GNU logs - #77914, boring messages

Message sent to bug-gnu-emacs@HIDDEN:

Subject: bug#77914: 31.0.50; treesit-font-lock-level set to 4 cause rust-ts-mode lost all color
Resent-From: Eval Exec <execvy@HIDDEN>
Original-Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>
Resent-CC: bug-gnu-emacs@HIDDEN
Resent-Date: Sat, 19 Apr 2025 05:12:02 +0000
Resent-Message-ID: <handler.77914.B.174503949922277 <at> debbugs.gnu.org>
Resent-Sender: help-debbugs@HIDDEN
To: 77914 <at> debbugs.gnu.org
From: Eval Exec <execvy@HIDDEN>
User-Agent: mu4e 1.12.9; emacs 31.0.50
Date: Sat, 19 Apr 2025 13:10:57 +0800
Message-ID: <877c3gka72.fsf@HIDDEN>
MIME-Version: 1.0
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: quoted-printable
Received-SPF: pass client-ip=2607:f8b0:4864:20::1042;
 envelope-from=execvy@HIDDEN; helo=mail-pj1-x1042.google.com
X-Spam_score_int: -20
X-Spam_score: -2.1
X-Spam_bar: --
X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1,
 DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_FROM=0.001,
 RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001,
 SPF_PASS=-0.001 autolearn=ham autolearn_force=no
X-Spam_action: no action
X-Spam-Score: 1.0 (+)
X-BeenThere: debbugs-submit <at> debbugs.gnu.org
X-Mailman-Version: 2.1.18
Precedence: list
List-Id: <debbugs-submit.debbugs.gnu.org>
List-Unsubscribe: <https://debbugs.gnu.org/cgi-bin/mailman/options/debbugs-submit>, 
 <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=unsubscribe>
List-Archive: <https://debbugs.gnu.org/cgi-bin/mailman/private/debbugs-submit/>
List-Post: <mailto:debbugs-submit <at> debbugs.gnu.org>
List-Help: <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=help>
List-Subscribe: <https://debbugs.gnu.org/cgi-bin/mailman/listinfo/debbugs-submit>, 
 <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=subscribe>
Errors-To: debbugs-submit-bounces <at> debbugs.gnu.org
Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>
X-Spam-Score: -0.0 (/)


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))=20
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))=20
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 =3D "rust1", since =3D "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 =3D "marker_trait", issue =3D "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 =3D "internal_impls_macro", issue =3D "none")]
// Allow implementations of `UnsizedConstParamTy` even though std cannot us=
e that feature.
#[allow_internal_unstable(unsized_const_params)]
macro marker_impls {
    ( $(#[$($meta:tt)*])* $Trait:ident for $({$($bounds:tt)*})? $T:ty $(, $=
($rest:tt)*)? ) =3D> {
        $(#[$($meta)*])* impl< $($($bounds)*)? > $Trait for $T {}
        marker_impls! { $(#[$($meta)*])* $Trait for $($($rest)*)? }
    },
    ( $(#[$($meta:tt)*])* $Trait:ident for ) =3D> {},

    ( $(#[$($meta:tt)*])* unsafe $Trait:ident for $({$($bounds:tt)*})? $T:t=
y $(, $($rest:tt)*)? ) =3D> {
        $(#[$($meta)*])* unsafe impl< $($($bounds)*)? > $Trait for $T {}
        marker_impls! { $(#[$($meta)*])* unsafe $Trait for $($($rest)*)? }
    },
    ( $(#[$($meta:tt)*])* unsafe $Trait:ident for ) =3D> {},
}

/// 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 a=
t the
/// same time, which is [undefined behavior][ub] because [`Rc`] doesn't use=
 atomic
/// operations. Its cousin [`sync::Arc`][arc] does use atomic operations (i=
ncurring
/// some overhead) and thus is `Send`.
///
/// See [the Nomicon](../../nomicon/send-and-sync.html) and the [`Sync`] tr=
ait for more details.
///
/// [`Rc`]: ../../std/rc/struct.Rc.html
/// [arc]: ../../std/sync/struct.Arc.html
/// [ub]: ../../reference/behavior-considered-undefined.html
#[stable(feature =3D "rust1", since =3D "1.0.0")]
#[cfg_attr(not(test), rustc_diagnostic_item =3D "Send")]
#[diagnostic::on_unimplemented(
    message =3D "`{Self}` cannot be sent between threads safely",
    label =3D "`{Self}` cannot be sent between threads safely"
)]
pub unsafe auto trait Send {
    // empty.
}

#[stable(feature =3D "rust1", since =3D "1.0.0")]
impl<T: ?Sized> !Send for *const T {}
#[stable(feature =3D "rust1", since =3D "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 =3D "rust1", since =3D "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 synt=
ax
/// `?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 [i=
32]
/// 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 obje=
ct]s
/// where, by definition, the trait needs to work with all possible impleme=
ntors,
/// 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 =3D &Impl;    // OK
/// // let y: &dyn Bar =3D &Impl; // error: the trait `Bar` cannot
///                             // be made into an object
/// ```
///
/// [trait object]: ../../book/ch17-02-trait-objects.html
#[doc(alias =3D "?", alias =3D "?Sized")]
#[stable(feature =3D "rust1", since =3D "1.0.0")]
#[lang =3D "sized"]
#[diagnostic::on_unimplemented(
    message =3D "the size for values of type `{Self}` cannot be known at co=
mpilation time",
    label =3D "doesn't have a size known at compile-time"
)]
#[fundamental] // for Default, for example, which requires that `[T]: !Defa=
ult` be evaluatable
#[rustc_specialization_trait]
#[cfg_attr(bootstrap, rustc_deny_explicit_impl(implement_via_object =3D fal=
se))]
#[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]>` a=
nd
/// `Unsize<dyn fmt::Debug>`.
///
/// All implementations of `Unsize` are provided automatically by the compi=
ler.
/// 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 o=
f these conditions
/// are met:
///   - Only the last field of `Foo` has a type involving the parameters `T=
1`, ..., `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 coe=
rcion][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-c=
oercion.md
/// [nomicon-coerce]: ../../nomicon/coercions.html
/// [^1]: Formerly known as *object safe*.
#[unstable(feature =3D "unsize", issue =3D "18598")]
#[lang =3D "unsize"]
#[cfg_attr(bootstrap, rustc_deny_explicit_impl(implement_via_object =3D fal=
se))]
#[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 constan=
t 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-rest=
rict-constants-in-patterns.md
/// [issue 63438]: https://github.com/rust-lang/rust/issues/63438
#[unstable(feature =3D "structural_match", issue =3D "31434")]
#[diagnostic::on_unimplemented(message =3D "the type `{Self}` does not `#[d=
erive(PartialEq)]`")]
#[lang =3D "structural_peq"]
pub trait StructuralPartialEq {
    // Empty.
}

marker_impls! {
    #[unstable(feature =3D "structural_match", issue =3D "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 =3D Foo;
///
/// let y =3D 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 =3D Foo;
///
/// let y =3D 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 o=
ptimized 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 su=
ch 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 =3D 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 [`Clo=
ne`] can
/// provide any type-specific behavior necessary to duplicate values safely=
. For example,
/// the implementation of [`Clone`] for [`String`] needs to copy the pointe=
d-to string
/// buffer in the heap. A simple bitwise copy of [`String`] values would me=
rely copy the
/// pointer, leading to a double free down the line. For this reason, [`Str=
ing`] 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 n=
eeds 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 eli=
gible 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 n=
ot `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` do=
es 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 foll=
owing 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 fo=
r 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. Kee=
p 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` implem=
entation 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 functi=
on)
/// * 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 `Co=
py`
///   (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 =3D "rust1", since =3D "1.0.0")]
#[lang =3D "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 =3D "Copy"]
pub trait Copy: Clone {
    // Empty.
}

/// Derive macro generating an impl of the trait `Copy`.
#[rustc_builtin_macro]
#[stable(feature =3D "builtin_macro_prelude", since =3D "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 =3D "rust1", since =3D "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 =3D "never_type", issue =3D "35121")]
impl Copy for ! {}

/// Shared references can be copied, but mutable references *cannot*!
#[stable(feature =3D "rust1", since =3D "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 requ=
ires
/// 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 =3D "rust1", since =3D "1.0.0")]
#[cfg_attr(not(test), rustc_diagnostic_item =3D "Sync")]
#[lang =3D "sync"]
#[rustc_on_unimplemented(
    on(
        _Self =3D "core::cell::once::OnceCell<T>",
        note =3D "if you want to do aliasing and mutation between multiple =
threads, use `std::sync::OnceLock` instead"
    ),
    on(
        _Self =3D "core::cell::Cell<u8>",
        note =3D "if you want to do aliasing and mutation between multiple =
threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicU8` instead",
    ),
    on(
        _Self =3D "core::cell::Cell<u16>",
        note =3D "if you want to do aliasing and mutation between multiple =
threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicU16` instead",
    ),
    on(
        _Self =3D "core::cell::Cell<u32>",
        note =3D "if you want to do aliasing and mutation between multiple =
threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicU32` instead",
    ),
    on(
        _Self =3D "core::cell::Cell<u64>",
        note =3D "if you want to do aliasing and mutation between multiple =
threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicU64` instead",
    ),
    on(
        _Self =3D "core::cell::Cell<usize>",
        note =3D "if you want to do aliasing and mutation between multiple =
threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicUsize` instea=
d",
    ),
    on(
        _Self =3D "core::cell::Cell<i8>",
        note =3D "if you want to do aliasing and mutation between multiple =
threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicI8` instead",
    ),
    on(
        _Self =3D "core::cell::Cell<i16>",
        note =3D "if you want to do aliasing and mutation between multiple =
threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicI16` instead",
    ),
    on(
        _Self =3D "core::cell::Cell<i32>",
        note =3D "if you want to do aliasing and mutation between multiple =
threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicI32` instead",
    ),
    on(
        _Self =3D "core::cell::Cell<i64>",
        note =3D "if you want to do aliasing and mutation between multiple =
threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicI64` instead",
    ),
    on(
        _Self =3D "core::cell::Cell<isize>",
        note =3D "if you want to do aliasing and mutation between multiple =
threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicIsize` instea=
d",
    ),
    on(
        _Self =3D "core::cell::Cell<bool>",
        note =3D "if you want to do aliasing and mutation between multiple =
threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicBool` instead=
",
    ),
    on(
        all(
            _Self =3D "core::cell::Cell<T>",
            not(_Self =3D "core::cell::Cell<u8>"),
            not(_Self =3D "core::cell::Cell<u16>"),
            not(_Self =3D "core::cell::Cell<u32>"),
            not(_Self =3D "core::cell::Cell<u64>"),
            not(_Self =3D "core::cell::Cell<usize>"),
            not(_Self =3D "core::cell::Cell<i8>"),
            not(_Self =3D "core::cell::Cell<i16>"),
            not(_Self =3D "core::cell::Cell<i32>"),
            not(_Self =3D "core::cell::Cell<i64>"),
            not(_Self =3D "core::cell::Cell<isize>"),
            not(_Self =3D "core::cell::Cell<bool>")
        ),
        note =3D "if you want to do aliasing and mutation between multiple =
threads, use `std::sync::RwLock`",
    ),
    on(
        _Self =3D "core::cell::RefCell<T>",
        note =3D "if you want to do aliasing and mutation between multiple =
threads, use `std::sync::RwLock` instead",
    ),
    message =3D "`{Self}` cannot be shared between threads safely",
    label =3D "`{Self}` cannot be shared between threads safely"
)]
pub unsafe auto trait Sync {
    // FIXME(estebank): once support to add notes in `rustc_on_unimplemente=
d`
    // 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=3D"`{Self}` cannot be shared safely, consider marking the c=
losure `move`"
    // ),
    // ```

    // Empty
}

#[stable(feature =3D "rust1", since =3D "1.0.0")]
impl<T: ?Sized> !Sync for *const T {}
#[stable(feature =3D "rust1", since =3D "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 yo=
ur
/// 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 properti=
es.
///
/// For a more in-depth explanation of how to use `PhantomData<T>`, please =
see
/// [the Nomicon](../../nomicon/phantom-data.html).
///
/// # A ghastly note =F0=9F=91=BB=F0=9F=91=BB=F0=9F=91=BB
///
/// 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 `PhantomDa=
ta`.
///
/// # 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 =3D 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-ca=
ll-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 =3D 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 =3D 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 co=
mpiler'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>>() =3D=3D 0`
/// * `align_of::<PhantomData<T>>() =3D=3D 1`
///
/// [drop check]: Drop#drop-check
#[lang =3D "phantom_data"]
#[stable(feature =3D "rust1", since =3D "1.0.0")]
pub struct PhantomData<T: ?Sized>;

#[stable(feature =3D "rust1", since =3D "1.0.0")]
impl<T: ?Sized> Hash for PhantomData<T> {
    #[inline]
    fn hash<H: Hasher>(&self, _: &mut H) {}
}

#[stable(feature =3D "rust1", since =3D "1.0.0")]
impl<T: ?Sized> cmp::PartialEq for PhantomData<T> {
    fn eq(&self, _other: &PhantomData<T>) -> bool {
        true
    }
}

#[stable(feature =3D "rust1", since =3D "1.0.0")]
impl<T: ?Sized> cmp::Eq for PhantomData<T> {}

#[stable(feature =3D "rust1", since =3D "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 =3D "rust1", since =3D "1.0.0")]
impl<T: ?Sized> cmp::Ord for PhantomData<T> {
    fn cmp(&self, _other: &PhantomData<T>) -> cmp::Ordering {
        cmp::Ordering::Equal
    }
}

#[stable(feature =3D "rust1", since =3D "1.0.0")]
impl<T: ?Sized> Copy for PhantomData<T> {}

#[stable(feature =3D "rust1", since =3D "1.0.0")]
impl<T: ?Sized> Clone for PhantomData<T> {
    fn clone(&self) -> Self {
        Self
    }
}

#[stable(feature =3D "rust1", since =3D "1.0.0")]
impl<T: ?Sized> Default for PhantomData<T> {
    fn default() -> Self {
        Self
    }
}

#[unstable(feature =3D "structural_match", issue =3D "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 tr=
ansmute
/// between `DiscriminantKind::Discriminant` and `mem::Discriminant`.
///
/// [`mem::Discriminant`]: crate::mem::Discriminant
#[unstable(
    feature =3D "discriminant_kind",
    issue =3D "none",
    reason =3D "this trait is unlikely to ever be stabilized, use `mem::dis=
criminant` instead"
)]
#[lang =3D "discriminant_kind"]
#[cfg_attr(bootstrap, rustc_deny_explicit_impl(implement_via_object =3D fal=
se))]
#[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 =3D "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 tr=
ait 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 =3D "freeze"]
#[unstable(feature =3D "freeze", issue =3D "121675")]
pub unsafe auto trait Freeze {}

#[unstable(feature =3D "freeze", issue =3D "121675")]
impl<T: ?Sized> !Freeze for UnsafeCell<T> {}
marker_impls! {
    #[unstable(feature =3D "freeze", issue =3D "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] documentat=
ion.
///
/// Implementing the `Unpin` trait for `T` expresses the fact that `T` is p=
inning-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>`] po=
inting 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 t=
hat 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 imple=
ment `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 soun=
dly.
///
/// For more discussion on the consequences of [`Unpin`] within the wider s=
cope 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::repla=
ce`] works for any
/// `&mut T`, not just when `T: Unpin`).
///
/// *However*, you cannot use [`mem::replace`] on `!Unpin` data which is *p=
inned* by being wrapped
/// inside a [`Pin<Ptr>`] pointing at it. This is because you cannot (safel=
y) use a
/// [`Pin<Ptr>`] to get a `&mut T` to its pointee value, which you would ne=
ed 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 =3D "this".to_string();
/// let mut pinned_string =3D 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 comp=
iler is free
/// to take the conservative stance of marking types as [`Unpin`] so long a=
s all of the types that
/// compose its fields are also [`Unpin`]. This is because if a type implem=
ents [`Unpin`], then it
/// is unsound for that type's implementation to rely on pinning-related gu=
arantees for soundness,
/// *even* when viewed through a "pinning" pointer! It is the responsibilit=
y of the implementor of
/// a type that relies upon pinning for soundness to ensure that type is *n=
ot* marked as [`Unpin`]
/// by adding [`PhantomPinned`] field. For more details, see the [`pin` mod=
ule] 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 =3D "pin", since =3D "1.33.0")]
#[diagnostic::on_unimplemented(
    note =3D "consider using the `pin!` macro\nconsider using `Box::pin` if=
 you need to access the pinned value outside of the current scope",
    message =3D "`{Self}` cannot be unpinned"
)]
#[lang =3D "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 =3D "pin", since =3D "1.33.0")]
#[derive(Debug, Default, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct PhantomPinned;

#[stable(feature =3D "pin", since =3D "1.33.0")]
impl !Unpin for PhantomPinned {}

marker_impls! {
    #[stable(feature =3D "pin", since =3D "1.33.0")]
    Unpin for
        {T: ?Sized} &T,
        {T: ?Sized} &mut T,
}

marker_impls! {
    #[stable(feature =3D "pin_raw", since =3D "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 =3D "const_destruct", issue =3D "133214")]
#[lang =3D "destruct"]
#[rustc_on_unimplemented(message =3D "can't drop `{Self}`", append_const_ms=
g)]
#[cfg_attr(bootstrap, rustc_deny_explicit_impl(implement_via_object =3D fal=
se))]
#[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 =3D "tuple_trait", issue =3D "none")]
#[lang =3D "tuple_trait"]
#[diagnostic::on_unimplemented(message =3D "`{Self}` is not a tuple")]
#[cfg_attr(bootstrap, rustc_deny_explicit_impl(implement_via_object =3D fal=
se))]
#[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=E2=80=99s sole non-zero-sized field must itself implement `P=
ointerLike`.
#[unstable(feature =3D "pointer_like_trait", issue =3D "none")]
#[lang =3D "pointer_like"]
#[diagnostic::on_unimplemented(
    message =3D "`{Self}` needs to have the same ABI as a pointer",
    label =3D "`{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 =3D "pointer_like_trait", issue =3D "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 parame=
ters.
///
/// These types must have a proper equivalence relation (`Eq`) and it must =
be automatically
/// derived (`StructuralPartialEq`). There's a hard-coded check in the comp=
iler ensuring
/// that all fields are also `ConstParamTy`, which implies that recursively=
, all fields
/// are `StructuralPartialEq`.
#[lang =3D "const_param_ty"]
#[unstable(feature =3D "unsized_const_params", issue =3D "95174")]
#[diagnostic::on_unimplemented(message =3D "`{Self}` can't be used as a con=
st parameter type")]
#[allow(multiple_supertrait_upcastable)]
// We name this differently than the derive macro so that the `adt_const_pa=
rams` 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 sta=
bilization.
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 =3D "adt_const_params", issue =3D "95174")]
pub macro ConstParamTy($item:item) {
    /* compiler built-in */
}

#[lang =3D "unsized_const_param_ty"]
#[unstable(feature =3D "unsized_const_params", issue =3D "95174")]
#[diagnostic::on_unimplemented(message =3D "`{Self}` can't be used as a con=
st parameter type")]
/// A marker for types which can be used as types of `const` generic parame=
ters.
///
/// 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 =3D "unsized_const_params", issue =3D "95174")]
pub macro UnsizedConstParamTy($item:item) {
    /* compiler built-in */
}

// FIXME(adt_const_params): handle `ty::FnDef`/`ty::Closure`
marker_impls! {
    #[unstable(feature =3D "adt_const_params", issue =3D "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 =3D "unsized_const_params", issue =3D "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 =3D "fn_ptr_trait",
    issue =3D "none",
    reason =3D "internal trait for implementing various traits for all func=
tion pointers"
)]
#[lang =3D "fn_ptr_trait"]
#[cfg_attr(bootstrap, rustc_deny_explicit_impl(implement_via_object =3D fal=
se))]
#[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 =3D "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 =3D "derive_coerce_pointee", issue =3D "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=3D-O3 -march=3Dnative'
 --prefix=3D/home/exec/Projects/git.savannah.gnu.org/git/emacs-build/featur=
e_igc-7b35a5062231ec5a11c7a87d4797cfb5dba25121-O3
 --with-mps=3Dyes --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=3Dinotify'

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=3Dfcitx
  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/e=
xec/.emacs.d/elpaca/builds/standard-themes/theme-loaddefs
/home/exec/.emacs.d/elpaca/builds/modus-themes/theme-loaddefs hides /home/e=
xec/.emacs.d/elpaca/builds/ef-themes/theme-loaddefs
/home/exec/.emacs.d/elpaca/builds/modus-themes/theme-loaddefs hides /home/e=
xec/Projects/git.savannah.gnu.org/git/emacs-build/feature_igc-7b35a5062231e=
c5a11c7a87d4797cfb5dba25121-O3/share/emacs/31.0.50/lisp/theme-loaddefs
/home/exec/.emacs.d/elpaca/builds/transient/transient hides /home/exec/Proj=
ects/git.savannah.gnu.org/git/emacs-build/feature_igc-7b35a5062231ec5a11c7a=
87d4797cfb5dba25121-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))

--=20

Message sent:

Content-Disposition: inline
Content-Transfer-Encoding: quoted-printable
MIME-Version: 1.0
X-Mailer: MIME-tools 5.505 (Entity 5.505)
Content-Type: text/plain; charset=utf-8
X-Loop: help-debbugs@HIDDEN
From: help-debbugs@HIDDEN (GNU bug Tracking System)
To: Eval Exec <execvy@HIDDEN>
Subject: bug#77914: Acknowledgement (31.0.50; treesit-font-lock-level set
 to 4 cause rust-ts-mode lost all color)
Message-ID: <handler.77914.B.174503949922277.ack <at> debbugs.gnu.org>
References: <877c3gka72.fsf@HIDDEN>
X-Gnu-PR-Message: ack 77914
X-Gnu-PR-Package: emacs
Reply-To: 77914 <at> debbugs.gnu.org
Date: Sat, 19 Apr 2025 05:12:02 +0000

Thank you for filing a new bug report with debbugs.gnu.org.

This is an automatically generated reply to let you know your message
has been received.

Your message is being forwarded to the package maintainers and other
interested parties for their attention; they will reply in due course.

Your message has been sent to the package maintainer(s):
 bug-gnu-emacs@HIDDEN

If you wish to submit further information on this problem, please
send it to 77914 <at> debbugs.gnu.org.

Please do not send mail to help-debbugs@HIDDEN unless you wish
to report a problem with the Bug-tracking system.

--=20
77914: https://debbugs.gnu.org/cgi/bugreport.cgi?bug=3D77914
GNU Bug Tracking System
Contact help-debbugs@HIDDEN with problems

Message sent to bug-gnu-emacs@HIDDEN:

Subject: bug#77914: 31.0.50; treesit-font-lock-level set to 4 cause rust-ts-mode lost all color
Resent-From: Vincenzo Pupillo <v.pupillo@HIDDEN>
Original-Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>
Resent-CC: bug-gnu-emacs@HIDDEN
Resent-Date: Sat, 19 Apr 2025 22:13:02 +0000
Resent-Message-ID: <handler.77914.B.174510077531554 <at> debbugs.gnu.org>
Resent-Sender: help-debbugs@HIDDEN
To: 77914 <at> debbugs.gnu.org
Cc: Eval Exec <execvy@HIDDEN>
From: Vincenzo Pupillo <v.pupillo@HIDDEN>
Date: Sun, 20 Apr 2025 00:12:34 +0200
Message-ID: <3523927.LZWGnKmheA@fedora>
In-Reply-To: <877c3gka72.fsf@HIDDEN>
References: <877c3gka72.fsf@HIDDEN>
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary="nextPart7128439.9J7NaK4W3v"
Content-Transfer-Encoding: 7Bit
Received-SPF: pass client-ip=2a00:1450:4864:20::429;
 envelope-from=v.pupillo@HIDDEN; helo=mail-wr1-x429.google.com
X-Spam_score_int: -20
X-Spam_score: -2.1
X-Spam_bar: --
X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1,
 DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_FROM=0.001,
 RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001,
 SPF_PASS=-0.001 autolearn=ham autolearn_force=no
X-Spam_action: no action
X-BeenThere: debbugs-submit <at> debbugs.gnu.org
X-Mailman-Version: 2.1.18
Precedence: list
List-Id: <debbugs-submit.debbugs.gnu.org>
List-Unsubscribe: <https://debbugs.gnu.org/cgi-bin/mailman/options/debbugs-submit>, 
 <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=unsubscribe>
List-Archive: <https://debbugs.gnu.org/cgi-bin/mailman/private/debbugs-submit/>
List-Post: <mailto:debbugs-submit <at> debbugs.gnu.org>
List-Help: <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=help>
List-Subscribe: <https://debbugs.gnu.org/cgi-bin/mailman/listinfo/debbugs-submit>, 
 <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=subscribe>
Errors-To: debbugs-submit-bounces <at> debbugs.gnu.org
Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>

This is a multi-part message in MIME format.

--nextPart7128439.9J7NaK4W3v
Content-Transfer-Encoding: quoted-printable
Content-Type: text/plain; charset="utf-8"

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=E2=80=99Europa centr=
ale, Eval=20
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:
>=20
> Then eval:
> 1. (progn  (setq treesit-font-lock-level 4) (revert-buffer))
> all color are lost.
>=20
> 2. (progn  (setq treesit-font-lock-level 4) (revert-buffer))
> colors are good.
>=20
> 3. (progn  (setq treesit-font-lock-level 4) (revert-buffer))
> all color are lost again.
>=20
>=20
> ```rust
>=20
> //! 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.
>=20
> #![stable(feature =3D "rust1", since =3D "1.0.0")]
>=20
> use crate::cell::UnsafeCell;
> use crate::cmp;
> use crate::fmt::Debug;
> use crate::hash::{Hash, Hasher};
>=20
> /// 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 =3D "marker_trait", issue =3D "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 =3D "internal_impls_macro", issue =3D "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)*)? ) =3D> { $(#[$($meta)*])* impl< $($($bounds)*)? > $Trait f=
or
> $T {}
>         marker_impls! { $(#[$($meta)*])* $Trait for $($($rest)*)? }
>     },
>     ( $(#[$($meta:tt)*])* $Trait:ident for ) =3D> {},
>=20
>     ( $(#[$($meta:tt)*])* unsafe $Trait:ident for $({$($bounds:tt)*})? $T=
:ty
> $(, $($rest:tt)*)? ) =3D> { $(#[$($meta)*])* unsafe impl< $($($bounds)*)?=
 >
> $Trait for $T {} marker_impls! { $(#[$($meta)*])* unsafe $Trait for
> $($($rest)*)? } },
>     ( $(#[$($meta:tt)*])* unsafe $Trait:ident for ) =3D> {},
> }
>=20
> /// 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 overhea=
d)
> 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 =3D "rust1", since =3D "1.0.0")]
> #[cfg_attr(not(test), rustc_diagnostic_item =3D "Send")]
> #[diagnostic::on_unimplemented(
>     message =3D "`{Self}` cannot be sent between threads safely",
>     label =3D "`{Self}` cannot be sent between threads safely"
> )]
> pub unsafe auto trait Send {
>     // empty.
> }
>=20
> #[stable(feature =3D "rust1", since =3D "1.0.0")]
> impl<T: ?Sized> !Send for *const T {}
> #[stable(feature =3D "rust1", since =3D "1.0.0")]
> impl<T: ?Sized> !Send for *mut T {}
>=20
> // 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 =3D "rust1", since =3D "1.0.0")]
> unsafe impl<T: Sync + ?Sized> Send for &T {}
>=20
> /// 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 =3D &Impl;    // OK
> /// // let y: &dyn Bar =3D &Impl; // error: the trait `Bar` cannot
> ///                             // be made into an object
> /// ```
> ///
> /// [trait object]: ../../book/ch17-02-trait-objects.html
> #[doc(alias =3D "?", alias =3D "?Sized")]
> #[stable(feature =3D "rust1", since =3D "1.0.0")]
> #[lang =3D "sized"]
> #[diagnostic::on_unimplemented(
>     message =3D "the size for values of type `{Self}` cannot be known at
> compilation time", label =3D "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 =3D
> 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.
> }
>=20
> /// 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 conditio=
ns
> 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<..=
=2E>`
> 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 =3D "unsize", issue =3D "18598")]
> #[lang =3D "unsize"]
> #[cfg_attr(bootstrap, rustc_deny_explicit_impl(implement_via_object =3D
> 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.
> }
>=20
> /// 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 tra=
it,
> /// 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 const=
ant
> 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 =3D "structural_match", issue =3D "31434")]
> #[diagnostic::on_unimplemented(message =3D "the type `{Self}` does not
> `#[derive(PartialEq)]`")] #[lang =3D "structural_peq"]
> pub trait StructuralPartialEq {
>     // Empty.
> }
>=20
> marker_impls! {
>     #[unstable(feature =3D "structural_match", issue =3D "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,
> }
>=20
> /// 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 =3D Foo;
> ///
> /// let y =3D 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 =3D Foo;
> ///
> /// let y =3D 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 wi=
ll
> 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 =3D=
 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 duplica=
te
> 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 /// pointe=
r,
> 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` mu=
st
> 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`, ev=
en
> 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` fr=
om
> 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 duplica=
te
> 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-`Co=
py`
> 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. K=
eep
> 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 =3D "rust1", since =3D "1.0.0")]
> #[lang =3D "copy"]
> // FIXME(matthewjasper) This allows copying a type that doesn't implement
> // `Copy` because of unsatisfied lifetime bounds (copying `A<'_>` when on=
ly
> // `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 =3D "Copy"]
> pub trait Copy: Clone {
>     // Empty.
> }
>=20
> /// Derive macro generating an impl of the trait `Copy`.
> #[rustc_builtin_macro]
> #[stable(feature =3D "builtin_macro_prelude", since =3D "1.38.0")]
> #[allow_internal_unstable(core_intrinsics, derive_clone_copy)]
> pub macro Copy($item:item) {
>     /* compiler built-in */
> }
>=20
> // 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 =3D "rust1", since =3D "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,
>=20
> }
>=20
> #[unstable(feature =3D "never_type", issue =3D "35121")]
> impl Copy for ! {}
>=20
> /// Shared references can be copied, but mutable references *cannot*!
> #[stable(feature =3D "rust1", since =3D "1.0.0")]
> impl<T: ?Sized> Copy for &T {}
>=20
> /// 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 w=
ay.
> ///
> /// 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 =3D "rust1", since =3D "1.0.0")]
> #[cfg_attr(not(test), rustc_diagnostic_item =3D "Sync")]
> #[lang =3D "sync"]
> #[rustc_on_unimplemented(
>     on(
>         _Self =3D "core::cell::once::OnceCell<T>",
>         note =3D "if you want to do aliasing and mutation between multiple
> threads, use `std::sync::OnceLock` instead" ),
>     on(
>         _Self =3D "core::cell::Cell<u8>",
>         note =3D "if you want to do aliasing and mutation between multiple
> threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicU8` instead=
",
> ),
>     on(
>         _Self =3D "core::cell::Cell<u16>",
>         note =3D "if you want to do aliasing and mutation between multiple
> threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicU16`
> instead", ),
>     on(
>         _Self =3D "core::cell::Cell<u32>",
>         note =3D "if you want to do aliasing and mutation between multiple
> threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicU32`
> instead", ),
>     on(
>         _Self =3D "core::cell::Cell<u64>",
>         note =3D "if you want to do aliasing and mutation between multiple
> threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicU64`
> instead", ),
>     on(
>         _Self =3D "core::cell::Cell<usize>",
>         note =3D "if you want to do aliasing and mutation between multiple
> threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicUsize`
> instead", ),
>     on(
>         _Self =3D "core::cell::Cell<i8>",
>         note =3D "if you want to do aliasing and mutation between multiple
> threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicI8` instead=
",
> ),
>     on(
>         _Self =3D "core::cell::Cell<i16>",
>         note =3D "if you want to do aliasing and mutation between multiple
> threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicI16`
> instead", ),
>     on(
>         _Self =3D "core::cell::Cell<i32>",
>         note =3D "if you want to do aliasing and mutation between multiple
> threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicI32`
> instead", ),
>     on(
>         _Self =3D "core::cell::Cell<i64>",
>         note =3D "if you want to do aliasing and mutation between multiple
> threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicI64`
> instead", ),
>     on(
>         _Self =3D "core::cell::Cell<isize>",
>         note =3D "if you want to do aliasing and mutation between multiple
> threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicIsize`
> instead", ),
>     on(
>         _Self =3D "core::cell::Cell<bool>",
>         note =3D "if you want to do aliasing and mutation between multiple
> threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicBool`
> instead", ),
>     on(
>         all(
>             _Self =3D "core::cell::Cell<T>",
>             not(_Self =3D "core::cell::Cell<u8>"),
>             not(_Self =3D "core::cell::Cell<u16>"),
>             not(_Self =3D "core::cell::Cell<u32>"),
>             not(_Self =3D "core::cell::Cell<u64>"),
>             not(_Self =3D "core::cell::Cell<usize>"),
>             not(_Self =3D "core::cell::Cell<i8>"),
>             not(_Self =3D "core::cell::Cell<i16>"),
>             not(_Self =3D "core::cell::Cell<i32>"),
>             not(_Self =3D "core::cell::Cell<i64>"),
>             not(_Self =3D "core::cell::Cell<isize>"),
>             not(_Self =3D "core::cell::Cell<bool>")
>         ),
>         note =3D "if you want to do aliasing and mutation between multiple
> threads, use `std::sync::RwLock`", ),
>     on(
>         _Self =3D "core::cell::RefCell<T>",
>         note =3D "if you want to do aliasing and mutation between multiple
> threads, use `std::sync::RwLock` instead", ),
>     message =3D "`{Self}` cannot be shared between threads safely",
>     label =3D "`{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=3D"`{Self}` cannot be shared safely, consider marking the
> closure `move`" // ),
>     // ```
>=20
>     // Empty
> }
>=20
> #[stable(feature =3D "rust1", since =3D "1.0.0")]
> impl<T: ?Sized> !Sync for *const T {}
> #[stable(feature =3D "rust1", since =3D "1.0.0")]
> impl<T: ?Sized> !Sync for *mut T {}
>=20
> /// 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 =F0=9F=91=BB=F0=9F=91=BB=F0=9F=91=BB
> ///
> /// 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 h=
as
> 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 =3D 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 =3D 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 =3D 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 exa=
ct
> rules, see the [drop check] documentation. ///
> /// ## Layout
> ///
> /// For all `T`, the following are guaranteed:
> /// * `size_of::<PhantomData<T>>() =3D=3D 0`
> /// * `align_of::<PhantomData<T>>() =3D=3D 1`
> ///
> /// [drop check]: Drop#drop-check
> #[lang =3D "phantom_data"]
> #[stable(feature =3D "rust1", since =3D "1.0.0")]
> pub struct PhantomData<T: ?Sized>;
>=20
> #[stable(feature =3D "rust1", since =3D "1.0.0")]
> impl<T: ?Sized> Hash for PhantomData<T> {
>     #[inline]
>     fn hash<H: Hasher>(&self, _: &mut H) {}
> }
>=20
> #[stable(feature =3D "rust1", since =3D "1.0.0")]
> impl<T: ?Sized> cmp::PartialEq for PhantomData<T> {
>     fn eq(&self, _other: &PhantomData<T>) -> bool {
>         true
>     }
> }
>=20
> #[stable(feature =3D "rust1", since =3D "1.0.0")]
> impl<T: ?Sized> cmp::Eq for PhantomData<T> {}
>=20
> #[stable(feature =3D "rust1", since =3D "1.0.0")]
> impl<T: ?Sized> cmp::PartialOrd for PhantomData<T> {
>     fn partial_cmp(&self, _other: &PhantomData<T>) -> Option<cmp::Orderin=
g>
> { Option::Some(cmp::Ordering::Equal)
>     }
> }
>=20
> #[stable(feature =3D "rust1", since =3D "1.0.0")]
> impl<T: ?Sized> cmp::Ord for PhantomData<T> {
>     fn cmp(&self, _other: &PhantomData<T>) -> cmp::Ordering {
>         cmp::Ordering::Equal
>     }
> }
>=20
> #[stable(feature =3D "rust1", since =3D "1.0.0")]
> impl<T: ?Sized> Copy for PhantomData<T> {}
>=20
> #[stable(feature =3D "rust1", since =3D "1.0.0")]
> impl<T: ?Sized> Clone for PhantomData<T> {
>     fn clone(&self) -> Self {
>         Self
>     }
> }
>=20
> #[stable(feature =3D "rust1", since =3D "1.0.0")]
> impl<T: ?Sized> Default for PhantomData<T> {
>     fn default() -> Self {
>         Self
>     }
> }
>=20
> #[unstable(feature =3D "structural_match", issue =3D "31434")]
> impl<T: ?Sized> StructuralPartialEq for PhantomData<T> {}
>=20
> /// Compiler-internal trait used to indicate the type of enum discriminan=
ts.
> ///
> /// This trait is automatically implemented for every type and does not a=
dd
> any /// guarantees to [`mem::Discriminant`]. It is **undefined behavior**
> to transmute /// between `DiscriminantKind::Discriminant` and
> `mem::Discriminant`. ///
> /// [`mem::Discriminant`]: crate::mem::Discriminant
> #[unstable(
>     feature =3D "discriminant_kind",
>     issue =3D "none",
>     reason =3D "this trait is unlikely to ever be stabilized, use
> `mem::discriminant` instead" )]
> #[lang =3D "discriminant_kind"]
> #[cfg_attr(bootstrap, rustc_deny_explicit_impl(implement_via_object =3D
> 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 =3D "discriminant_type"]
>     type Discriminant: Clone + Copy + Debug + Eq + PartialEq + Hash + Sen=
d +
> Sync + Unpin; }
>=20
> /// 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=
 =3D
> "freeze"]
> #[unstable(feature =3D "freeze", issue =3D "121675")]
> pub unsafe auto trait Freeze {}
>=20
> #[unstable(feature =3D "freeze", issue =3D "121675")]
> impl<T: ?Sized> !Freeze for UnsafeCell<T> {}
> marker_impls! {
>     #[unstable(feature =3D "freeze", issue =3D "121675")]
>     unsafe Freeze for
>         {T: ?Sized} PhantomData<T>,
>         {T: ?Sized} *const T,
>         {T: ?Sized} *mut T,
>         {T: ?Sized} &T,
>         {T: ?Sized} &mut T,
> }
>=20
> /// 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 /// whi=
ch
> 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 whi=
ch
> 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 impleme=
nt
> `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 i=
ts
> 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 =3D "this".to_string();
> /// let mut pinned_string =3D 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 unpi=
n"
> /// [`unsafe`]: ../../std/keyword.unsafe.html "keyword unsafe"
> #[stable(feature =3D "pin", since =3D "1.33.0")]
> #[diagnostic::on_unimplemented(
>     note =3D "consider using the `pin!` macro\nconsider using `Box::pin` =
if
> you need to access the pinned value outside of the current scope", message
> =3D "`{Self}` cannot be unpinned"
> )]
> #[lang =3D "unpin"]
> pub auto trait Unpin {}
>=20
> /// A marker type which does not implement `Unpin`.
> ///
> /// If a type contains a `PhantomPinned`, it will not implement `Unpin` by
> default. #[stable(feature =3D "pin", since =3D "1.33.0")]
> #[derive(Debug, Default, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Has=
h)]
> pub struct PhantomPinned;
>=20
> #[stable(feature =3D "pin", since =3D "1.33.0")]
> impl !Unpin for PhantomPinned {}
>=20
> marker_impls! {
>     #[stable(feature =3D "pin", since =3D "1.33.0")]
>     Unpin for
>         {T: ?Sized} &T,
>         {T: ?Sized} &mut T,
> }
>=20
> marker_impls! {
>     #[stable(feature =3D "pin_raw", since =3D "1.38.0")]
>     Unpin for
>         {T: ?Sized} *const T,
>         {T: ?Sized} *mut T,
> }
>=20
> /// 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 =3D "const_destruct", issue =3D "133214")]
> #[lang =3D "destruct"]
> #[rustc_on_unimplemented(message =3D "can't drop `{Self}`", append_const_=
msg)]
> #[cfg_attr(bootstrap, rustc_deny_explicit_impl(implement_via_object =3D
> 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 {}
>=20
> /// A marker for tuple types.
> ///
> /// The implementation of this trait is built-in and cannot be implemented
> /// for any user type.
> #[unstable(feature =3D "tuple_trait", issue =3D "none")]
> #[lang =3D "tuple_trait"]
> #[diagnostic::on_unimplemented(message =3D "`{Self}` is not a tuple")]
> #[cfg_attr(bootstrap, rustc_deny_explicit_impl(implement_via_object =3D
> false))] #[cfg_attr(not(bootstrap), rustc_deny_explicit_impl)]
> #[cfg_attr(not(bootstrap), rustc_do_not_implement_via_object)]
> pub trait Tuple {}
>=20
> /// 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=E2=80=99s sole non-zero-sized field must itself implement
> `PointerLike`. #[unstable(feature =3D "pointer_like_trait", issue =3D "no=
ne")]
> #[lang =3D "pointer_like"]
> #[diagnostic::on_unimplemented(
>     message =3D "`{Self}` needs to have the same ABI as a pointer",
>     label =3D "`{Self}` needs to be a pointer-like type"
> )]
> #[cfg_attr(not(bootstrap), rustc_do_not_implement_via_object)]
> pub trait PointerLike {}
>=20
> #[cfg(not(bootstrap))]
> marker_impls! {
>     #[unstable(feature =3D "pointer_like_trait", issue =3D "none")]
>     PointerLike for
>         isize,
>         usize,
>         {T} &T,
>         {T} &mut T,
>         {T} *const T,
>         {T} *mut T,
>         {T: PointerLike} crate::pin::Pin<T>,
> }
>=20
> /// 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 =3D "const_param_ty"]
> #[unstable(feature =3D "unsized_const_params", issue =3D "95174")]
> #[diagnostic::on_unimplemented(message =3D "`{Self}` can't be used as a c=
onst
> 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 use=
d.
> This should be renamed on stabilization. pub trait ConstParamTy_:
> UnsizedConstParamTy + StructuralPartialEq + Eq {}
>=20
> /// Derive macro generating an impl of the trait `ConstParamTy`.
> #[rustc_builtin_macro]
> #[allow_internal_unstable(unsized_const_params)]
> #[unstable(feature =3D "adt_const_params", issue =3D "95174")]
> pub macro ConstParamTy($item:item) {
>     /* compiler built-in */
> }
>=20
> #[lang =3D "unsized_const_param_ty"]
> #[unstable(feature =3D "unsized_const_params", issue =3D "95174")]
> #[diagnostic::on_unimplemented(message =3D "`{Self}` can't be used as a c=
onst
> 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 {}
>=20
> /// Derive macro generating an impl of the trait `ConstParamTy`.
> #[rustc_builtin_macro]
> #[allow_internal_unstable(unsized_const_params)]
> #[unstable(feature =3D "unsized_const_params", issue =3D "95174")]
> pub macro UnsizedConstParamTy($item:item) {
>     /* compiler built-in */
> }
>=20
> // FIXME(adt_const_params): handle `ty::FnDef`/`ty::Closure`
> marker_impls! {
>     #[unstable(feature =3D "adt_const_params", issue =3D "95174")]
>     ConstParamTy_ for
>         usize, u8, u16, u32, u64, u128,
>         isize, i8, i16, i32, i64, i128,
>         bool,
>         char,
>         (),
>         {T: ConstParamTy_, const N: usize} [T; N],
> }
>=20
> marker_impls! {
>     #[unstable(feature =3D "unsized_const_params", issue =3D "95174")]
>     UnsizedConstParamTy for
>         usize, u8, u16, u32, u64, u128,
>         isize, i8, i16, i32, i64, i128,
>         bool,
>         char,
>         (),
>         {T: UnsizedConstParamTy, const N: usize} [T; N],
>=20
>         str,
>         {T: UnsizedConstParamTy} [T],
>         {T: UnsizedConstParamTy + ?Sized} &T,
> }
>=20
> /// A common trait implemented by all function pointers.
> #[unstable(
>     feature =3D "fn_ptr_trait",
>     issue =3D "none",
>     reason =3D "internal trait for implementing various traits for all
> function pointers" )]
> #[lang =3D "fn_ptr_trait"]
> #[cfg_attr(bootstrap, rustc_deny_explicit_impl(implement_via_object =3D
> 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 =3D "fn_ptr_addr"]
>     fn addr(self) -> *const ();
> }
>=20
> /// 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 =3D "derive_coerce_pointee", issue =3D "123430")]
> #[cfg(not(bootstrap))]
> pub macro CoercePointee($item:item) {
>     /* compiler built-in */
> }
>=20
>=20
> ```
>=20
>=20
> 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)
>=20
> Configured using:
>  'configure 'CFLAGS=3D-O3 -march=3Dnative'
>  --prefix=3D/home/exec/Projects/git.savannah.gnu.org/git/emacs-build/feat=
ure_i
> gc-7b35a5062231ec5a11c7a87d4797cfb5dba25121-O3 --with-mps=3Dyes
> --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=3Dinotify'
>=20
> 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
>=20
> 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=3Dfcitx
>   locale-coding-system: utf-8-unix
>=20
> Major mode: Elisp/l
>=20
> 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
>=20
> 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
>=20
> 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)
>=20
> 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))


--nextPart7128439.9J7NaK4W3v
Content-Disposition: attachment; filename="rust-grammar-bug.png"
Content-Transfer-Encoding: base64
Content-Type: image/png; name="rust-grammar-bug.png"
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--nextPart7128439.9J7NaK4W3v--

Message sent to bug-gnu-emacs@HIDDEN:

Subject: bug#77914: 31.0.50; treesit-font-lock-level set to 4 cause rust-ts-mode lost all color
Resent-From: Vincenzo Pupillo <v.pupillo@HIDDEN>
Original-Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>
Resent-CC: bug-gnu-emacs@HIDDEN
Resent-Date: Sat, 19 Apr 2025 22:13:02 +0000
Resent-Message-ID: <handler.77914.B77914.174510076731532 <at> debbugs.gnu.org>
Resent-Sender: help-debbugs@HIDDEN
To: 77914 <at> debbugs.gnu.org
Cc: Eval Exec <execvy@HIDDEN>
From: Vincenzo Pupillo <v.pupillo@HIDDEN>
Date: Sun, 20 Apr 2025 00:12:34 +0200
Message-ID: <3523927.LZWGnKmheA@fedora>
In-Reply-To: <877c3gka72.fsf@HIDDEN>
References: <877c3gka72.fsf@HIDDEN>
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary="nextPart7128439.9J7NaK4W3v"
Content-Transfer-Encoding: 7Bit
Precedence: list
Errors-To: debbugs-submit-bounces <at> debbugs.gnu.org
Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>

This is a multi-part message in MIME format.

--nextPart7128439.9J7NaK4W3v
Content-Transfer-Encoding: quoted-printable
Content-Type: text/plain; charset="utf-8"

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=E2=80=99Europa centr=
ale, Eval=20
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:
>=20
> Then eval:
> 1. (progn  (setq treesit-font-lock-level 4) (revert-buffer))
> all color are lost.
>=20
> 2. (progn  (setq treesit-font-lock-level 4) (revert-buffer))
> colors are good.
>=20
> 3. (progn  (setq treesit-font-lock-level 4) (revert-buffer))
> all color are lost again.
>=20
>=20
> ```rust
>=20
> //! 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.
>=20
> #![stable(feature =3D "rust1", since =3D "1.0.0")]
>=20
> use crate::cell::UnsafeCell;
> use crate::cmp;
> use crate::fmt::Debug;
> use crate::hash::{Hash, Hasher};
>=20
> /// 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 =3D "marker_trait", issue =3D "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 =3D "internal_impls_macro", issue =3D "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)*)? ) =3D> { $(#[$($meta)*])* impl< $($($bounds)*)? > $Trait f=
or
> $T {}
>         marker_impls! { $(#[$($meta)*])* $Trait for $($($rest)*)? }
>     },
>     ( $(#[$($meta:tt)*])* $Trait:ident for ) =3D> {},
>=20
>     ( $(#[$($meta:tt)*])* unsafe $Trait:ident for $({$($bounds:tt)*})? $T=
:ty
> $(, $($rest:tt)*)? ) =3D> { $(#[$($meta)*])* unsafe impl< $($($bounds)*)?=
 >
> $Trait for $T {} marker_impls! { $(#[$($meta)*])* unsafe $Trait for
> $($($rest)*)? } },
>     ( $(#[$($meta:tt)*])* unsafe $Trait:ident for ) =3D> {},
> }
>=20
> /// 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 overhea=
d)
> 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 =3D "rust1", since =3D "1.0.0")]
> #[cfg_attr(not(test), rustc_diagnostic_item =3D "Send")]
> #[diagnostic::on_unimplemented(
>     message =3D "`{Self}` cannot be sent between threads safely",
>     label =3D "`{Self}` cannot be sent between threads safely"
> )]
> pub unsafe auto trait Send {
>     // empty.
> }
>=20
> #[stable(feature =3D "rust1", since =3D "1.0.0")]
> impl<T: ?Sized> !Send for *const T {}
> #[stable(feature =3D "rust1", since =3D "1.0.0")]
> impl<T: ?Sized> !Send for *mut T {}
>=20
> // 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 =3D "rust1", since =3D "1.0.0")]
> unsafe impl<T: Sync + ?Sized> Send for &T {}
>=20
> /// 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 =3D &Impl;    // OK
> /// // let y: &dyn Bar =3D &Impl; // error: the trait `Bar` cannot
> ///                             // be made into an object
> /// ```
> ///
> /// [trait object]: ../../book/ch17-02-trait-objects.html
> #[doc(alias =3D "?", alias =3D "?Sized")]
> #[stable(feature =3D "rust1", since =3D "1.0.0")]
> #[lang =3D "sized"]
> #[diagnostic::on_unimplemented(
>     message =3D "the size for values of type `{Self}` cannot be known at
> compilation time", label =3D "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 =3D
> 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.
> }
>=20
> /// 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 conditio=
ns
> 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<..=
=2E>`
> 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 =3D "unsize", issue =3D "18598")]
> #[lang =3D "unsize"]
> #[cfg_attr(bootstrap, rustc_deny_explicit_impl(implement_via_object =3D
> 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.
> }
>=20
> /// 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 tra=
it,
> /// 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 const=
ant
> 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 =3D "structural_match", issue =3D "31434")]
> #[diagnostic::on_unimplemented(message =3D "the type `{Self}` does not
> `#[derive(PartialEq)]`")] #[lang =3D "structural_peq"]
> pub trait StructuralPartialEq {
>     // Empty.
> }
>=20
> marker_impls! {
>     #[unstable(feature =3D "structural_match", issue =3D "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,
> }
>=20
> /// 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 =3D Foo;
> ///
> /// let y =3D 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 =3D Foo;
> ///
> /// let y =3D 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 wi=
ll
> 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 =3D=
 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 duplica=
te
> 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 /// pointe=
r,
> 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` mu=
st
> 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`, ev=
en
> 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` fr=
om
> 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 duplica=
te
> 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-`Co=
py`
> 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. K=
eep
> 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 =3D "rust1", since =3D "1.0.0")]
> #[lang =3D "copy"]
> // FIXME(matthewjasper) This allows copying a type that doesn't implement
> // `Copy` because of unsatisfied lifetime bounds (copying `A<'_>` when on=
ly
> // `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 =3D "Copy"]
> pub trait Copy: Clone {
>     // Empty.
> }
>=20
> /// Derive macro generating an impl of the trait `Copy`.
> #[rustc_builtin_macro]
> #[stable(feature =3D "builtin_macro_prelude", since =3D "1.38.0")]
> #[allow_internal_unstable(core_intrinsics, derive_clone_copy)]
> pub macro Copy($item:item) {
>     /* compiler built-in */
> }
>=20
> // 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 =3D "rust1", since =3D "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,
>=20
> }
>=20
> #[unstable(feature =3D "never_type", issue =3D "35121")]
> impl Copy for ! {}
>=20
> /// Shared references can be copied, but mutable references *cannot*!
> #[stable(feature =3D "rust1", since =3D "1.0.0")]
> impl<T: ?Sized> Copy for &T {}
>=20
> /// 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 w=
ay.
> ///
> /// 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 =3D "rust1", since =3D "1.0.0")]
> #[cfg_attr(not(test), rustc_diagnostic_item =3D "Sync")]
> #[lang =3D "sync"]
> #[rustc_on_unimplemented(
>     on(
>         _Self =3D "core::cell::once::OnceCell<T>",
>         note =3D "if you want to do aliasing and mutation between multiple
> threads, use `std::sync::OnceLock` instead" ),
>     on(
>         _Self =3D "core::cell::Cell<u8>",
>         note =3D "if you want to do aliasing and mutation between multiple
> threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicU8` instead=
",
> ),
>     on(
>         _Self =3D "core::cell::Cell<u16>",
>         note =3D "if you want to do aliasing and mutation between multiple
> threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicU16`
> instead", ),
>     on(
>         _Self =3D "core::cell::Cell<u32>",
>         note =3D "if you want to do aliasing and mutation between multiple
> threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicU32`
> instead", ),
>     on(
>         _Self =3D "core::cell::Cell<u64>",
>         note =3D "if you want to do aliasing and mutation between multiple
> threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicU64`
> instead", ),
>     on(
>         _Self =3D "core::cell::Cell<usize>",
>         note =3D "if you want to do aliasing and mutation between multiple
> threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicUsize`
> instead", ),
>     on(
>         _Self =3D "core::cell::Cell<i8>",
>         note =3D "if you want to do aliasing and mutation between multiple
> threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicI8` instead=
",
> ),
>     on(
>         _Self =3D "core::cell::Cell<i16>",
>         note =3D "if you want to do aliasing and mutation between multiple
> threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicI16`
> instead", ),
>     on(
>         _Self =3D "core::cell::Cell<i32>",
>         note =3D "if you want to do aliasing and mutation between multiple
> threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicI32`
> instead", ),
>     on(
>         _Self =3D "core::cell::Cell<i64>",
>         note =3D "if you want to do aliasing and mutation between multiple
> threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicI64`
> instead", ),
>     on(
>         _Self =3D "core::cell::Cell<isize>",
>         note =3D "if you want to do aliasing and mutation between multiple
> threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicIsize`
> instead", ),
>     on(
>         _Self =3D "core::cell::Cell<bool>",
>         note =3D "if you want to do aliasing and mutation between multiple
> threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicBool`
> instead", ),
>     on(
>         all(
>             _Self =3D "core::cell::Cell<T>",
>             not(_Self =3D "core::cell::Cell<u8>"),
>             not(_Self =3D "core::cell::Cell<u16>"),
>             not(_Self =3D "core::cell::Cell<u32>"),
>             not(_Self =3D "core::cell::Cell<u64>"),
>             not(_Self =3D "core::cell::Cell<usize>"),
>             not(_Self =3D "core::cell::Cell<i8>"),
>             not(_Self =3D "core::cell::Cell<i16>"),
>             not(_Self =3D "core::cell::Cell<i32>"),
>             not(_Self =3D "core::cell::Cell<i64>"),
>             not(_Self =3D "core::cell::Cell<isize>"),
>             not(_Self =3D "core::cell::Cell<bool>")
>         ),
>         note =3D "if you want to do aliasing and mutation between multiple
> threads, use `std::sync::RwLock`", ),
>     on(
>         _Self =3D "core::cell::RefCell<T>",
>         note =3D "if you want to do aliasing and mutation between multiple
> threads, use `std::sync::RwLock` instead", ),
>     message =3D "`{Self}` cannot be shared between threads safely",
>     label =3D "`{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=3D"`{Self}` cannot be shared safely, consider marking the
> closure `move`" // ),
>     // ```
>=20
>     // Empty
> }
>=20
> #[stable(feature =3D "rust1", since =3D "1.0.0")]
> impl<T: ?Sized> !Sync for *const T {}
> #[stable(feature =3D "rust1", since =3D "1.0.0")]
> impl<T: ?Sized> !Sync for *mut T {}
>=20
> /// 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 =F0=9F=91=BB=F0=9F=91=BB=F0=9F=91=BB
> ///
> /// 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 h=
as
> 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 =3D 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 =3D 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 =3D 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 exa=
ct
> rules, see the [drop check] documentation. ///
> /// ## Layout
> ///
> /// For all `T`, the following are guaranteed:
> /// * `size_of::<PhantomData<T>>() =3D=3D 0`
> /// * `align_of::<PhantomData<T>>() =3D=3D 1`
> ///
> /// [drop check]: Drop#drop-check
> #[lang =3D "phantom_data"]
> #[stable(feature =3D "rust1", since =3D "1.0.0")]
> pub struct PhantomData<T: ?Sized>;
>=20
> #[stable(feature =3D "rust1", since =3D "1.0.0")]
> impl<T: ?Sized> Hash for PhantomData<T> {
>     #[inline]
>     fn hash<H: Hasher>(&self, _: &mut H) {}
> }
>=20
> #[stable(feature =3D "rust1", since =3D "1.0.0")]
> impl<T: ?Sized> cmp::PartialEq for PhantomData<T> {
>     fn eq(&self, _other: &PhantomData<T>) -> bool {
>         true
>     }
> }
>=20
> #[stable(feature =3D "rust1", since =3D "1.0.0")]
> impl<T: ?Sized> cmp::Eq for PhantomData<T> {}
>=20
> #[stable(feature =3D "rust1", since =3D "1.0.0")]
> impl<T: ?Sized> cmp::PartialOrd for PhantomData<T> {
>     fn partial_cmp(&self, _other: &PhantomData<T>) -> Option<cmp::Orderin=
g>
> { Option::Some(cmp::Ordering::Equal)
>     }
> }
>=20
> #[stable(feature =3D "rust1", since =3D "1.0.0")]
> impl<T: ?Sized> cmp::Ord for PhantomData<T> {
>     fn cmp(&self, _other: &PhantomData<T>) -> cmp::Ordering {
>         cmp::Ordering::Equal
>     }
> }
>=20
> #[stable(feature =3D "rust1", since =3D "1.0.0")]
> impl<T: ?Sized> Copy for PhantomData<T> {}
>=20
> #[stable(feature =3D "rust1", since =3D "1.0.0")]
> impl<T: ?Sized> Clone for PhantomData<T> {
>     fn clone(&self) -> Self {
>         Self
>     }
> }
>=20
> #[stable(feature =3D "rust1", since =3D "1.0.0")]
> impl<T: ?Sized> Default for PhantomData<T> {
>     fn default() -> Self {
>         Self
>     }
> }
>=20
> #[unstable(feature =3D "structural_match", issue =3D "31434")]
> impl<T: ?Sized> StructuralPartialEq for PhantomData<T> {}
>=20
> /// Compiler-internal trait used to indicate the type of enum discriminan=
ts.
> ///
> /// This trait is automatically implemented for every type and does not a=
dd
> any /// guarantees to [`mem::Discriminant`]. It is **undefined behavior**
> to transmute /// between `DiscriminantKind::Discriminant` and
> `mem::Discriminant`. ///
> /// [`mem::Discriminant`]: crate::mem::Discriminant
> #[unstable(
>     feature =3D "discriminant_kind",
>     issue =3D "none",
>     reason =3D "this trait is unlikely to ever be stabilized, use
> `mem::discriminant` instead" )]
> #[lang =3D "discriminant_kind"]
> #[cfg_attr(bootstrap, rustc_deny_explicit_impl(implement_via_object =3D
> 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 =3D "discriminant_type"]
>     type Discriminant: Clone + Copy + Debug + Eq + PartialEq + Hash + Sen=
d +
> Sync + Unpin; }
>=20
> /// 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=
 =3D
> "freeze"]
> #[unstable(feature =3D "freeze", issue =3D "121675")]
> pub unsafe auto trait Freeze {}
>=20
> #[unstable(feature =3D "freeze", issue =3D "121675")]
> impl<T: ?Sized> !Freeze for UnsafeCell<T> {}
> marker_impls! {
>     #[unstable(feature =3D "freeze", issue =3D "121675")]
>     unsafe Freeze for
>         {T: ?Sized} PhantomData<T>,
>         {T: ?Sized} *const T,
>         {T: ?Sized} *mut T,
>         {T: ?Sized} &T,
>         {T: ?Sized} &mut T,
> }
>=20
> /// 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 /// whi=
ch
> 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 whi=
ch
> 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 impleme=
nt
> `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 i=
ts
> 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 =3D "this".to_string();
> /// let mut pinned_string =3D 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 unpi=
n"
> /// [`unsafe`]: ../../std/keyword.unsafe.html "keyword unsafe"
> #[stable(feature =3D "pin", since =3D "1.33.0")]
> #[diagnostic::on_unimplemented(
>     note =3D "consider using the `pin!` macro\nconsider using `Box::pin` =
if
> you need to access the pinned value outside of the current scope", message
> =3D "`{Self}` cannot be unpinned"
> )]
> #[lang =3D "unpin"]
> pub auto trait Unpin {}
>=20
> /// A marker type which does not implement `Unpin`.
> ///
> /// If a type contains a `PhantomPinned`, it will not implement `Unpin` by
> default. #[stable(feature =3D "pin", since =3D "1.33.0")]
> #[derive(Debug, Default, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Has=
h)]
> pub struct PhantomPinned;
>=20
> #[stable(feature =3D "pin", since =3D "1.33.0")]
> impl !Unpin for PhantomPinned {}
>=20
> marker_impls! {
>     #[stable(feature =3D "pin", since =3D "1.33.0")]
>     Unpin for
>         {T: ?Sized} &T,
>         {T: ?Sized} &mut T,
> }
>=20
> marker_impls! {
>     #[stable(feature =3D "pin_raw", since =3D "1.38.0")]
>     Unpin for
>         {T: ?Sized} *const T,
>         {T: ?Sized} *mut T,
> }
>=20
> /// 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 =3D "const_destruct", issue =3D "133214")]
> #[lang =3D "destruct"]
> #[rustc_on_unimplemented(message =3D "can't drop `{Self}`", append_const_=
msg)]
> #[cfg_attr(bootstrap, rustc_deny_explicit_impl(implement_via_object =3D
> 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 {}
>=20
> /// A marker for tuple types.
> ///
> /// The implementation of this trait is built-in and cannot be implemented
> /// for any user type.
> #[unstable(feature =3D "tuple_trait", issue =3D "none")]
> #[lang =3D "tuple_trait"]
> #[diagnostic::on_unimplemented(message =3D "`{Self}` is not a tuple")]
> #[cfg_attr(bootstrap, rustc_deny_explicit_impl(implement_via_object =3D
> false))] #[cfg_attr(not(bootstrap), rustc_deny_explicit_impl)]
> #[cfg_attr(not(bootstrap), rustc_do_not_implement_via_object)]
> pub trait Tuple {}
>=20
> /// 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=E2=80=99s sole non-zero-sized field must itself implement
> `PointerLike`. #[unstable(feature =3D "pointer_like_trait", issue =3D "no=
ne")]
> #[lang =3D "pointer_like"]
> #[diagnostic::on_unimplemented(
>     message =3D "`{Self}` needs to have the same ABI as a pointer",
>     label =3D "`{Self}` needs to be a pointer-like type"
> )]
> #[cfg_attr(not(bootstrap), rustc_do_not_implement_via_object)]
> pub trait PointerLike {}
>=20
> #[cfg(not(bootstrap))]
> marker_impls! {
>     #[unstable(feature =3D "pointer_like_trait", issue =3D "none")]
>     PointerLike for
>         isize,
>         usize,
>         {T} &T,
>         {T} &mut T,
>         {T} *const T,
>         {T} *mut T,
>         {T: PointerLike} crate::pin::Pin<T>,
> }
>=20
> /// 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 =3D "const_param_ty"]
> #[unstable(feature =3D "unsized_const_params", issue =3D "95174")]
> #[diagnostic::on_unimplemented(message =3D "`{Self}` can't be used as a c=
onst
> 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 use=
d.
> This should be renamed on stabilization. pub trait ConstParamTy_:
> UnsizedConstParamTy + StructuralPartialEq + Eq {}
>=20
> /// Derive macro generating an impl of the trait `ConstParamTy`.
> #[rustc_builtin_macro]
> #[allow_internal_unstable(unsized_const_params)]
> #[unstable(feature =3D "adt_const_params", issue =3D "95174")]
> pub macro ConstParamTy($item:item) {
>     /* compiler built-in */
> }
>=20
> #[lang =3D "unsized_const_param_ty"]
> #[unstable(feature =3D "unsized_const_params", issue =3D "95174")]
> #[diagnostic::on_unimplemented(message =3D "`{Self}` can't be used as a c=
onst
> 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 {}
>=20
> /// Derive macro generating an impl of the trait `ConstParamTy`.
> #[rustc_builtin_macro]
> #[allow_internal_unstable(unsized_const_params)]
> #[unstable(feature =3D "unsized_const_params", issue =3D "95174")]
> pub macro UnsizedConstParamTy($item:item) {
>     /* compiler built-in */
> }
>=20
> // FIXME(adt_const_params): handle `ty::FnDef`/`ty::Closure`
> marker_impls! {
>     #[unstable(feature =3D "adt_const_params", issue =3D "95174")]
>     ConstParamTy_ for
>         usize, u8, u16, u32, u64, u128,
>         isize, i8, i16, i32, i64, i128,
>         bool,
>         char,
>         (),
>         {T: ConstParamTy_, const N: usize} [T; N],
> }
>=20
> marker_impls! {
>     #[unstable(feature =3D "unsized_const_params", issue =3D "95174")]
>     UnsizedConstParamTy for
>         usize, u8, u16, u32, u64, u128,
>         isize, i8, i16, i32, i64, i128,
>         bool,
>         char,
>         (),
>         {T: UnsizedConstParamTy, const N: usize} [T; N],
>=20
>         str,
>         {T: UnsizedConstParamTy} [T],
>         {T: UnsizedConstParamTy + ?Sized} &T,
> }
>=20
> /// A common trait implemented by all function pointers.
> #[unstable(
>     feature =3D "fn_ptr_trait",
>     issue =3D "none",
>     reason =3D "internal trait for implementing various traits for all
> function pointers" )]
> #[lang =3D "fn_ptr_trait"]
> #[cfg_attr(bootstrap, rustc_deny_explicit_impl(implement_via_object =3D
> 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 =3D "fn_ptr_addr"]
>     fn addr(self) -> *const ();
> }
>=20
> /// 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 =3D "derive_coerce_pointee", issue =3D "123430")]
> #[cfg(not(bootstrap))]
> pub macro CoercePointee($item:item) {
>     /* compiler built-in */
> }
>=20
>=20
> ```
>=20
>=20
> 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)
>=20
> Configured using:
>  'configure 'CFLAGS=3D-O3 -march=3Dnative'
>  --prefix=3D/home/exec/Projects/git.savannah.gnu.org/git/emacs-build/feat=
ure_i
> gc-7b35a5062231ec5a11c7a87d4797cfb5dba25121-O3 --with-mps=3Dyes
> --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=3Dinotify'
>=20
> 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
>=20
> 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=3Dfcitx
>   locale-coding-system: utf-8-unix
>=20
> Major mode: Elisp/l
>=20
> 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
>=20
> 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
>=20
> 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)
>=20
> 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))


--nextPart7128439.9J7NaK4W3v
Content-Disposition: attachment; filename="rust-grammar-bug.png"
Content-Transfer-Encoding: base64
Content-Type: image/png; name="rust-grammar-bug.png"
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--nextPart7128439.9J7NaK4W3v--

Message sent to bug-gnu-emacs@HIDDEN:

X-Loop: help-debbugs@HIDDEN
Subject: bug#77914: 31.0.50; treesit-font-lock-level set to 4 cause rust-ts-mode lost all color
Resent-From: Juri Linkov <juri@HIDDEN>
Original-Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>
Resent-CC: bug-gnu-emacs@HIDDEN
Resent-Date: Sun, 20 Apr 2025 06:28:04 +0000
Resent-Message-ID: <handler.77914.B77914.17451304679060 <at> debbugs.gnu.org>
Resent-Sender: help-debbugs@HIDDEN
X-GNU-PR-Message: followup 77914
X-GNU-PR-Package: emacs
X-GNU-PR-Keywords: 
To: Vincenzo Pupillo <v.pupillo@HIDDEN>
Cc: Eval Exec <execvy@HIDDEN>, 77914 <at> debbugs.gnu.org
Received: via spool by 77914-submit <at> debbugs.gnu.org id=B77914.17451304679060
          (code B ref 77914); Sun, 20 Apr 2025 06:28:04 +0000
Received: (at 77914) by debbugs.gnu.org; 20 Apr 2025 06:27:47 +0000
Received: from localhost ([127.0.0.1]:43893 helo=debbugs.gnu.org)
	by debbugs.gnu.org with esmtp (Exim 4.84_2)
	(envelope-from <debbugs-submit-bounces <at> debbugs.gnu.org>)
	id 1u6O9b-0002M3-D2
	for submit <at> debbugs.gnu.org; Sun, 20 Apr 2025 02:27:47 -0400
Received: from relay8-d.mail.gandi.net ([2001:4b98:dc4:8::228]:33203)
 by debbugs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256)
 (Exim 4.84_2) (envelope-from <juri@HIDDEN>) id 1u6O9Y-0002LX-TQ
 for 77914 <at> debbugs.gnu.org; Sun, 20 Apr 2025 02:27:45 -0400
Received: by mail.gandi.net (Postfix) with ESMTPSA id 511F043B31;
 Sun, 20 Apr 2025 06:27:36 +0000 (UTC)
From: Juri Linkov <juri@HIDDEN>
In-Reply-To: <3523927.LZWGnKmheA@fedora>
Organization: LINKOV.NET
References: <877c3gka72.fsf@HIDDEN> <3523927.LZWGnKmheA@fedora>
Date: Sun, 20 Apr 2025 09:15:51 +0300
Message-ID: <87mscbe5a8.fsf@HIDDEN>
User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/31.0.50 (x86_64-pc-linux-gnu)
MIME-Version: 1.0
Content-Type: text/plain
X-GND-State: clean
X-GND-Score: -100
X-GND-Cause: gggruggvucftvghtrhhoucdtuddrgeefvddrtddtgddvfeejudelucetufdoteggodetrfdotffvucfrrhhofhhilhgvmecuifetpfffkfdpucggtfgfnhhsuhgsshgtrhhisggvnecuuegrihhlohhuthemuceftddunecusecvtfgvtghiphhivghnthhsucdlqddutddtmdenucfjughrpefhvfevufgjohhffffkfgggtgesthdtredttdertdenucfhrhhomheplfhurhhiucfnihhnkhhovhcuoehjuhhriheslhhinhhkohhvrdhnvghtqeenucggtffrrghtthgvrhhnpeelieevuedtheeftdeguddtieelheekgeehveeghedtgfeuueeivddvhfevkeevgfenucffohhmrghinhepghhnuhdrohhrghenucfkphepledurdduvdelrddutdehrdduudejnecuvehluhhsthgvrhfuihiivgeptdenucfrrghrrghmpehinhgvthepledurdduvdelrddutdehrdduudejpdhhvghlohepmhgrihhlrdhgrghnughirdhnvghtpdhmrghilhhfrhhomhepjhhurhhisehlihhnkhhovhdrnhgvthdpnhgspghrtghpthhtohepfedprhgtphhtthhopegvgigvtghvhiesghhmrghilhdrtghomhdprhgtphhtthhopeejjeeludegseguvggssghughhsrdhgnhhurdhorhhgpdhrtghpthhtohepvhdrphhuphhilhhlohesghhmrghilhdrtghomh
X-GND-Sasl: juri@HIDDEN
X-Spam-Score: -0.7 (/)
X-BeenThere: debbugs-submit <at> debbugs.gnu.org
X-Mailman-Version: 2.1.18
Precedence: list
List-Id: <debbugs-submit.debbugs.gnu.org>
List-Unsubscribe: <https://debbugs.gnu.org/cgi-bin/mailman/options/debbugs-submit>, 
 <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=unsubscribe>
List-Archive: <https://debbugs.gnu.org/cgi-bin/mailman/private/debbugs-submit/>
List-Post: <mailto:debbugs-submit <at> debbugs.gnu.org>
List-Help: <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=help>
List-Subscribe: <https://debbugs.gnu.org/cgi-bin/mailman/listinfo/debbugs-submit>, 
 <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=subscribe>
Errors-To: debbugs-submit-bounces <at> debbugs.gnu.org
Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>
X-Spam-Score: -1.7 (-)

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

Maybe this is related to Rust grammar version mismatch
where the current rust-ts-mode works only with
tree-sitter-rust v0.23.0:

https://lists.gnu.org/archive/html/emacs-devel/2025-04/msg00430.html

Message sent to bug-gnu-emacs@HIDDEN:

X-Loop: help-debbugs@HIDDEN
Subject: bug#77914: 31.0.50; treesit-font-lock-level set to 4 cause rust-ts-mode lost all color
Resent-From: Eval Exec <execvy@HIDDEN>
Original-Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>
Resent-CC: bug-gnu-emacs@HIDDEN
Resent-Date: Sun, 20 Apr 2025 07:20:02 +0000
Resent-Message-ID: <handler.77914.B.1745133593364 <at> debbugs.gnu.org>
Resent-Sender: help-debbugs@HIDDEN
X-GNU-PR-Message: followup 77914
X-GNU-PR-Package: emacs
X-GNU-PR-Keywords: 
To: v.pupillo@HIDDEN, 77914 <at> debbugs.gnu.org
X-Debbugs-Original-To: Vincenzo Pupillo <v.pupillo@HIDDEN>, 77914 <at> debbugs.gnu.org, bug-gnu-emacs@HIDDEN
Received: via spool by submit <at> debbugs.gnu.org id=B.1745133593364
          (code B ref -1); Sun, 20 Apr 2025 07:20:02 +0000
Received: (at submit) by debbugs.gnu.org; 20 Apr 2025 07:19:53 +0000
Received: from localhost ([127.0.0.1]:44281 helo=debbugs.gnu.org)
	by debbugs.gnu.org with esmtp (Exim 4.84_2)
	(envelope-from <debbugs-submit-bounces <at> debbugs.gnu.org>)
	id 1u6Oxw-00005b-RN
	for submit <at> debbugs.gnu.org; Sun, 20 Apr 2025 03:19:53 -0400
Received: from lists.gnu.org ([2001:470:142::17]:35380)
 by debbugs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256)
 (Exim 4.84_2) (envelope-from <execvy@HIDDEN>) id 1u6Oxq-00004s-BS
 for submit <at> debbugs.gnu.org; Sun, 20 Apr 2025 03:19:47 -0400
Received: from eggs.gnu.org ([2001:470:142:3::10])
 by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256)
 (Exim 4.90_1) (envelope-from <execvy@HIDDEN>) id 1u6Oxi-000833-4L
 for bug-gnu-emacs@HIDDEN; Sun, 20 Apr 2025 03:19:34 -0400
Received: from mail-pl1-x642.google.com ([2607:f8b0:4864:20::642])
 by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128)
 (Exim 4.90_1) (envelope-from <execvy@HIDDEN>) id 1u6Oxb-0006Q6-Sn
 for bug-gnu-emacs@HIDDEN; Sun, 20 Apr 2025 03:19:33 -0400
Received: by mail-pl1-x642.google.com with SMTP id
 d9443c01a7336-227d6b530d8so31118615ad.3
 for <bug-gnu-emacs@HIDDEN>; Sun, 20 Apr 2025 00:19:26 -0700 (PDT)
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed;
 d=gmail.com; s=20230601; t=1745133565; x=1745738365; darn=gnu.org;
 h=content-transfer-encoding:in-reply-to:autocrypt:from
 :content-language:references:to:subject:user-agent:mime-version:date
 :message-id:from:to:cc:subject:date:message-id:reply-to;
 bh=66FkkO0nThuk+v+ot92XcoRd/UnRY/Q0mreicvF4ayo=;
 b=SXhqKbfKH0w9ckbOwxlDsFfMflMMMr5Vcaa4r9IzzbXT7VHc7WmhwQNaVAaDtPIB1C
 /eElD8YkUTCmAEF+Ymuols4+KuBN4vlqaPDRjMZBefFqmiCaGLvvR3RLo0zkSwMTZ39G
 9G6JjzFTeGR4WNwslTnhBDM4IXrsdEbKazzAyb4ZpIA32peMt6Q4DpT6auqKWb01B7JT
 HFXtUQPMiq97lUhUDh2yrtWHN3g1l7MHn7szb05Lrt6G3FYKprFfbwZ8OnjSoyZD1F7D
 ds4QsiP4SGFer0fAIXSegMygdV8Ik1fz0PZN8oglOykXlV5p/BJvpiThCoeUOfhYdR9N
 u0YQ==
X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed;
 d=1e100.net; s=20230601; t=1745133565; x=1745738365;
 h=content-transfer-encoding:in-reply-to:autocrypt:from
 :content-language:references:to:subject:user-agent:mime-version:date
 :message-id:x-gm-message-state:from:to:cc:subject:date:message-id
 :reply-to;
 bh=66FkkO0nThuk+v+ot92XcoRd/UnRY/Q0mreicvF4ayo=;
 b=uvPj4pRj+St2gL86/HpdLWCjmMZiA1oplQ3IMM3yMKLvESt5zYf99vze1B6oV895hO
 HDTc+HtjbHXkCy/AMRFmVTFZkpOM5F3gZbdn2gqTCJYolFdowLZbfCP/2+twd3APlO/0
 47dRch8fTc/Rs6AypAkv5BqiBkaY34KyJFKQTH5WWfhnrV6HIMYIlZKKufA1UHxBAMXT
 qSDUEcJPCmcmhgLBbcwyaHGvCDqiZvAPvczdThuxEuZYy7oqpk30KtvBGSHTd8baszo3
 jWwWBFyZic4fXLUCqTQ03nAjpW8CtOY6Q5UEiejF4tbiLeA61X/SFCkXPLZEsSj+mnNR
 WP1g==
X-Forwarded-Encrypted: i=1;
 AJvYcCU+o3cguNQE526padhETOayK92/oKMcyqTwdGYl59sqMuk8CWFTq7IpORjEXVGnRQs3T/RSneqhy/TXju5C@HIDDEN
X-Gm-Message-State: AOJu0Yzl0u8M2SrXyKkswId+RmRUXti9Ml87+zTq01uCnibLBXDw540E
 a3xPPcX42udAuSLtV0xg/m0ufFLWcK6QgXmSIZkZ9eUDtmBl0y9jG0K4kllOw8zeMscI
X-Gm-Gg: ASbGncsNtIZWtXzoUmAui9Lq7k1OZvzCSViHkRG9bUWXHJ2kynaY6ROJ3ebLVxfKIV2
 WIyPED9mwoRsbIn4uLE1ErjBIje2kEi2FoZqJWNmF7ugqQM/Qt6o2OOCpCeK0k4a3NPWf4z/gJk
 Kws0vQlZt9Peq/j3A3i7gKL9h9sExvgVWAI8moh0/+rx1M6jZD4iI/UMd4UW/9Vbb22h1Wy+JG5
 I6pkc4MXFbErOZD3bk/8yn1qOroguRHj2ZkLsQBlv8Lk0EnjAHu0YbTUAvdf5OGP82nn5N6rjE1
 DmylU/pznUPod4RNTtXKG2O5oQ9GglP4gw==
X-Google-Smtp-Source: AGHT+IFR+AucwWhh2c4EFMr0EnrZcZ7/2dmXkamqx61nmaJ/L56skSoNBTnci3hbPqA+fY036iFpyg==
X-Received: by 2002:a17:902:dac7:b0:224:b60:3cd3 with SMTP id
 d9443c01a7336-22c53583e10mr110402305ad.19.1745133564579; 
 Sun, 20 Apr 2025 00:19:24 -0700 (PDT)
Received: from [28.0.0.1] ([124.64.126.60]) by smtp.gmail.com with ESMTPSA id
 d9443c01a7336-22c50bf3eb1sm44145935ad.82.2025.04.20.00.19.22
 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128);
 Sun, 20 Apr 2025 00:19:24 -0700 (PDT)
Message-ID: <5af658c9-70e0-4dd2-82ba-d528021771c1@HIDDEN>
Date: Sun, 20 Apr 2025 15:19:20 +0800
MIME-Version: 1.0
User-Agent: Mozilla Thunderbird
References: <877c3gka72.fsf@HIDDEN> <3523927.LZWGnKmheA@fedora>
Content-Language: en-US
From: Eval Exec <execvy@HIDDEN>
Autocrypt: addr=execvy@HIDDEN; keydata=
 xsFNBGBvzeYBEAC4K4kJM/PbZ+0zth4/1NG5ZAjIa5dlNys4OguRq4o+ebX1oI7DICnVv0Jk
 ZSB/hUtGQD3LkBlxAvYaT42P3riM55uLLc3qESxC5jQ6N8pvkyPj98JhNgB3NUyXSZFtOpWS
 BMWWxwpUcQtrLxVfo5cS1LENtKSgt/NwKyaO2O18Fhe/Rn0zRaiduVhvth3thLx+DzbmmL5g
 0C4CyO2JERMQQnDhKdaNzU2gJXiiCjrr9pqSRd/ZrnH803DY5l4iMqCU5dx/AaPt0U4/tqTy
 tD1872Nzdxvfsvq6YIwhHEx/zA533HV0sYMuR9Rj78LlAV+bKiGmCU4Vvo34i/MxTG+R5P96
 2WXbyLwQ8ovacUpoSJHZ33RQBgkEdt/SXjcLfMJ1YXsuw9MsJp8rCIh0k5oKtBxSg8k9YmNE
 ClZsrIpxHehlx27mWuNSjGyvdXbNEHE+LcXLP8BFJWWxZrl2oKBjt1V4ylia2f4Qz8VV05+i
 m8PmzRZWf6M4dLrUZT/CuYkGMrMe0NP9C3LL4wm8wH8p8NdO6erbP2BdcQ9SlJBJYwcpCGgd
 aSKju11WsqQBa0HDa5LTBTqG3o21c3FLv+ttdQHdGacwkpIlzglrDpqkekleFSxKL9hBk3KJ
 HgLJRkDK7EI0bexpwRfhm/fmVuWemQ/4xlio5ThPkG96Ng+B3wARAQABzSpFdmFsIEVYRUMg
 KERJRyBESUcgRElHKSA8ZXhlY3Z5QGdtYWlsLmNvbT7CwY4EEwEIADgWIQRLRTznDyZGBEFx
 us4PAnLA06yR9wUCYG/N5gIbAwULCQgHAgYVCgkICwIEFgIDAQIeAQIXgAAKCRAPAnLA06yR
 97GED/9XE8UUutbQHow0cnb0VGT4jMNbteULFXFkedvicNP3c0THEDOLRoSYQmDPsTPzmM+b
 Z49aTFlLQq4USeO/HXWCpL2AMftS0jiETUiCSoc/e+TI88/2PjdZc24qU5o4pWiLOjVMpG90
 QiWbecj6vq29P2UCEMgy3/Qc/InuD4hE208Zq7pHNjE2WVfPMx9vJ/8xup2s3pKpVfHAfe+1
 WqaLeTiP5/NXaPNEkCfayAasfDVIKZpvOAMgF5rCNYbuCEWLaXkBa/rIXgFnrGQr5Bf5pqyn
 utysw+RpP5/MxhB2XPjplu4GZVPTIVJYgmHjMAtTFaRPmcRQl7JeeO0YEqX+ry2G3uzvpy9f
 jpz0hKrL8j+DTS+lQWaRaph0moaU69MAQ6d2HzdiagsYnlbbJfhZ6GSIJBvXSOtehsnMQ5lD
 p1SgdwmmjCDocsKD5vu/553OffAZw4N7AapsgnLufhaYV9OJbFpCRoy7MQA0DVHxcDCVFNgY
 Bz0aBPG6w8oA1cm7CR3nM0g7MKWAGc1vkZa+pMnlIDGySohFD+2r3UEy3OENU9iiaUZydxr4
 2PXZwQg3L2+YcBd01uJYQaQ5NyC5g9pxT3/WMFsdJQWncECeeIyER8mgCWshNhRInpDciOV+
 2lzH4lSGqO1tCDguRG4Q36tsn2sXApHnf6OuXjXF0c7BTQRgb83mARAA8mmfBNxj8CppO6Xb
 helhSkisZB0S85cq2LBvpc7tUxBwJlJ8BuI4Z1Dr6vbs/pioY2pvXAd0og/L4nV1ihCI8ban
 sWvzQHzj1Dr7q8+9X3FyD7T4rmJ4xvZXgv8XnB1i/7NNENyQ2yB2Pqg2JeWcKgwehpR03Hse
 0dAZ0VMPu9+wvHncfF0pIrD7Wdt2y9gXP2P3bmqCBd9Bbr3Dah+tIbPAvAHbKyP2lM0g2h+Q
 GnkdSg1VKviJ23IoNUqJbeMZKI68z1Pc1Ww8KPD5OzwzW/AnVBA+B2OO2kmDFZY9K3WtMKP3
 TjbSDvthSv6ir6IUdLA7tlgPtuvM7agaSWtGoM0x1nidycjO6FvOGij9vqIRu/J9FwiegHke
 odCSAlh/NHyDWDRgK9mU+4WuZ96hOavBGnenMbyuvNdp2k6yyoYjpUQsimIkFaYVtBn5vrfz
 YL+vpyLC/LeLaYJq8mr7FwuXZ474bmCA8VhwRpyIpuQedVWz6DHNtTmsP/JjuH8lIArj2/zJ
 silliHzktOZmF7hdkHMeNt4NX9Lb33JBIQxQqlemSseYeW/gglvloRyLVHN343CCshKjW4qv
 Ob1zJIDXONloDLZhQoqfLniXLzeM+VDJOY3/zMxDXyvodQED6uZcqKo/hYXu6eEkSwW3HVub
 8zeifVHnqSGHOL7xk/sAEQEAAcLBdgQYAQgAIBYhBEtFPOcPJkYEQXG6zg8CcsDTrJH3BQJg
 b83mAhsMAAoJEA8CcsDTrJH3wKwP/3ib0bcgNaQl3y00Ee1MEpynenyHA4egU5ARgsO7oNic
 49E2IYfaz8xcw/HmMvLTR1clmbFNEcGodkvp3aVCtK6JKixhv+JXH6DGASYvwsmEktrbmcTw
 vhfWlwxCnPW6+tpk62wFn/7GMN3YoJHstEfenK1o9dwWr3Z4Jt7ZaCDt2u6bS/QZvsmNhdmG
 qls7+8Q+qxiZoNKfBG3L5Ii7xr9pqmQPHjaVsF5WnNOhZrSyh3832PBmrybEDQK76yN/4Gs1
 BNrtkCNS3DPJbe0xqr4XCg/MiFoJprKBA63zm0S62y7M/4KOTn7P+KoUUoPvx3svR8gNGy3U
 P44PIH/td2qTkcapmsfcyPjP9pGQJpWZR+eIGFzhKX35qgUdhUba0xzoGz7/boflBlwv1mem
 TwBMdIPm68Yhfzh07MU/fyD4RX5S5BjMkcaYJ01INzvmzx67nIpEKmQlav3dn9nGfmmdqxTQ
 ngKNE5Qst37L862tSuFb5nRAqLFYpNfnFkb3YLSZos2UncGK8a6wnUCcTnYL5qkUbcackV/G
 j/NDNSrZZlg1RYHwJii4P2sb/j0FykcxwsYtjCWM5U28FM4dhCiT1IhwGs6pKhugFTC7uAjE
 1z8ZAw+Cdd8R9+XPgwM2rtWoND8mCjRbEZnLjnGytw3jxOoj39wlm3Myb2XnQRY2
In-Reply-To: <3523927.LZWGnKmheA@fedora>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Received-SPF: pass client-ip=2607:f8b0:4864:20::642;
 envelope-from=execvy@HIDDEN; helo=mail-pl1-x642.google.com
X-Spam_score_int: -20
X-Spam_score: -2.1
X-Spam_bar: --
X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1,
 DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_FROM=0.001,
 RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001,
 SPF_PASS=-0.001 autolearn=ham autolearn_force=no
X-Spam_action: no action
X-Spam-Score: 1.0 (+)
X-BeenThere: debbugs-submit <at> debbugs.gnu.org
X-Mailman-Version: 2.1.18
Precedence: list
List-Id: <debbugs-submit.debbugs.gnu.org>
List-Unsubscribe: <https://debbugs.gnu.org/cgi-bin/mailman/options/debbugs-submit>, 
 <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=unsubscribe>
List-Archive: <https://debbugs.gnu.org/cgi-bin/mailman/private/debbugs-submit/>
List-Post: <mailto:debbugs-submit <at> debbugs.gnu.org>
List-Help: <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=help>
List-Subscribe: <https://debbugs.gnu.org/cgi-bin/mailman/listinfo/debbugs-submit>, 
 <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=subscribe>
Errors-To: debbugs-submit-bounces <at> debbugs.gnu.org
Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>
X-Spam-Score: -0.0 (/)

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

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

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

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


Can you reproduce this?

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

Message sent to bug-gnu-emacs@HIDDEN:

X-Loop: help-debbugs@HIDDEN
Subject: bug#77914: 31.0.50; treesit-font-lock-level set to 4 cause rust-ts-mode lost all color
Resent-From: Eval Exec <execvy@HIDDEN>
Original-Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>
Resent-CC: bug-gnu-emacs@HIDDEN
Resent-Date: Sun, 20 Apr 2025 07:20:02 +0000
Resent-Message-ID: <handler.77914.B77914.1745133583329 <at> debbugs.gnu.org>
Resent-Sender: help-debbugs@HIDDEN
X-GNU-PR-Message: followup 77914
X-GNU-PR-Package: emacs
X-GNU-PR-Keywords: 
To: v.pupillo@HIDDEN, 77914 <at> debbugs.gnu.org
X-Debbugs-Original-To: Vincenzo Pupillo <v.pupillo@HIDDEN>, 77914 <at> debbugs.gnu.org, bug-gnu-emacs@HIDDEN
Received: via spool by 77914-submit <at> debbugs.gnu.org id=B77914.1745133583329
          (code B ref 77914); Sun, 20 Apr 2025 07:20:02 +0000
Received: (at 77914) by debbugs.gnu.org; 20 Apr 2025 07:19:43 +0000
Received: from localhost ([127.0.0.1]:44276 helo=debbugs.gnu.org)
	by debbugs.gnu.org with esmtp (Exim 4.84_2)
	(envelope-from <debbugs-submit-bounces <at> debbugs.gnu.org>)
	id 1u6Oxn-000056-5S
	for submit <at> debbugs.gnu.org; Sun, 20 Apr 2025 03:19:43 -0400
Received: from mail-pl1-x643.google.com ([2607:f8b0:4864:20::643]:44086)
 by debbugs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128)
 (Exim 4.84_2) (envelope-from <execvy@HIDDEN>) id 1u6Oxf-0008WM-Pq
 for 77914 <at> debbugs.gnu.org; Sun, 20 Apr 2025 03:19:36 -0400
Received: by mail-pl1-x643.google.com with SMTP id
 d9443c01a7336-2255003f4c6so35538335ad.0
 for <77914 <at> debbugs.gnu.org>; Sun, 20 Apr 2025 00:19:31 -0700 (PDT)
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed;
 d=gmail.com; s=20230601; t=1745133565; x=1745738365; darn=debbugs.gnu.org;
 h=content-transfer-encoding:in-reply-to:autocrypt:from
 :content-language:references:to:subject:user-agent:mime-version:date
 :message-id:from:to:cc:subject:date:message-id:reply-to;
 bh=66FkkO0nThuk+v+ot92XcoRd/UnRY/Q0mreicvF4ayo=;
 b=eiWR/YdpABYjs5PeMlYF9B+MyWdM4QoWUoMIWverRhe16YIw9Qv97JoEBbGtsus05e
 yShmD37xQ/wWcpd3ItvB6bUGWHHHhaNLdiqABrU0N+Da34t+a6HYNGp2K2N47CwmVMFN
 t2gCWYb92b7jKjLAiDq63H9VC0ARz04QPGdbQ759y7DFN679OY/QGOWGdWpQ1gf5DhO3
 cCP/qm486xOqBQw5lXoxunPpfBhFahavsdG5gREKCGQ1HnBQKTneiVJUxIpHZ1QHsj+O
 xQvHDoB36BiLXn4eG0NFagDopV7apayL88Wv5EC/ADnqxe2CGzo8YKXlXhQdjw7uEHyN
 s2fA==
X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed;
 d=1e100.net; s=20230601; t=1745133565; x=1745738365;
 h=content-transfer-encoding:in-reply-to:autocrypt:from
 :content-language:references:to:subject:user-agent:mime-version:date
 :message-id:x-gm-message-state:from:to:cc:subject:date:message-id
 :reply-to;
 bh=66FkkO0nThuk+v+ot92XcoRd/UnRY/Q0mreicvF4ayo=;
 b=oTfhiGIkWmwsT8EdbTL/YU7qUYXBqI3jMRwkDlMDpDMMpnaiFjRF4aFCXVC0gOkpcJ
 QlzVjGGn/0EI4gXihULrv506tyJLHo7qHTKo2v6keVHZTo0h4mM4RW0u2OYbNNyMpUyb
 QXzY4L8qe8cCnUEGNjEdb8kkpzjIisOZeTvrHBD0czoNlv4dTVIuN6ppET3Dgbiq2WMR
 Ozw50I204jKob0lsj2lsGMAgsGj/s223hjAIweikcWOf3w+6YziQJIxLrA5karKpBv1F
 0ngqIwy+Qh6ilwWAdA9RqoimEmEKCW7ZmW/7SH5PsyHNAb5VKk8xheGWThOYYNHPPDw8
 Keeg==
X-Forwarded-Encrypted: i=1;
 AJvYcCUQxzGrw0ZlUrR921cdr7YLAZEJvVlmJnRhy2Ym7jGZdHNxXoBTYModW/0I8s+xaP/URZI/Bg==@debbugs.gnu.org
X-Gm-Message-State: AOJu0YzwKhO7c8xIPr5ip5w8yVoLhayeUmMQ6Yb0MXorD4oXMJXgsj4P
 ZL+OP0zR6zhJHTbLL+dbkaubn9Hoya+Xf+yr9ixz1oEXcCxIMT7L
X-Gm-Gg: ASbGncv7I/hSshs57WWAQoLJxbOkZdBYSvpUPKC0GwAHfTqFpCrCrph5fgyf7fhItml
 R2XEMZw96YbdNAmtA/2EYw6YXzVmkzP2kZE8z1Zjebp0DbA28i8HFuYlBb2xL8V0gyDhtGGXLbZ
 ZZWeS8uVlm5qkRoSUGl9A7ypMrKWGHrbk2ZJfJMNBUl6z+EjGHlKBBzO+xaZ883XJmhVxVxhYud
 KCzPTgW5Um2C1z/ZO3WYBuEHYO7n3lHam+skhmi5Zi1UFVZjVgfx47vU6bALrTwhdUDUpdMUGEL
 Wk8cdH/4i9epIP+h200T5zCLbcYdmoxrOg==
X-Google-Smtp-Source: AGHT+IFR+AucwWhh2c4EFMr0EnrZcZ7/2dmXkamqx61nmaJ/L56skSoNBTnci3hbPqA+fY036iFpyg==
X-Received: by 2002:a17:902:dac7:b0:224:b60:3cd3 with SMTP id
 d9443c01a7336-22c53583e10mr110402305ad.19.1745133564579; 
 Sun, 20 Apr 2025 00:19:24 -0700 (PDT)
Received: from [28.0.0.1] ([124.64.126.60]) by smtp.gmail.com with ESMTPSA id
 d9443c01a7336-22c50bf3eb1sm44145935ad.82.2025.04.20.00.19.22
 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128);
 Sun, 20 Apr 2025 00:19:24 -0700 (PDT)
Message-ID: <5af658c9-70e0-4dd2-82ba-d528021771c1@HIDDEN>
Date: Sun, 20 Apr 2025 15:19:20 +0800
MIME-Version: 1.0
User-Agent: Mozilla Thunderbird
References: <877c3gka72.fsf@HIDDEN> <3523927.LZWGnKmheA@fedora>
Content-Language: en-US
From: Eval Exec <execvy@HIDDEN>
Autocrypt: addr=execvy@HIDDEN; keydata=
 xsFNBGBvzeYBEAC4K4kJM/PbZ+0zth4/1NG5ZAjIa5dlNys4OguRq4o+ebX1oI7DICnVv0Jk
 ZSB/hUtGQD3LkBlxAvYaT42P3riM55uLLc3qESxC5jQ6N8pvkyPj98JhNgB3NUyXSZFtOpWS
 BMWWxwpUcQtrLxVfo5cS1LENtKSgt/NwKyaO2O18Fhe/Rn0zRaiduVhvth3thLx+DzbmmL5g
 0C4CyO2JERMQQnDhKdaNzU2gJXiiCjrr9pqSRd/ZrnH803DY5l4iMqCU5dx/AaPt0U4/tqTy
 tD1872Nzdxvfsvq6YIwhHEx/zA533HV0sYMuR9Rj78LlAV+bKiGmCU4Vvo34i/MxTG+R5P96
 2WXbyLwQ8ovacUpoSJHZ33RQBgkEdt/SXjcLfMJ1YXsuw9MsJp8rCIh0k5oKtBxSg8k9YmNE
 ClZsrIpxHehlx27mWuNSjGyvdXbNEHE+LcXLP8BFJWWxZrl2oKBjt1V4ylia2f4Qz8VV05+i
 m8PmzRZWf6M4dLrUZT/CuYkGMrMe0NP9C3LL4wm8wH8p8NdO6erbP2BdcQ9SlJBJYwcpCGgd
 aSKju11WsqQBa0HDa5LTBTqG3o21c3FLv+ttdQHdGacwkpIlzglrDpqkekleFSxKL9hBk3KJ
 HgLJRkDK7EI0bexpwRfhm/fmVuWemQ/4xlio5ThPkG96Ng+B3wARAQABzSpFdmFsIEVYRUMg
 KERJRyBESUcgRElHKSA8ZXhlY3Z5QGdtYWlsLmNvbT7CwY4EEwEIADgWIQRLRTznDyZGBEFx
 us4PAnLA06yR9wUCYG/N5gIbAwULCQgHAgYVCgkICwIEFgIDAQIeAQIXgAAKCRAPAnLA06yR
 97GED/9XE8UUutbQHow0cnb0VGT4jMNbteULFXFkedvicNP3c0THEDOLRoSYQmDPsTPzmM+b
 Z49aTFlLQq4USeO/HXWCpL2AMftS0jiETUiCSoc/e+TI88/2PjdZc24qU5o4pWiLOjVMpG90
 QiWbecj6vq29P2UCEMgy3/Qc/InuD4hE208Zq7pHNjE2WVfPMx9vJ/8xup2s3pKpVfHAfe+1
 WqaLeTiP5/NXaPNEkCfayAasfDVIKZpvOAMgF5rCNYbuCEWLaXkBa/rIXgFnrGQr5Bf5pqyn
 utysw+RpP5/MxhB2XPjplu4GZVPTIVJYgmHjMAtTFaRPmcRQl7JeeO0YEqX+ry2G3uzvpy9f
 jpz0hKrL8j+DTS+lQWaRaph0moaU69MAQ6d2HzdiagsYnlbbJfhZ6GSIJBvXSOtehsnMQ5lD
 p1SgdwmmjCDocsKD5vu/553OffAZw4N7AapsgnLufhaYV9OJbFpCRoy7MQA0DVHxcDCVFNgY
 Bz0aBPG6w8oA1cm7CR3nM0g7MKWAGc1vkZa+pMnlIDGySohFD+2r3UEy3OENU9iiaUZydxr4
 2PXZwQg3L2+YcBd01uJYQaQ5NyC5g9pxT3/WMFsdJQWncECeeIyER8mgCWshNhRInpDciOV+
 2lzH4lSGqO1tCDguRG4Q36tsn2sXApHnf6OuXjXF0c7BTQRgb83mARAA8mmfBNxj8CppO6Xb
 helhSkisZB0S85cq2LBvpc7tUxBwJlJ8BuI4Z1Dr6vbs/pioY2pvXAd0og/L4nV1ihCI8ban
 sWvzQHzj1Dr7q8+9X3FyD7T4rmJ4xvZXgv8XnB1i/7NNENyQ2yB2Pqg2JeWcKgwehpR03Hse
 0dAZ0VMPu9+wvHncfF0pIrD7Wdt2y9gXP2P3bmqCBd9Bbr3Dah+tIbPAvAHbKyP2lM0g2h+Q
 GnkdSg1VKviJ23IoNUqJbeMZKI68z1Pc1Ww8KPD5OzwzW/AnVBA+B2OO2kmDFZY9K3WtMKP3
 TjbSDvthSv6ir6IUdLA7tlgPtuvM7agaSWtGoM0x1nidycjO6FvOGij9vqIRu/J9FwiegHke
 odCSAlh/NHyDWDRgK9mU+4WuZ96hOavBGnenMbyuvNdp2k6yyoYjpUQsimIkFaYVtBn5vrfz
 YL+vpyLC/LeLaYJq8mr7FwuXZ474bmCA8VhwRpyIpuQedVWz6DHNtTmsP/JjuH8lIArj2/zJ
 silliHzktOZmF7hdkHMeNt4NX9Lb33JBIQxQqlemSseYeW/gglvloRyLVHN343CCshKjW4qv
 Ob1zJIDXONloDLZhQoqfLniXLzeM+VDJOY3/zMxDXyvodQED6uZcqKo/hYXu6eEkSwW3HVub
 8zeifVHnqSGHOL7xk/sAEQEAAcLBdgQYAQgAIBYhBEtFPOcPJkYEQXG6zg8CcsDTrJH3BQJg
 b83mAhsMAAoJEA8CcsDTrJH3wKwP/3ib0bcgNaQl3y00Ee1MEpynenyHA4egU5ARgsO7oNic
 49E2IYfaz8xcw/HmMvLTR1clmbFNEcGodkvp3aVCtK6JKixhv+JXH6DGASYvwsmEktrbmcTw
 vhfWlwxCnPW6+tpk62wFn/7GMN3YoJHstEfenK1o9dwWr3Z4Jt7ZaCDt2u6bS/QZvsmNhdmG
 qls7+8Q+qxiZoNKfBG3L5Ii7xr9pqmQPHjaVsF5WnNOhZrSyh3832PBmrybEDQK76yN/4Gs1
 BNrtkCNS3DPJbe0xqr4XCg/MiFoJprKBA63zm0S62y7M/4KOTn7P+KoUUoPvx3svR8gNGy3U
 P44PIH/td2qTkcapmsfcyPjP9pGQJpWZR+eIGFzhKX35qgUdhUba0xzoGz7/boflBlwv1mem
 TwBMdIPm68Yhfzh07MU/fyD4RX5S5BjMkcaYJ01INzvmzx67nIpEKmQlav3dn9nGfmmdqxTQ
 ngKNE5Qst37L862tSuFb5nRAqLFYpNfnFkb3YLSZos2UncGK8a6wnUCcTnYL5qkUbcackV/G
 j/NDNSrZZlg1RYHwJii4P2sb/j0FykcxwsYtjCWM5U28FM4dhCiT1IhwGs6pKhugFTC7uAjE
 1z8ZAw+Cdd8R9+XPgwM2rtWoND8mCjRbEZnLjnGytw3jxOoj39wlm3Myb2XnQRY2
In-Reply-To: <3523927.LZWGnKmheA@fedora>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
X-Spam-Score: 0.0 (/)
X-BeenThere: debbugs-submit <at> debbugs.gnu.org
X-Mailman-Version: 2.1.18
Precedence: list
List-Id: <debbugs-submit.debbugs.gnu.org>
List-Unsubscribe: <https://debbugs.gnu.org/cgi-bin/mailman/options/debbugs-submit>, 
 <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=unsubscribe>
List-Archive: <https://debbugs.gnu.org/cgi-bin/mailman/private/debbugs-submit/>
List-Post: <mailto:debbugs-submit <at> debbugs.gnu.org>
List-Help: <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=help>
List-Subscribe: <https://debbugs.gnu.org/cgi-bin/mailman/listinfo/debbugs-submit>, 
 <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=subscribe>
Errors-To: debbugs-submit-bounces <at> debbugs.gnu.org
Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>
X-Spam-Score: -1.0 (-)

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

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

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

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


Can you reproduce this?

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

Message sent to bug-gnu-emacs@HIDDEN:

X-Loop: help-debbugs@HIDDEN
Subject: bug#77914: 31.0.50; treesit-font-lock-level set to 4 cause rust-ts-mode lost all color
Resent-From: Eli Zaretskii <eliz@HIDDEN>
Original-Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>
Resent-CC: bug-gnu-emacs@HIDDEN
Resent-Date: Sun, 20 Apr 2025 08:18:02 +0000
Resent-Message-ID: <handler.77914.B77914.174513707522249 <at> debbugs.gnu.org>
Resent-Sender: help-debbugs@HIDDEN
X-GNU-PR-Message: followup 77914
X-GNU-PR-Package: emacs
X-GNU-PR-Keywords: 
To: Juri Linkov <juri@HIDDEN>
Cc: execvy@HIDDEN, v.pupillo@HIDDEN, 77914 <at> debbugs.gnu.org
Received: via spool by 77914-submit <at> debbugs.gnu.org id=B77914.174513707522249
          (code B ref 77914); Sun, 20 Apr 2025 08:18:02 +0000
Received: (at 77914) by debbugs.gnu.org; 20 Apr 2025 08:17:55 +0000
Received: from localhost ([127.0.0.1]:44892 helo=debbugs.gnu.org)
	by debbugs.gnu.org with esmtp (Exim 4.84_2)
	(envelope-from <debbugs-submit-bounces <at> debbugs.gnu.org>)
	id 1u6PsB-0005mn-57
	for submit <at> debbugs.gnu.org; Sun, 20 Apr 2025 04:17:55 -0400
Received: from eggs.gnu.org ([2001:470:142:3::10]:43102)
 by debbugs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256)
 (Exim 4.84_2) (envelope-from <eliz@HIDDEN>) id 1u6Ps8-0005mV-Lo
 for 77914 <at> debbugs.gnu.org; Sun, 20 Apr 2025 04:17:53 -0400
Received: from fencepost.gnu.org ([2001:470:142:3::e])
 by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256)
 (Exim 4.90_1) (envelope-from <eliz@HIDDEN>)
 id 1u6Ps2-00050K-Qo; Sun, 20 Apr 2025 04:17:46 -0400
DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=gnu.org;
 s=fencepost-gnu-org; h=References:Subject:In-Reply-To:To:From:Date:
 mime-version; bh=YUwyfiEDtzXvOE4+CZFuL5yjwAKaYo6fnju/S4mN768=; b=UdFxCDSedEke
 lQ8KUXfozFc4Esj6zMrCGftxDIXElR1DDHY+bH+ths6A420LdCD1ZWPNStLsanWVKTDllAzv9DqxY
 wEpsqPKpbib528YuEaLSJoXox4dyoshPeHjBl/7TJx8l2MuYfawg4J9WZb4V1Q6fpnm03Gb3LJGj1
 sNWCUBIIxIPshwiNdObjthO5vtS5vMETOsi8BiOlRm3mudxBHHmL5Z5+HUFAW/W8MhU1BRfXLiSEn
 4W3IWHRpOF1AFPxwH/iVbfsBFdq1APpPUdM7Q/CT8b7gjttswl43VihkyH/+KAMJndXt7GlOb+adv
 q0UoNKY+nMOuiCQ7IvqzuQ==;
Date: Sun, 20 Apr 2025 11:17:44 +0300
Message-Id: <865xiz6yc7.fsf@HIDDEN>
From: Eli Zaretskii <eliz@HIDDEN>
In-Reply-To: <87mscbe5a8.fsf@HIDDEN> (message from Juri Linkov on
 Sun, 20 Apr 2025 09:15:51 +0300)
References: <877c3gka72.fsf@HIDDEN> <3523927.LZWGnKmheA@fedora>
 <87mscbe5a8.fsf@HIDDEN>
X-Spam-Score: -2.3 (--)
X-BeenThere: debbugs-submit <at> debbugs.gnu.org
X-Mailman-Version: 2.1.18
Precedence: list
List-Id: <debbugs-submit.debbugs.gnu.org>
List-Unsubscribe: <https://debbugs.gnu.org/cgi-bin/mailman/options/debbugs-submit>, 
 <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=unsubscribe>
List-Archive: <https://debbugs.gnu.org/cgi-bin/mailman/private/debbugs-submit/>
List-Post: <mailto:debbugs-submit <at> debbugs.gnu.org>
List-Help: <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=help>
List-Subscribe: <https://debbugs.gnu.org/cgi-bin/mailman/listinfo/debbugs-submit>, 
 <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=subscribe>
Errors-To: debbugs-submit-bounces <at> debbugs.gnu.org
Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>
X-Spam-Score: -3.3 (---)

> Cc: Eval Exec <execvy@HIDDEN>, 77914 <at> debbugs.gnu.org
> From: Juri Linkov <juri@HIDDEN>
> Date: Sun, 20 Apr 2025 09:15:51 +0300
> 
> > 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)
> 
> Maybe this is related to Rust grammar version mismatch
> where the current rust-ts-mode works only with
> tree-sitter-rust v0.23.0:
> 
> https://lists.gnu.org/archive/html/emacs-devel/2025-04/msg00430.html

If this is the reason, it would be good to adapt rust-ts-mode to a
newer grammar version.

Message sent to bug-gnu-emacs@HIDDEN:

X-Loop: help-debbugs@HIDDEN
Subject: bug#77914: 31.0.50; treesit-font-lock-level set to 4 cause rust-ts-mode lost all color
Resent-From: Eli Zaretskii <eliz@HIDDEN>
Original-Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>
Resent-CC: bug-gnu-emacs@HIDDEN
Resent-Date: Sun, 20 Apr 2025 09:30:02 +0000
Resent-Message-ID: <handler.77914.B77914.17451413573082 <at> debbugs.gnu.org>
Resent-Sender: help-debbugs@HIDDEN
X-GNU-PR-Message: followup 77914
X-GNU-PR-Package: emacs
X-GNU-PR-Keywords: 
To: Eval Exec <execvy@HIDDEN>
Cc: v.pupillo@HIDDEN, 77914 <at> debbugs.gnu.org
Received: via spool by 77914-submit <at> debbugs.gnu.org id=B77914.17451413573082
          (code B ref 77914); Sun, 20 Apr 2025 09:30:02 +0000
Received: (at 77914) by debbugs.gnu.org; 20 Apr 2025 09:29:17 +0000
Received: from localhost ([127.0.0.1]:45009 helo=debbugs.gnu.org)
	by debbugs.gnu.org with esmtp (Exim 4.84_2)
	(envelope-from <debbugs-submit-bounces <at> debbugs.gnu.org>)
	id 1u6QzE-0000ne-OZ
	for submit <at> debbugs.gnu.org; Sun, 20 Apr 2025 05:29:17 -0400
Received: from eggs.gnu.org ([2001:470:142:3::10]:36790)
 by debbugs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256)
 (Exim 4.84_2) (envelope-from <eliz@HIDDEN>) id 1u6QzD-0000nP-Ch
 for 77914 <at> debbugs.gnu.org; Sun, 20 Apr 2025 05:29:15 -0400
Received: from fencepost.gnu.org ([2001:470:142:3::e])
 by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256)
 (Exim 4.90_1) (envelope-from <eliz@HIDDEN>)
 id 1u6Qz8-0004sj-3i; Sun, 20 Apr 2025 05:29:10 -0400
DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=gnu.org;
 s=fencepost-gnu-org; h=References:Subject:In-Reply-To:To:From:Date:
 mime-version; bh=luoh+FL9qh0vNn7c/w0bLf0B1vMA5ShllzPK7wtDzWc=; b=j5/zwrQPO/od
 8M1jqc2F91NKaUEhcZpCvNXEJKgTpK/B1SvZdok2vGh+gN2eUdmeixZR91ktgRFQF8u9aleLCQc+B
 8/4ulN4V324giiJTYeUsse3QFHLzAUMgl4Pl/Pj8gHVOpnO6XiziLPWPkTovDuQSiom/fiyO5oq02
 sLkzgOtfDOWqfjod2kXkk68Np1JYHiEtKNhrkvAc9E4WunTIuQxq20gaDhE6KPuaQzOF3870j/T9j
 GC8BsLD6a+cJxWc63s8UrfE10tTWX8uK0+Ml0nYlyAuGNtIE9CHFIfM2QJMztUhn0g0Z4GRTvvFcC
 8K6kl84qWbjE7bxkNjxSPw==;
Date: Sun, 20 Apr 2025 12:29:07 +0300
Message-Id: <86wmbf5ggs.fsf@HIDDEN>
From: Eli Zaretskii <eliz@HIDDEN>
In-Reply-To: <5af658c9-70e0-4dd2-82ba-d528021771c1@HIDDEN> (message from
 Eval Exec on Sun, 20 Apr 2025 15:19:20 +0800)
References: <877c3gka72.fsf@HIDDEN> <3523927.LZWGnKmheA@fedora>
 <5af658c9-70e0-4dd2-82ba-d528021771c1@HIDDEN>
X-Spam-Score: -2.3 (--)
X-BeenThere: debbugs-submit <at> debbugs.gnu.org
X-Mailman-Version: 2.1.18
Precedence: list
List-Id: <debbugs-submit.debbugs.gnu.org>
List-Unsubscribe: <https://debbugs.gnu.org/cgi-bin/mailman/options/debbugs-submit>, 
 <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=unsubscribe>
List-Archive: <https://debbugs.gnu.org/cgi-bin/mailman/private/debbugs-submit/>
List-Post: <mailto:debbugs-submit <at> debbugs.gnu.org>
List-Help: <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=help>
List-Subscribe: <https://debbugs.gnu.org/cgi-bin/mailman/listinfo/debbugs-submit>, 
 <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=subscribe>
Errors-To: debbugs-submit-bounces <at> debbugs.gnu.org
Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>
X-Spam-Score: -3.3 (---)

> Date: Sun, 20 Apr 2025 15:19:20 +0800
> From: Eval Exec <execvy@HIDDEN>
> 
> 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.

Don't use setq, use setopt.  treesit-font-lock-level is a defcustom,
and it has a setter function.

Last modified: Sun, 20 Apr 2025 09:45:02 UTC

GNU bug tracking system
Copyright (C) 1999 Darren O. Benham, 1997 nCipher Corporation Ltd, 1994-97 Ian Jackson.