GNU bug report logs - #77914
31.0.50; treesit-font-lock-level set to 4 cause rust-ts-mode lost all color

Previous Next

To reply to this bug, email your comments to 77914 AT debbugs.gnu.org.

Toggle the display of automated, internal messages from the tracker.

Message #5 received at submit <at> debbugs.gnu.org (full text, mbox):

From: Eval Exec <execvy <at> gmail.com>
To: bug-gnu-emacs <at> gnu.org
Subject: 31.0.50; treesit-font-lock-level set to 4 cause rust-ts-mode lost
 all color
Date: Sat, 19 Apr 2025 13:10:57 +0800

Hello,
I'm visiting a rust file, when I set treesit-font-lock-level to 3, all
color are good, when I set treesit-font-lock-level to 4, all color as
lost.
To reproduce this: use this rust file:

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

2. (progn  (setq treesit-font-lock-level 4) (revert-buffer))
colors are good.

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


```rust

//! Primitive traits and types representing basic properties of types.
//!
//! Rust types can be classified in various useful ways according to
//! their intrinsic properties. These classifications are represented
//! as traits.

#![stable(feature = "rust1", since = "1.0.0")]

use crate::cell::UnsafeCell;
use crate::cmp;
use crate::fmt::Debug;
use crate::hash::{Hash, Hasher};

/// Implements a given marker trait for multiple types at the same time.
///
/// The basic syntax looks like this:
/// ```ignore private macro
/// marker_impls! { MarkerTrait for u8, i8 }
/// ```
/// You can also implement `unsafe` traits
/// ```ignore private macro
/// marker_impls! { unsafe MarkerTrait for u8, i8 }
/// ```
/// Add attributes to all impls:
/// ```ignore private macro
/// marker_impls! {
///     #[allow(lint)]
///     #[unstable(feature = "marker_trait", issue = "none")]
///     MarkerTrait for u8, i8
/// }
/// ```
/// And use generics:
/// ```ignore private macro
/// marker_impls! {
///     MarkerTrait for
///         u8, i8,
///         {T: ?Sized} *const T,
///         {T: ?Sized} *mut T,
///         {T: MarkerTrait} PhantomData<T>,
///         u32,
/// }
/// ```
#[unstable(feature = "internal_impls_macro", issue = "none")]
// Allow implementations of `UnsizedConstParamTy` even though std cannot use that feature.
#[allow_internal_unstable(unsized_const_params)]
macro marker_impls {
    ( $(#[$($meta:tt)*])* $Trait:ident for $({$($bounds:tt)*})? $T:ty $(, $($rest:tt)*)? ) => {
        $(#[$($meta)*])* impl< $($($bounds)*)? > $Trait for $T {}
        marker_impls! { $(#[$($meta)*])* $Trait for $($($rest)*)? }
    },
    ( $(#[$($meta:tt)*])* $Trait:ident for ) => {},

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

/// Types that can be transferred across thread boundaries.
///
/// This trait is automatically implemented when the compiler determines it's
/// appropriate.
///
/// An example of a non-`Send` type is the reference-counting pointer
/// [`rc::Rc`][`Rc`]. If two threads attempt to clone [`Rc`]s that point to the same
/// reference-counted value, they might try to update the reference count at the
/// same time, which is [undefined behavior][ub] because [`Rc`] doesn't use atomic
/// operations. Its cousin [`sync::Arc`][arc] does use atomic operations (incurring
/// some overhead) and thus is `Send`.
///
/// See [the Nomicon](../../nomicon/send-and-sync.html) and the [`Sync`] trait for more details.
///
/// [`Rc`]: ../../std/rc/struct.Rc.html
/// [arc]: ../../std/sync/struct.Arc.html
/// [ub]: ../../reference/behavior-considered-undefined.html
#[stable(feature = "rust1", since = "1.0.0")]
#[cfg_attr(not(test), rustc_diagnostic_item = "Send")]
#[diagnostic::on_unimplemented(
    message = "`{Self}` cannot be sent between threads safely",
    label = "`{Self}` cannot be sent between threads safely"
)]
pub unsafe auto trait Send {
    // empty.
}

#[stable(feature = "rust1", since = "1.0.0")]
impl<T: ?Sized> !Send for *const T {}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: ?Sized> !Send for *mut T {}

// Most instances arise automatically, but this instance is needed to link up `T: Sync` with
// `&T: Send` (and it also removes the unsound default instance `T Send` -> `&T: Send` that would
// otherwise exist).
#[stable(feature = "rust1", since = "1.0.0")]
unsafe impl<T: Sync + ?Sized> Send for &T {}

/// Types with a constant size known at compile time.
///
/// All type parameters have an implicit bound of `Sized`. The special syntax
/// `?Sized` can be used to remove this bound if it's not appropriate.
///
/// ```
/// # #![allow(dead_code)]
/// struct Foo<T>(T);
/// struct Bar<T: ?Sized>(T);
///
/// // struct FooUse(Foo<[i32]>); // error: Sized is not implemented for [i32]
/// struct BarUse(Bar<[i32]>); // OK
/// ```
///
/// The one exception is the implicit `Self` type of a trait. A trait does not
/// have an implicit `Sized` bound as this is incompatible with [trait object]s
/// where, by definition, the trait needs to work with all possible implementors,
/// and thus could be any size.
///
/// Although Rust will let you bind `Sized` to a trait, you won't
/// be able to use it to form a trait object later:
///
/// ```
/// # #![allow(unused_variables)]
/// trait Foo { }
/// trait Bar: Sized { }
///
/// struct Impl;
/// impl Foo for Impl { }
/// impl Bar for Impl { }
///
/// let x: &dyn Foo = &Impl;    // OK
/// // let y: &dyn Bar = &Impl; // error: the trait `Bar` cannot
///                             // be made into an object
/// ```
///
/// [trait object]: ../../book/ch17-02-trait-objects.html
#[doc(alias = "?", alias = "?Sized")]
#[stable(feature = "rust1", since = "1.0.0")]
#[lang = "sized"]
#[diagnostic::on_unimplemented(
    message = "the size for values of type `{Self}` cannot be known at compilation time",
    label = "doesn't have a size known at compile-time"
)]
#[fundamental] // for Default, for example, which requires that `[T]: !Default` be evaluatable
#[rustc_specialization_trait]
#[cfg_attr(bootstrap, rustc_deny_explicit_impl(implement_via_object = false))]
#[cfg_attr(not(bootstrap), rustc_deny_explicit_impl)]
#[cfg_attr(not(bootstrap), rustc_do_not_implement_via_object)]
#[rustc_coinductive]
pub trait Sized {
    // Empty.
}

/// Types that can be "unsized" to a dynamically-sized type.
///
/// For example, the sized array type `[i8; 2]` implements `Unsize<[i8]>` and
/// `Unsize<dyn fmt::Debug>`.
///
/// All implementations of `Unsize` are provided automatically by the compiler.
/// Those implementations are:
///
/// - Arrays `[T; N]` implement `Unsize<[T]>`.
/// - A type implements `Unsize<dyn Trait + 'a>` if all of these conditions are met:
///   - The type implements `Trait`.
///   - `Trait` is dyn-compatible[^1].
///   - The type is sized.
///   - The type outlives `'a`.
/// - Structs `Foo<..., T1, ..., Tn, ...>` implement `Unsize<Foo<..., U1, ..., Un, ...>>`
/// where any number of (type and const) parameters may be changed if all of these conditions
/// are met:
///   - Only the last field of `Foo` has a type involving the parameters `T1`, ..., `Tn`.
///   - All other parameters of the struct are equal.
///   - `Field<T1, ..., Tn>: Unsize<Field<U1, ..., Un>>`, where `Field<...>` stands for the actual
///     type of the struct's last field.
///
/// `Unsize` is used along with [`ops::CoerceUnsized`] to allow
/// "user-defined" containers such as [`Rc`] to contain dynamically-sized
/// types. See the [DST coercion RFC][RFC982] and [the nomicon entry on coercion][nomicon-coerce]
/// for more details.
///
/// [`ops::CoerceUnsized`]: crate::ops::CoerceUnsized
/// [`Rc`]: ../../std/rc/struct.Rc.html
/// [RFC982]: https://github.com/rust-lang/rfcs/blob/master/text/0982-dst-coercion.md
/// [nomicon-coerce]: ../../nomicon/coercions.html
/// [^1]: Formerly known as *object safe*.
#[unstable(feature = "unsize", issue = "18598")]
#[lang = "unsize"]
#[cfg_attr(bootstrap, rustc_deny_explicit_impl(implement_via_object = false))]
#[cfg_attr(not(bootstrap), rustc_deny_explicit_impl)]
#[cfg_attr(not(bootstrap), rustc_do_not_implement_via_object)]
pub trait Unsize<T: ?Sized> {
    // Empty.
}

/// Required trait for constants used in pattern matches.
///
/// Any type that derives `PartialEq` automatically implements this trait,
/// *regardless* of whether its type-parameters implement `PartialEq`.
///
/// If a `const` item contains some type that does not implement this trait,
/// then that type either (1.) does not implement `PartialEq` (which means the
/// constant will not provide that comparison method, which code generation
/// assumes is available), or (2.) it implements *its own* version of
/// `PartialEq` (which we assume does not conform to a structural-equality
/// comparison).
///
/// In either of the two scenarios above, we reject usage of such a constant in
/// a pattern match.
///
/// See also the [structural match RFC][RFC1445], and [issue 63438] which
/// motivated migrating from an attribute-based design to this trait.
///
/// [RFC1445]: https://github.com/rust-lang/rfcs/blob/master/text/1445-restrict-constants-in-patterns.md
/// [issue 63438]: https://github.com/rust-lang/rust/issues/63438
#[unstable(feature = "structural_match", issue = "31434")]
#[diagnostic::on_unimplemented(message = "the type `{Self}` does not `#[derive(PartialEq)]`")]
#[lang = "structural_peq"]
pub trait StructuralPartialEq {
    // Empty.
}

marker_impls! {
    #[unstable(feature = "structural_match", issue = "31434")]
    StructuralPartialEq for
        usize, u8, u16, u32, u64, u128,
        isize, i8, i16, i32, i64, i128,
        bool,
        char,
        str /* Technically requires `[u8]: StructuralPartialEq` */,
        (),
        {T, const N: usize} [T; N],
        {T} [T],
        {T: ?Sized} &T,
}

/// Types whose values can be duplicated simply by copying bits.
///
/// By default, variable bindings have 'move semantics.' In other
/// words:
///
/// ```
/// #[derive(Debug)]
/// struct Foo;
///
/// let x = Foo;
///
/// let y = x;
///
/// // `x` has moved into `y`, and so cannot be used
///
/// // println!("{x:?}"); // error: use of moved value
/// ```
///
/// However, if a type implements `Copy`, it instead has 'copy semantics':
///
/// ```
/// // We can derive a `Copy` implementation. `Clone` is also required, as it's
/// // a supertrait of `Copy`.
/// #[derive(Debug, Copy, Clone)]
/// struct Foo;
///
/// let x = Foo;
///
/// let y = x;
///
/// // `y` is a copy of `x`
///
/// println!("{x:?}"); // A-OK!
/// ```
///
/// It's important to note that in these two examples, the only difference is whether you
/// are allowed to access `x` after the assignment. Under the hood, both a copy and a move
/// can result in bits being copied in memory, although this is sometimes optimized away.
///
/// ## How can I implement `Copy`?
///
/// There are two ways to implement `Copy` on your type. The simplest is to use `derive`:
///
/// ```
/// #[derive(Copy, Clone)]
/// struct MyStruct;
/// ```
///
/// You can also implement `Copy` and `Clone` manually:
///
/// ```
/// struct MyStruct;
///
/// impl Copy for MyStruct { }
///
/// impl Clone for MyStruct {
///     fn clone(&self) -> MyStruct {
///         *self
///     }
/// }
/// ```
///
/// There is a small difference between the two. The `derive` strategy will also place a `Copy`
/// bound on type parameters:
///
/// ```
/// #[derive(Clone)]
/// struct MyStruct<T>(T);
///
/// impl<T: Copy> Copy for MyStruct<T> { }
/// ```
///
/// This isn't always desired. For example, shared references (`&T`) can be copied regardless of
/// whether `T` is `Copy`. Likewise, a generic struct containing markers such as [`PhantomData`]
/// could potentially be duplicated with a bit-wise copy.
///
/// ## What's the difference between `Copy` and `Clone`?
///
/// Copies happen implicitly, for example as part of an assignment `y = x`. The behavior of
/// `Copy` is not overloadable; it is always a simple bit-wise copy.
///
/// Cloning is an explicit action, `x.clone()`. The implementation of [`Clone`] can
/// provide any type-specific behavior necessary to duplicate values safely. For example,
/// the implementation of [`Clone`] for [`String`] needs to copy the pointed-to string
/// buffer in the heap. A simple bitwise copy of [`String`] values would merely copy the
/// pointer, leading to a double free down the line. For this reason, [`String`] is [`Clone`]
/// but not `Copy`.
///
/// [`Clone`] is a supertrait of `Copy`, so everything which is `Copy` must also implement
/// [`Clone`]. If a type is `Copy` then its [`Clone`] implementation only needs to return `*self`
/// (see the example above).
///
/// ## When can my type be `Copy`?
///
/// A type can implement `Copy` if all of its components implement `Copy`. For example, this
/// struct can be `Copy`:
///
/// ```
/// # #[allow(dead_code)]
/// #[derive(Copy, Clone)]
/// struct Point {
///    x: i32,
///    y: i32,
/// }
/// ```
///
/// A struct can be `Copy`, and [`i32`] is `Copy`, therefore `Point` is eligible to be `Copy`.
/// By contrast, consider
///
/// ```
/// # #![allow(dead_code)]
/// # struct Point;
/// struct PointList {
///     points: Vec<Point>,
/// }
/// ```
///
/// The struct `PointList` cannot implement `Copy`, because [`Vec<T>`] is not `Copy`. If we
/// attempt to derive a `Copy` implementation, we'll get an error:
///
/// ```text
/// the trait `Copy` cannot be implemented for this type; field `points` does not implement `Copy`
/// ```
///
/// Shared references (`&T`) are also `Copy`, so a type can be `Copy`, even when it holds
/// shared references of types `T` that are *not* `Copy`. Consider the following struct,
/// which can implement `Copy`, because it only holds a *shared reference* to our non-`Copy`
/// type `PointList` from above:
///
/// ```
/// # #![allow(dead_code)]
/// # struct PointList;
/// #[derive(Copy, Clone)]
/// struct PointListWrapper<'a> {
///     point_list_ref: &'a PointList,
/// }
/// ```
///
/// ## When *can't* my type be `Copy`?
///
/// Some types can't be copied safely. For example, copying `&mut T` would create an aliased
/// mutable reference. Copying [`String`] would duplicate responsibility for managing the
/// [`String`]'s buffer, leading to a double free.
///
/// Generalizing the latter case, any type implementing [`Drop`] can't be `Copy`, because it's
/// managing some resource besides its own [`size_of::<T>`] bytes.
///
/// If you try to implement `Copy` on a struct or enum containing non-`Copy` data, you will get
/// the error [E0204].
///
/// [E0204]: ../../error_codes/E0204.html
///
/// ## When *should* my type be `Copy`?
///
/// Generally speaking, if your type _can_ implement `Copy`, it should. Keep in mind, though,
/// that implementing `Copy` is part of the public API of your type. If the type might become
/// non-`Copy` in the future, it could be prudent to omit the `Copy` implementation now, to
/// avoid a breaking API change.
///
/// ## Additional implementors
///
/// In addition to the [implementors listed below][impls],
/// the following types also implement `Copy`:
///
/// * Function item types (i.e., the distinct types defined for each function)
/// * Function pointer types (e.g., `fn() -> i32`)
/// * Closure types, if they capture no value from the environment
///   or if all such captured values implement `Copy` themselves.
///   Note that variables captured by shared reference always implement `Copy`
///   (even if the referent doesn't),
///   while variables captured by mutable reference never implement `Copy`.
///
/// [`Vec<T>`]: ../../std/vec/struct.Vec.html
/// [`String`]: ../../std/string/struct.String.html
/// [`size_of::<T>`]: crate::mem::size_of
/// [impls]: #implementors
#[stable(feature = "rust1", since = "1.0.0")]
#[lang = "copy"]
// FIXME(matthewjasper) This allows copying a type that doesn't implement
// `Copy` because of unsatisfied lifetime bounds (copying `A<'_>` when only
// `A<'static>: Copy` and `A<'_>: Clone`).
// We have this attribute here for now only because there are quite a few
// existing specializations on `Copy` that already exist in the standard
// library, and there's no way to safely have this behavior right now.
#[rustc_unsafe_specialization_marker]
#[rustc_diagnostic_item = "Copy"]
pub trait Copy: Clone {
    // Empty.
}

/// Derive macro generating an impl of the trait `Copy`.
#[rustc_builtin_macro]
#[stable(feature = "builtin_macro_prelude", since = "1.38.0")]
#[allow_internal_unstable(core_intrinsics, derive_clone_copy)]
pub macro Copy($item:item) {
    /* compiler built-in */
}

// Implementations of `Copy` for primitive types.
//
// Implementations that cannot be described in Rust
// are implemented in `traits::SelectionContext::copy_clone_conditions()`
// in `rustc_trait_selection`.
marker_impls! {
    #[stable(feature = "rust1", since = "1.0.0")]
    Copy for
        usize, u8, u16, u32, u64, u128,
        isize, i8, i16, i32, i64, i128,
        f16, f32, f64, f128,
        bool, char,
        {T: ?Sized} *const T,
        {T: ?Sized} *mut T,

}

#[unstable(feature = "never_type", issue = "35121")]
impl Copy for ! {}

/// Shared references can be copied, but mutable references *cannot*!
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: ?Sized> Copy for &T {}

/// Types for which it is safe to share references between threads.
///
/// This trait is automatically implemented when the compiler determines
/// it's appropriate.
///
/// The precise definition is: a type `T` is [`Sync`] if and only if `&T` is
/// [`Send`]. In other words, if there is no possibility of
/// [undefined behavior][ub] (including data races) when passing
/// `&T` references between threads.
///
/// As one would expect, primitive types like [`u8`] and [`f64`]
/// are all [`Sync`], and so are simple aggregate types containing them,
/// like tuples, structs and enums. More examples of basic [`Sync`]
/// types include "immutable" types like `&T`, and those with simple
/// inherited mutability, such as [`Box<T>`][box], [`Vec<T>`][vec] and
/// most other collection types. (Generic parameters need to be [`Sync`]
/// for their container to be [`Sync`].)
///
/// A somewhat surprising consequence of the definition is that `&mut T`
/// is `Sync` (if `T` is `Sync`) even though it seems like that might
/// provide unsynchronized mutation. The trick is that a mutable
/// reference behind a shared reference (that is, `& &mut T`)
/// becomes read-only, as if it were a `& &T`. Hence there is no risk
/// of a data race.
///
/// A shorter overview of how [`Sync`] and [`Send`] relate to referencing:
/// * `&T` is [`Send`] if and only if `T` is [`Sync`]
/// * `&mut T` is [`Send`] if and only if `T` is [`Send`]
/// * `&T` and `&mut T` are [`Sync`] if and only if `T` is [`Sync`]
///
/// Types that are not `Sync` are those that have "interior
/// mutability" in a non-thread-safe form, such as [`Cell`][cell]
/// and [`RefCell`][refcell]. These types allow for mutation of
/// their contents even through an immutable, shared reference. For
/// example the `set` method on [`Cell<T>`][cell] takes `&self`, so it requires
/// only a shared reference [`&Cell<T>`][cell]. The method performs no
/// synchronization, thus [`Cell`][cell] cannot be `Sync`.
///
/// Another example of a non-`Sync` type is the reference-counting
/// pointer [`Rc`][rc]. Given any reference [`&Rc<T>`][rc], you can clone
/// a new [`Rc<T>`][rc], modifying the reference counts in a non-atomic way.
///
/// For cases when one does need thread-safe interior mutability,
/// Rust provides [atomic data types], as well as explicit locking via
/// [`sync::Mutex`][mutex] and [`sync::RwLock`][rwlock]. These types
/// ensure that any mutation cannot cause data races, hence the types
/// are `Sync`. Likewise, [`sync::Arc`][arc] provides a thread-safe
/// analogue of [`Rc`][rc].
///
/// Any types with interior mutability must also use the
/// [`cell::UnsafeCell`][unsafecell] wrapper around the value(s) which
/// can be mutated through a shared reference. Failing to doing this is
/// [undefined behavior][ub]. For example, [`transmute`][transmute]-ing
/// from `&T` to `&mut T` is invalid.
///
/// See [the Nomicon][nomicon-send-and-sync] for more details about `Sync`.
///
/// [box]: ../../std/boxed/struct.Box.html
/// [vec]: ../../std/vec/struct.Vec.html
/// [cell]: crate::cell::Cell
/// [refcell]: crate::cell::RefCell
/// [rc]: ../../std/rc/struct.Rc.html
/// [arc]: ../../std/sync/struct.Arc.html
/// [atomic data types]: crate::sync::atomic
/// [mutex]: ../../std/sync/struct.Mutex.html
/// [rwlock]: ../../std/sync/struct.RwLock.html
/// [unsafecell]: crate::cell::UnsafeCell
/// [ub]: ../../reference/behavior-considered-undefined.html
/// [transmute]: crate::mem::transmute
/// [nomicon-send-and-sync]: ../../nomicon/send-and-sync.html
#[stable(feature = "rust1", since = "1.0.0")]
#[cfg_attr(not(test), rustc_diagnostic_item = "Sync")]
#[lang = "sync"]
#[rustc_on_unimplemented(
    on(
        _Self = "core::cell::once::OnceCell<T>",
        note = "if you want to do aliasing and mutation between multiple threads, use `std::sync::OnceLock` instead"
    ),
    on(
        _Self = "core::cell::Cell<u8>",
        note = "if you want to do aliasing and mutation between multiple threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicU8` instead",
    ),
    on(
        _Self = "core::cell::Cell<u16>",
        note = "if you want to do aliasing and mutation between multiple threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicU16` instead",
    ),
    on(
        _Self = "core::cell::Cell<u32>",
        note = "if you want to do aliasing and mutation between multiple threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicU32` instead",
    ),
    on(
        _Self = "core::cell::Cell<u64>",
        note = "if you want to do aliasing and mutation between multiple threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicU64` instead",
    ),
    on(
        _Self = "core::cell::Cell<usize>",
        note = "if you want to do aliasing and mutation between multiple threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicUsize` instead",
    ),
    on(
        _Self = "core::cell::Cell<i8>",
        note = "if you want to do aliasing and mutation between multiple threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicI8` instead",
    ),
    on(
        _Self = "core::cell::Cell<i16>",
        note = "if you want to do aliasing and mutation between multiple threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicI16` instead",
    ),
    on(
        _Self = "core::cell::Cell<i32>",
        note = "if you want to do aliasing and mutation between multiple threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicI32` instead",
    ),
    on(
        _Self = "core::cell::Cell<i64>",
        note = "if you want to do aliasing and mutation between multiple threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicI64` instead",
    ),
    on(
        _Self = "core::cell::Cell<isize>",
        note = "if you want to do aliasing and mutation between multiple threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicIsize` instead",
    ),
    on(
        _Self = "core::cell::Cell<bool>",
        note = "if you want to do aliasing and mutation between multiple threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicBool` instead",
    ),
    on(
        all(
            _Self = "core::cell::Cell<T>",
            not(_Self = "core::cell::Cell<u8>"),
            not(_Self = "core::cell::Cell<u16>"),
            not(_Self = "core::cell::Cell<u32>"),
            not(_Self = "core::cell::Cell<u64>"),
            not(_Self = "core::cell::Cell<usize>"),
            not(_Self = "core::cell::Cell<i8>"),
            not(_Self = "core::cell::Cell<i16>"),
            not(_Self = "core::cell::Cell<i32>"),
            not(_Self = "core::cell::Cell<i64>"),
            not(_Self = "core::cell::Cell<isize>"),
            not(_Self = "core::cell::Cell<bool>")
        ),
        note = "if you want to do aliasing and mutation between multiple threads, use `std::sync::RwLock`",
    ),
    on(
        _Self = "core::cell::RefCell<T>",
        note = "if you want to do aliasing and mutation between multiple threads, use `std::sync::RwLock` instead",
    ),
    message = "`{Self}` cannot be shared between threads safely",
    label = "`{Self}` cannot be shared between threads safely"
)]
pub unsafe auto trait Sync {
    // FIXME(estebank): once support to add notes in `rustc_on_unimplemented`
    // lands in beta, and it has been extended to check whether a closure is
    // anywhere in the requirement chain, extend it as such (#48534):
    // ```
    // on(
    //     closure,
    //     note="`{Self}` cannot be shared safely, consider marking the closure `move`"
    // ),
    // ```

    // Empty
}

#[stable(feature = "rust1", since = "1.0.0")]
impl<T: ?Sized> !Sync for *const T {}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: ?Sized> !Sync for *mut T {}

/// Zero-sized type used to mark things that "act like" they own a `T`.
///
/// Adding a `PhantomData<T>` field to your type tells the compiler that your
/// type acts as though it stores a value of type `T`, even though it doesn't
/// really. This information is used when computing certain safety properties.
///
/// For a more in-depth explanation of how to use `PhantomData<T>`, please see
/// [the Nomicon](../../nomicon/phantom-data.html).
///
/// # A ghastly note 👻👻👻
///
/// Though they both have scary names, `PhantomData` and 'phantom types' are
/// related, but not identical. A phantom type parameter is simply a type
/// parameter which is never used. In Rust, this often causes the compiler to
/// complain, and the solution is to add a "dummy" use by way of `PhantomData`.
///
/// # Examples
///
/// ## Unused lifetime parameters
///
/// Perhaps the most common use case for `PhantomData` is a struct that has an
/// unused lifetime parameter, typically as part of some unsafe code. For
/// example, here is a struct `Slice` that has two pointers of type `*const T`,
/// presumably pointing into an array somewhere:
///
/// ```compile_fail,E0392
/// struct Slice<'a, T> {
///     start: *const T,
///     end: *const T,
/// }
/// ```
///
/// The intention is that the underlying data is only valid for the
/// lifetime `'a`, so `Slice` should not outlive `'a`. However, this
/// intent is not expressed in the code, since there are no uses of
/// the lifetime `'a` and hence it is not clear what data it applies
/// to. We can correct this by telling the compiler to act *as if* the
/// `Slice` struct contained a reference `&'a T`:
///
/// ```
/// use std::marker::PhantomData;
///
/// # #[allow(dead_code)]
/// struct Slice<'a, T> {
///     start: *const T,
///     end: *const T,
///     phantom: PhantomData<&'a T>,
/// }
/// ```
///
/// This also in turn infers the lifetime bound `T: 'a`, indicating
/// that any references in `T` are valid over the lifetime `'a`.
///
/// When initializing a `Slice` you simply provide the value
/// `PhantomData` for the field `phantom`:
///
/// ```
/// # #![allow(dead_code)]
/// # use std::marker::PhantomData;
/// # struct Slice<'a, T> {
/// #     start: *const T,
/// #     end: *const T,
/// #     phantom: PhantomData<&'a T>,
/// # }
/// fn borrow_vec<T>(vec: &Vec<T>) -> Slice<'_, T> {
///     let ptr = vec.as_ptr();
///     Slice {
///         start: ptr,
///         end: unsafe { ptr.add(vec.len()) },
///         phantom: PhantomData,
///     }
/// }
/// ```
///
/// ## Unused type parameters
///
/// It sometimes happens that you have unused type parameters which
/// indicate what type of data a struct is "tied" to, even though that
/// data is not actually found in the struct itself. Here is an
/// example where this arises with [FFI]. The foreign interface uses
/// handles of type `*mut ()` to refer to Rust values of different
/// types. We track the Rust type using a phantom type parameter on
/// the struct `ExternalResource` which wraps a handle.
///
/// [FFI]: ../../book/ch19-01-unsafe-rust.html#using-extern-functions-to-call-external-code
///
/// ```
/// # #![allow(dead_code)]
/// # trait ResType { }
/// # struct ParamType;
/// # mod foreign_lib {
/// #     pub fn new(_: usize) -> *mut () { 42 as *mut () }
/// #     pub fn do_stuff(_: *mut (), _: usize) {}
/// # }
/// # fn convert_params(_: ParamType) -> usize { 42 }
/// use std::marker::PhantomData;
/// use std::mem;
///
/// struct ExternalResource<R> {
///    resource_handle: *mut (),
///    resource_type: PhantomData<R>,
/// }
///
/// impl<R: ResType> ExternalResource<R> {
///     fn new() -> Self {
///         let size_of_res = mem::size_of::<R>();
///         Self {
///             resource_handle: foreign_lib::new(size_of_res),
///             resource_type: PhantomData,
///         }
///     }
///
///     fn do_stuff(&self, param: ParamType) {
///         let foreign_params = convert_params(param);
///         foreign_lib::do_stuff(self.resource_handle, foreign_params);
///     }
/// }
/// ```
///
/// ## Ownership and the drop check
///
/// The exact interaction of `PhantomData` with drop check **may change in the future**.
///
/// Currently, adding a field of type `PhantomData<T>` indicates that your type *owns* data of type
/// `T` in very rare circumstances. This in turn has effects on the Rust compiler's [drop check]
/// analysis. For the exact rules, see the [drop check] documentation.
///
/// ## Layout
///
/// For all `T`, the following are guaranteed:
/// * `size_of::<PhantomData<T>>() == 0`
/// * `align_of::<PhantomData<T>>() == 1`
///
/// [drop check]: Drop#drop-check
#[lang = "phantom_data"]
#[stable(feature = "rust1", since = "1.0.0")]
pub struct PhantomData<T: ?Sized>;

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

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

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

#[stable(feature = "rust1", since = "1.0.0")]
impl<T: ?Sized> cmp::PartialOrd for PhantomData<T> {
    fn partial_cmp(&self, _other: &PhantomData<T>) -> Option<cmp::Ordering> {
        Option::Some(cmp::Ordering::Equal)
    }
}

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

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

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

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

#[unstable(feature = "structural_match", issue = "31434")]
impl<T: ?Sized> StructuralPartialEq for PhantomData<T> {}

/// Compiler-internal trait used to indicate the type of enum discriminants.
///
/// This trait is automatically implemented for every type and does not add any
/// guarantees to [`mem::Discriminant`]. It is **undefined behavior** to transmute
/// between `DiscriminantKind::Discriminant` and `mem::Discriminant`.
///
/// [`mem::Discriminant`]: crate::mem::Discriminant
#[unstable(
    feature = "discriminant_kind",
    issue = "none",
    reason = "this trait is unlikely to ever be stabilized, use `mem::discriminant` instead"
)]
#[lang = "discriminant_kind"]
#[cfg_attr(bootstrap, rustc_deny_explicit_impl(implement_via_object = false))]
#[cfg_attr(not(bootstrap), rustc_deny_explicit_impl)]
#[cfg_attr(not(bootstrap), rustc_do_not_implement_via_object)]
pub trait DiscriminantKind {
    /// The type of the discriminant, which must satisfy the trait
    /// bounds required by `mem::Discriminant`.
    #[lang = "discriminant_type"]
    type Discriminant: Clone + Copy + Debug + Eq + PartialEq + Hash + Send + Sync + Unpin;
}

/// Used to determine whether a type contains
/// any `UnsafeCell` internally, but not through an indirection.
/// This affects, for example, whether a `static` of that type is
/// placed in read-only static memory or writable static memory.
/// This can be used to declare that a constant with a generic type
/// will not contain interior mutability, and subsequently allow
/// placing the constant behind references.
///
/// # Safety
///
/// This trait is a core part of the language, it is just expressed as a trait in libcore for
/// convenience. Do *not* implement it for other types.
// FIXME: Eventually this trait should become `#[rustc_deny_explicit_impl]`.
// That requires porting the impls below to native internal impls.
#[lang = "freeze"]
#[unstable(feature = "freeze", issue = "121675")]
pub unsafe auto trait Freeze {}

#[unstable(feature = "freeze", issue = "121675")]
impl<T: ?Sized> !Freeze for UnsafeCell<T> {}
marker_impls! {
    #[unstable(feature = "freeze", issue = "121675")]
    unsafe Freeze for
        {T: ?Sized} PhantomData<T>,
        {T: ?Sized} *const T,
        {T: ?Sized} *mut T,
        {T: ?Sized} &T,
        {T: ?Sized} &mut T,
}

/// Types that do not require any pinning guarantees.
///
/// For information on what "pinning" is, see the [`pin` module] documentation.
///
/// Implementing the `Unpin` trait for `T` expresses the fact that `T` is pinning-agnostic:
/// it shall not expose nor rely on any pinning guarantees. This, in turn, means that a
/// `Pin`-wrapped pointer to such a type can feature a *fully unrestricted* API.
/// In other words, if `T: Unpin`, a value of type `T` will *not* be bound by the invariants
/// which pinning otherwise offers, even when "pinned" by a [`Pin<Ptr>`] pointing at it.
/// When a value of type `T` is pointed at by a [`Pin<Ptr>`], [`Pin`] will not restrict access
/// to the pointee value like it normally would, thus allowing the user to do anything that they
/// normally could with a non-[`Pin`]-wrapped `Ptr` to that value.
///
/// The idea of this trait is to alleviate the reduced ergonomics of APIs that require the use
/// of [`Pin`] for soundness for some types, but which also want to be used by other types that
/// don't care about pinning. The prime example of such an API is [`Future::poll`]. There are many
/// [`Future`] types that don't care about pinning. These futures can implement `Unpin` and
/// therefore get around the pinning related restrictions in the API, while still allowing the
/// subset of [`Future`]s which *do* require pinning to be implemented soundly.
///
/// For more discussion on the consequences of [`Unpin`] within the wider scope of the pinning
/// system, see the [section about `Unpin`] in the [`pin` module].
///
/// `Unpin` has no consequence at all for non-pinned data. In particular, [`mem::replace`] happily
/// moves `!Unpin` data, which would be immovable when pinned ([`mem::replace`] works for any
/// `&mut T`, not just when `T: Unpin`).
///
/// *However*, you cannot use [`mem::replace`] on `!Unpin` data which is *pinned* by being wrapped
/// inside a [`Pin<Ptr>`] pointing at it. This is because you cannot (safely) use a
/// [`Pin<Ptr>`] to get a `&mut T` to its pointee value, which you would need to call
/// [`mem::replace`], and *that* is what makes this system work.
///
/// So this, for example, can only be done on types implementing `Unpin`:
///
/// ```rust
/// # #![allow(unused_must_use)]
/// use std::mem;
/// use std::pin::Pin;
///
/// let mut string = "this".to_string();
/// let mut pinned_string = Pin::new(&mut string);
///
/// // We need a mutable reference to call `mem::replace`.
/// // We can obtain such a reference by (implicitly) invoking `Pin::deref_mut`,
/// // but that is only possible because `String` implements `Unpin`.
/// mem::replace(&mut *pinned_string, "other".to_string());
/// ```
///
/// This trait is automatically implemented for almost every type. The compiler is free
/// to take the conservative stance of marking types as [`Unpin`] so long as all of the types that
/// compose its fields are also [`Unpin`]. This is because if a type implements [`Unpin`], then it
/// is unsound for that type's implementation to rely on pinning-related guarantees for soundness,
/// *even* when viewed through a "pinning" pointer! It is the responsibility of the implementor of
/// a type that relies upon pinning for soundness to ensure that type is *not* marked as [`Unpin`]
/// by adding [`PhantomPinned`] field. For more details, see the [`pin` module] docs.
///
/// [`mem::replace`]: crate::mem::replace "mem replace"
/// [`Future`]: crate::future::Future "Future"
/// [`Future::poll`]: crate::future::Future::poll "Future poll"
/// [`Pin`]: crate::pin::Pin "Pin"
/// [`Pin<Ptr>`]: crate::pin::Pin "Pin"
/// [`pin` module]: crate::pin "pin module"
/// [section about `Unpin`]: crate::pin#unpin "pin module docs about unpin"
/// [`unsafe`]: ../../std/keyword.unsafe.html "keyword unsafe"
#[stable(feature = "pin", since = "1.33.0")]
#[diagnostic::on_unimplemented(
    note = "consider using the `pin!` macro\nconsider using `Box::pin` if you need to access the pinned value outside of the current scope",
    message = "`{Self}` cannot be unpinned"
)]
#[lang = "unpin"]
pub auto trait Unpin {}

/// A marker type which does not implement `Unpin`.
///
/// If a type contains a `PhantomPinned`, it will not implement `Unpin` by default.
#[stable(feature = "pin", since = "1.33.0")]
#[derive(Debug, Default, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct PhantomPinned;

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

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

marker_impls! {
    #[stable(feature = "pin_raw", since = "1.38.0")]
    Unpin for
        {T: ?Sized} *const T,
        {T: ?Sized} *mut T,
}

/// A marker for types that can be dropped.
///
/// This should be used for `~const` bounds,
/// as non-const bounds will always hold for every type.
#[unstable(feature = "const_destruct", issue = "133214")]
#[lang = "destruct"]
#[rustc_on_unimplemented(message = "can't drop `{Self}`", append_const_msg)]
#[cfg_attr(bootstrap, rustc_deny_explicit_impl(implement_via_object = false))]
#[cfg_attr(not(bootstrap), rustc_deny_explicit_impl)]
#[cfg_attr(not(bootstrap), rustc_do_not_implement_via_object)]
#[cfg_attr(not(bootstrap), const_trait)]
pub trait Destruct {}

/// A marker for tuple types.
///
/// The implementation of this trait is built-in and cannot be implemented
/// for any user type.
#[unstable(feature = "tuple_trait", issue = "none")]
#[lang = "tuple_trait"]
#[diagnostic::on_unimplemented(message = "`{Self}` is not a tuple")]
#[cfg_attr(bootstrap, rustc_deny_explicit_impl(implement_via_object = false))]
#[cfg_attr(not(bootstrap), rustc_deny_explicit_impl)]
#[cfg_attr(not(bootstrap), rustc_do_not_implement_via_object)]
pub trait Tuple {}

/// A marker for pointer-like types.
///
/// This trait can only be implemented for types that are certain to have
/// the same size and alignment as a [`usize`] or [`*const ()`](pointer).
/// To ensure this, there are special requirements on implementations
/// of `PointerLike` (other than the already-provided implementations
/// for built-in types):
///
/// * The type must have `#[repr(transparent)]`.
/// * The type’s sole non-zero-sized field must itself implement `PointerLike`.
#[unstable(feature = "pointer_like_trait", issue = "none")]
#[lang = "pointer_like"]
#[diagnostic::on_unimplemented(
    message = "`{Self}` needs to have the same ABI as a pointer",
    label = "`{Self}` needs to be a pointer-like type"
)]
#[cfg_attr(not(bootstrap), rustc_do_not_implement_via_object)]
pub trait PointerLike {}

#[cfg(not(bootstrap))]
marker_impls! {
    #[unstable(feature = "pointer_like_trait", issue = "none")]
    PointerLike for
        isize,
        usize,
        {T} &T,
        {T} &mut T,
        {T} *const T,
        {T} *mut T,
        {T: PointerLike} crate::pin::Pin<T>,
}

/// A marker for types which can be used as types of `const` generic parameters.
///
/// These types must have a proper equivalence relation (`Eq`) and it must be automatically
/// derived (`StructuralPartialEq`). There's a hard-coded check in the compiler ensuring
/// that all fields are also `ConstParamTy`, which implies that recursively, all fields
/// are `StructuralPartialEq`.
#[lang = "const_param_ty"]
#[unstable(feature = "unsized_const_params", issue = "95174")]
#[diagnostic::on_unimplemented(message = "`{Self}` can't be used as a const parameter type")]
#[allow(multiple_supertrait_upcastable)]
// We name this differently than the derive macro so that the `adt_const_params` can
// be used independently of `unsized_const_params` without requiring a full path
// to the derive macro every time it is used. This should be renamed on stabilization.
pub trait ConstParamTy_: UnsizedConstParamTy + StructuralPartialEq + Eq {}

/// Derive macro generating an impl of the trait `ConstParamTy`.
#[rustc_builtin_macro]
#[allow_internal_unstable(unsized_const_params)]
#[unstable(feature = "adt_const_params", issue = "95174")]
pub macro ConstParamTy($item:item) {
    /* compiler built-in */
}

#[lang = "unsized_const_param_ty"]
#[unstable(feature = "unsized_const_params", issue = "95174")]
#[diagnostic::on_unimplemented(message = "`{Self}` can't be used as a const parameter type")]
/// A marker for types which can be used as types of `const` generic parameters.
///
/// Equivalent to [`ConstParamTy_`] except that this is used by
/// the `unsized_const_params` to allow for fake unstable impls.
pub trait UnsizedConstParamTy: StructuralPartialEq + Eq {}

/// Derive macro generating an impl of the trait `ConstParamTy`.
#[rustc_builtin_macro]
#[allow_internal_unstable(unsized_const_params)]
#[unstable(feature = "unsized_const_params", issue = "95174")]
pub macro UnsizedConstParamTy($item:item) {
    /* compiler built-in */
}

// FIXME(adt_const_params): handle `ty::FnDef`/`ty::Closure`
marker_impls! {
    #[unstable(feature = "adt_const_params", issue = "95174")]
    ConstParamTy_ for
        usize, u8, u16, u32, u64, u128,
        isize, i8, i16, i32, i64, i128,
        bool,
        char,
        (),
        {T: ConstParamTy_, const N: usize} [T; N],
}

marker_impls! {
    #[unstable(feature = "unsized_const_params", issue = "95174")]
    UnsizedConstParamTy for
        usize, u8, u16, u32, u64, u128,
        isize, i8, i16, i32, i64, i128,
        bool,
        char,
        (),
        {T: UnsizedConstParamTy, const N: usize} [T; N],

        str,
        {T: UnsizedConstParamTy} [T],
        {T: UnsizedConstParamTy + ?Sized} &T,
}

/// A common trait implemented by all function pointers.
#[unstable(
    feature = "fn_ptr_trait",
    issue = "none",
    reason = "internal trait for implementing various traits for all function pointers"
)]
#[lang = "fn_ptr_trait"]
#[cfg_attr(bootstrap, rustc_deny_explicit_impl(implement_via_object = false))]
#[cfg_attr(not(bootstrap), rustc_deny_explicit_impl)]
#[cfg_attr(not(bootstrap), rustc_do_not_implement_via_object)]
pub trait FnPtr: Copy + Clone {
    /// Returns the address of the function pointer.
    #[lang = "fn_ptr_addr"]
    fn addr(self) -> *const ();
}

/// Derive macro generating impls of traits related to smart pointers.
#[rustc_builtin_macro(CoercePointee, attributes(pointee))]
#[allow_internal_unstable(dispatch_from_dyn, coerce_unsized, unsize)]
#[unstable(feature = "derive_coerce_pointee", issue = "123430")]
#[cfg(not(bootstrap))]
pub macro CoercePointee($item:item) {
    /* compiler built-in */
}


```


In GNU Emacs 31.0.50 (build 1, x86_64-pc-linux-gnu, GTK+ Version
 3.24.43, cairo version 1.18.2) of 2025-04-17 built on Mufasa
Repository revision: 7b35a5062231ec5a11c7a87d4797cfb5dba25121
Repository branch: feature/igc
System Description: NixOS 24.11 (Vicuna)

Configured using:
 'configure 'CFLAGS=-O3 -march=native'
 --prefix=/home/exec/Projects/git.savannah.gnu.org/git/emacs-build/feature_igc-7b35a5062231ec5a11c7a87d4797cfb5dba25121-O3
 --with-mps=yes --with-imagemagick --with-modules --with-pgtk
 --with-cairo --with-cairo-xcb --without-compress-install
 --with-mailutils --with-tree-sitter --with-xinput2
 --enable-link-time-optimization --with-file-notification=inotify'

Configured features:
ACL CAIRO DBUS FREETYPE GIF GLIB GMP GNUTLS GSETTINGS HARFBUZZ
IMAGEMAGICK JPEG LCMS2 LIBOTF LIBXML2 MODULES MPS NATIVE_COMP NOTIFY
INOTIFY PDUMPER PGTK PNG RSVG SECCOMP SOUND SQLITE3 THREADS TIFF
TOOLKIT_SCROLL_BARS TREE_SITTER WEBP XIM GTK3 ZLIB

Important settings:
  value of $LC_COLLATE: C
  value of $LC_MONETARY: en_US.UTF-8
  value of $LC_NUMERIC: en_US.UTF-8
  value of $LC_TIME: C
  value of $LANG: en_US.UTF-8
  value of $XMODIFIERS: @im=fcitx
  locale-coding-system: utf-8-unix

Major mode: Elisp/l

Minor modes in effect:
  restore-point-mode: t
  global-atomic-chrome-edit-mode: t
  global-git-gutter-mode: t
  git-gutter-mode: t
  marginalia-mode: t
  elisp-def-mode: t
  flycheck-posframe-mode: t
  hungry-delete-mode: t
  symbol-overlay-mode: t
  keycast-tab-bar-mode: t
  vertico-truncate-mode: t
  vertico-multiform-mode: t
  vertico-mode: t
  telega-root-auto-fill-mode: t
  telega-contact-birthdays-mode: t
  telega-active-video-chats-mode: t
  telega-active-locations-mode: t
  telega-patrons-mode: t
  telega-active-stories-mode: t
  tab-line-nerd-icons-global-mode: t
  global-tab-line-mode: t
  tab-line-mode: t
  ultra-scroll-mode: t
  pixel-scroll-precision-mode: t
  org-roam-db-autosync-mode: t
  global-org-modern-mode: t
  mu4e-modeline-mode: t
  global-kkp-mode: t
  global-git-commit-mode: t
  flycheck-mode: t
  engine-mode: t
  symex-mode: t
  global-evil-surround-mode: t
  evil-surround-mode: t
  yas-global-mode: t
  yas-minor-mode: t
  corfu-terminal-mode: t
  corfu-history-mode: t
  global-corfu-mode: t
  corfu-mode: t
  rainbow-mode: t
  elisp-autofmt-mode: t
  highlight-defined-mode: t
  highlight-numbers-mode: t
  hes-mode: t
  rainbow-delimiters-mode: t
  burly-tabs-mode: t
  global-form-feed-st-mode: t
  form-feed-st-mode: t
  eat-eshell-mode: t
  sly-symbol-completion-mode: t
  super-save-mode: t
  savehist-mode: t
  which-key-mode: t
  super-hint-xref-mode: t
  super-hint-rg-mode: t
  windmove-mode: t
  server-mode: t
  save-place-mode: t
  recentf-mode: t
  winner-mode: t
  persistent-scratch-autosave-mode: t
  global-dash-fontify-mode: t
  dash-fontify-mode: t
  nerd-icons-completion-mode: t
  sudo-edit-indicator-mode: t
  global-evil-visualstar-mode: t
  evil-visualstar-mode: t
  evil-commentary-mode: t
  global-evil-mc-mode: t
  evil-mc-mode: t
  evil-lion-mode: t
  global-evil-collection-unimpaired-mode: t
  evil-collection-unimpaired-mode: t
  buffer-face-mode: t
  TeX-PDF-mode: t
  display-line-numbers-mode: t
  electric-pair-mode: t
  global-auto-revert-mode: t
  evil-mode: t
  evil-local-mode: t
  general-override-mode: t
  minions-mode: t
  el-patch-use-package-mode: t
  elpaca-use-package-mode: t
  override-global-mode: t
  tooltip-mode: t
  global-eldoc-mode: t
  eldoc-mode: t
  show-paren-mode: t
  electric-indent-mode: t
  mouse-wheel-mode: t
  tab-bar-mode: t
  file-name-shadow-mode: t
  context-menu-mode: t
  global-font-lock-mode: t
  font-lock-mode: t
  minibuffer-regexp-mode: t
  column-number-mode: -1
  line-number-mode: -1
  transient-mark-mode: t
  auto-composition-mode: t
  auto-encryption-mode: t
  auto-compression-mode: t

Load-path shadows:
/home/exec/.emacs.d/elpaca/builds/modus-themes/theme-loaddefs hides /home/exec/.emacs.d/elpaca/builds/standard-themes/theme-loaddefs
/home/exec/.emacs.d/elpaca/builds/modus-themes/theme-loaddefs hides /home/exec/.emacs.d/elpaca/builds/ef-themes/theme-loaddefs
/home/exec/.emacs.d/elpaca/builds/modus-themes/theme-loaddefs hides /home/exec/Projects/git.savannah.gnu.org/git/emacs-build/feature_igc-7b35a5062231ec5a11c7a87d4797cfb5dba25121-O3/share/emacs/31.0.50/lisp/theme-loaddefs
/home/exec/.emacs.d/elpaca/builds/transient/transient hides /home/exec/Projects/git.savannah.gnu.org/git/emacs-build/feature_igc-7b35a5062231ec5a11c7a87d4797cfb5dba25121-O3/share/emacs/31.0.50/lisp/transient

Features:
(shadow sort mail-extr expand-region yaml-mode-expansions
subword-mode-expansions text-mode-expansions cc-mode-expansions
the-org-mode-expansions python-el-fgallina-expansions
latex-mode-expansions js2-mode-expansions js-mode-expansions
web-mode-expansions html-mode-expansions clojure-mode-expansions
er-basic-expansions expand-region-core expand-region-custom
evil-collection-embark embark-org embark-consult embark gptel-curl
nerd-icons-dired diredfl info-colors vertico-sort cus-start descr-text
dabbrev cape lsp-diagnostics lsp-modeline lsp-icons lsp-zig lsp-yang
lsp-yaml lsp-xml lsp-wgsl lsp-volar lsp-vimscript lsp-vhdl lsp-vetur
lsp-html lsp-verilog lsp-vala lsp-v lsp-typespec lsp-typeprof lsp-ttcn3
lsp-ts-query lsp-trunk lsp-toml lsp-tilt lsp-tex lsp-terraform
lsp-svelte lsp-steep lsp-sqls lsp-sql lsp-sorbet lsp-solidity
lsp-solargraph lsp-semgrep lsp-ruff lsp-ruby-syntax-tree lsp-ruby-lsp
lsp-rubocop lsp-roslyn lsp-roc lsp-rf lsp-remark lsp-racket lsp-r
lsp-qml lsp-pyright lsp-pylsp lsp-pyls lsp-pwsh lsp-purescript lsp-pls
lsp-php lsp-perlnavigator lsp-perl lsp-openscad lsp-ocaml lsp-nushell
lsp-nix lsp-nim lsp-nginx lsp-nextflow lsp-move lsp-mojo lsp-mint
lsp-meson lsp-mdx lsp-matlab lsp-marksman lsp-markdown lsp-magik
lsp-fennel lsp-lua lsp-lisp lsp-kubernetes-helm lsp-kotlin lsp-json
lsp-jq lsp-javascript lsp-idris lsp-haxe lsp-hack lsp-groovy lsp-graphql
lsp-golangci-lint lsp-glsl lsp-gleam lsp-gdscript lsp-fsharp lsp-futhark
lsp-fortran lsp-eslint lsp-erlang lsp-emmet lsp-elm lsp-elixir
lsp-earthly lsp-dockerfile lsp-dhall lsp-d lsp-cypher lsp-cucumber
lsp-copilot lsp-css lsp-c3 lsp-csharp lsp-crystal lsp-credo lsp-cobol
lsp-cmake lsp-clojure lsp-clangd lsp-bufls lsp-go lsp-completion
lsp-beancount lsp-bash lsp-awk lsp-autotools lsp-astro lsp-asm
lsp-ansible lsp-angular lsp-ada lsp-actionscript copilot
copilot-balancer editorconfig editorconfig-core editorconfig-core-handle
editorconfig-fnmatch jsonrpc gptel-openai-extras gptel-anthropic
gptel-gemini gptel-ollama org-indent gptel-openai consult-dir-autoloads
consult-ag-autoloads restore-point evil-collection-atomic-chrome
atomic-chrome git-gutter marginalia elisp-def evil-collection-ert ert
flycheck-posframe evil-collection-hungry-delete hungry-delete
symbol-overlay keycast zig-mode reformatter empv vertico-truncate
vertico-posframe vertico-multiform evil-collection-vertico vertico
lsp-uniteai nix-ts-mode go-translate gt-text-utility gt-engine-echo
gt-engine-libre gt-engine-chatgpt gt-engine-youdao gt-engine-osxdict
gt-engine-stardict gt-engine-deepl gt-engine-google-rpc gt-engine-google
gt-engine-bing gt-extension gt-faces gt-core gt-httpx sdcv cap-words
superword subword evil-collection-telega telega-obsolete telega
telega-tdlib-events telega-match telega-root telega-info telega-chat
telega-modes telega-company telega-emoji telega-user
telega-notifications telega-voip telega-msg telega-story telega-webpage
telega-tme telega-sticker telega-vvnote telega-ffplay telega-i18n
telega-sort telega-filter telega-ins telega-inline telega-util
telega-folders telega-topic telega-media telega-tdlib telega-server
telega-core telega-customize emacsbug tab-line-nerd-icons
evil-collection-imenu-list imenu-list tab-line rust-utils
rust-mode-treesitter rust-ts-mode rust-mode rust-playpen rust-cargo
rust-common rust-rustfmt rust-compile cargo cargo-process rg-info-hack
rg-menu rg-ibuffer ibuf-macs rg-result wgrep-rg rg-history ibuf-ext
evil-collection-ibuffer ibuffer ibuffer-loaddefs rg-header
evil-collection-ultra-scroll ultra-scroll pixel-scroll cua-base
org-sliced-images emacsql-sqlite-builtin evil-collection-org-roam
org-roam-migrate org-roam-log org-roam-mode org-roam-capture org-roam-id
org-roam-node org-roam-db org-roam-utils org-roam-compat org-roam
org-capture emacsql-sqlite emacsql emacsql-compiler org-journal
org-crypt cal-iso org-modern orderless evil-collection-mu4e mu4e
mu4e-org mu4e-notification mu4e-main smtpmail mu4e-view mu4e-mime-parts
mu4e-headers mu4e-thread mu4e-actions mu4e-compose mu4e-draft gnus-msg
gnus-art mm-uu mml2015 mu4e-search mu4e-lists mu4e-bookmarks mu4e-mark
mu4e-message flow-fill mu4e-contacts mu4e-update mu4e-folders
mu4e-context mu4e-query-items mu4e-server mu4e-modeline mu4e-vars
mu4e-helpers mu4e-config mu4e-window ido mu4e-obsolete cyphejor qml-mode
kkp rfc-mode string-inflection wakatime-mode systemd minuet pr-review
pr-review-render pr-review-action magit-diff git-commit
evil-collection-log-edit log-edit pcvs-util add-log magit-core
magit-autorevert magit-margin magit-transient magit-process
evil-collection-with-editor with-editor magit-mode magit-git magit-base
pr-review-input pr-review-api ghub-graphql treepy gsexp ghub
pr-review-common consult-lsp lsp-ui lsp-ui-flycheck lsp-ui-doc
evil-collection-lsp-ui-imenu lsp-ui-imenu lsp-ui-peek lsp-ui-sideline
lsp-rust lsp-semantic-tokens lsp-mode network-stream
evil-collection-markdown-mode markdown-mode lsp-ui-util lsp-protocol
llm-prompt groovy-mode iedit help-macro iedit-lib hide-comnt
minibuffer-header gptel-quick gotest fzf flycheck-clj-kondo jka-compr
pos-tip consult-flycheck flycheck-rust engine-mode evil-collection-ement
ement-room-list taxy-magit-section taxy ement ement-notifications
ement-notify ement-room ewoc ement-lib ement-api ement-structs
ement-macros dns llm-ollama llm-provider-utils llm-models
llm-request-plz plz-event-source plz-media-type plz llm symex symex-evil
symex-evil-support symex-hydra symex-transformations
symex-transformations-lisp symex-utils evil-cleverparens
evil-cleverparens-text-objects evil-cleverparens-util smartparens
evil-surround symex-misc symex-interface-builtins symex-interface-fennel
symex-interface-arc symex-interface-common-lisp symex-interface-clojure
symex-interface-scheme symex-interface-racket symex-interface-elisp
symex-interop symex-interface symex-traversals symex-dsl symex-evaluator
symex-computations symex-primitives symex-ts symex-utils-ts
symex-transformations-ts symex-primitives-lisp symex-data symex-ui
symex-custom evil-collection-lispy lispy le-clojure delsel lispy-inline
avy lispy-tags zoutline combobulate evil-collection-elfeed elfeed-show
elfeed-search elfeed-csv elfeed elfeed-curl elfeed-log elfeed-db
elfeed-lib xml-query dired-git-info dired-hacks dired-preview
evil-collection-cmake-mode cmake-mode consult-yasnippet yasnippet-capf
yasnippet-snippets yasnippet kind-icon svg-lib corfu-terminal popon
corfu-popupinfo corfu-indexed corfu-history evil-collection-corfu corfu
consult-ls-git paredit clojure-ts-mode evil-collection-cider cider
tramp-sh cider-debug cider-browse-ns cider-mode cider-xref-backend
cider-find cider-inspector cider-completion cider-profile cider-eval
cider-jar cider-repl-history cider-repl cider-resolve cider-test
cider-overlays cider-stacktrace cider-doc cider-browse-spec
cider-clojuredocs cider-eldoc cider-docstring cider-client cider-common
cider-completion-context cider-connection cider-popup sesman-browser
nrepl-client cider-util sesman queue nrepl-dict spinner clojure-mode
rainbow-mode elisp-autofmt loadhist highlight-defined highlight-numbers
parent-mode highlight-escape-sequences rainbow-delimiters chatgpt-shell
chatgpt-shell-prompt-compose chatgpt-shell-perplexity
chatgpt-shell-openrouter chatgpt-shell-openai chatgpt-shell-ollama
chatgpt-shell-kagi chatgpt-shell-google chatgpt-shell-deepseek
chatgpt-shell-anthropic evil-collection-smerge-mode smerge-mode diff
shell-maker ielm evil-collection-eshell eshell em-prompt esh-mode
esh-var esh-cmd esh-ext esh-proc esh-opt esh-io esh-arg esh-module
esh-module-loaddefs esh-util cargo-jump-xref toml breadcrumb pulse
bookmark-in-project bookmark+ bookmark+-key bookmark+-1 gnus-sum
gnus-group gnus-undo gnus-start gnus-dbus gnus-cloud nnimap nnmail
mail-source utf7 nnoo gnus-spec gnus-int gnus-range gnus-win
bookmark+-bmu bookmark+-lit bookmark+-mac babashka parseedn
parseclj-parser parseclj-lex parseclj-alist cnfonts burly-tabs burly
compile-multi form-feed-st google-this echo-bar fcitx
evil-collection-eat eat term/xterm xterm evil-collection-term term ehelp
ox-reveal ox-odt rng-loc rng-uri rng-parse rng-match rng-dt rng-util
rng-pttrn nxml-parse nxml-ns nxml-enc xmltok nxml-util ox-latex
ox-icalendar org-agenda ox-html table ox-ascii ox-publish ox org-attach
org-element org-persist org-id org-refile org-element-ast inline
avl-tree htmlize evil-collection-explain-pause-mode explain-pause-mode
explain-pause-top explain-pause-log-to-socket evil-collection-profiler
profiler weather-metno solar cal-dst url-cache display-wttr kdeconnect
crux pest-mode popwin modus-themes blackboard-theme standard-themes
nimbus-theme tok-theme danneskjold-theme srcery-theme subatomic256-theme
iscroll xml+ evil-textobj-tree-sitter
evil-textobj-tree-sitter-thing-at-point evil-textobj-tree-sitter-core
tree-sitter tree-sitter-load tree-sitter-cli tsc tsc-dyn tsc-dyn-get
dired-aux tsc-obsolete ctable evil-collection-color-rg color-rg
line-reminder ov ht fringe-helper solarized-theme solarized
solarized-faces sqlup-mode evil-collection-bm bm zen-mode
evil-collection-sly sly gud sly-completion sly-buttons sly-messages
sly-common evil-collection-apropos apropos evil-collection-arc-mode
arc-mode archive-mode hyperspec sicp base16-theme idea-darkula-theme
hybrid-reverse-theme material-theme doom-themes doom-themes-base
nyan-mode organic-green-theme inkpot-theme github-dark-vscode-theme
almost-mono-themes cyberpunk-theme soothe-theme soothe-tva zenburn-theme
mindre-theme kaolin-themes kaolin-themes-lib tron-legacy-theme
wildcharm-theme atom-one-dark-theme parchment-theme autothemer
visual-fill-column transpose-frame gameoflife evil-collection-docker
docker docker-context docker-volume docker-network docker-image
docker-container docker-faces docker-core docker-compose docker-process
docker-utils docker-group aio dockerfile-mode emacs-everywhere cus-dir
dumb-jump evil-collection-popup popup websocket bindat bing-dict cl
bing-dict-cache hl-todo atom-dark-theme ef-themes uwu-theme vagrant
evil-collection-ag ag vc-svn find-dired alarm-clock alert log4e
notifications gntp pinentry evil-collection-hackernews hackernews
evil-collection-notmuch notmuch notmuch-tree notmuch-jump notmuch-hello
notmuch-show notmuch-print notmuch-crypto notmuch-mua notmuch-message
notmuch-draft notmuch-maildir-fcc notmuch-address notmuch-company
notmuch-parser notmuch-wash coolj goto-addr icalendar diary-lib
diary-loaddefs notmuch-tag notmuch-lib notmuch-compat message sendmail
yank-media rfc822 mml mailabbrev gmm-utils mm-view mml-smime mml-sec
smime gnutls dig mm-decode mm-bodies mm-encode fussy flx affe
evil-collection-consult consult clang-format apheleia apheleia-rcs
apheleia-dp apheleia-formatters apheleia-utils apheleia-log
apheleia-formatter-context vimrc-mode gnuplot olivetti super-save
evil-collection-helpful helpful cc-langs trace cl-print
evil-collection-edebug edebug evil-collection-debug debug backtrace
info-look evil-collection-info info help-fns radix-tree
evil-collection-elisp-refs elisp-refs solidity-mode solidity-common
evil-collection-git-timemachine git-timemachine web-mode disp-table
evil-collection-go-mode go-mode find-file evil-collection-js2-mode
js2-mode etags fileloop zig-mode-autoloads reformatter-autoloads
empv-autoloads yasnippet-snippets-autoloads marginalia-autoloads
vertico-truncate-autoloads vertico-posframe-autoloads vertico-autoloads
lsp-uniteai-autoloads nix-ts-mode-autoloads go-translate-autoloads
alert-autoloads gntp-autoloads log4e-autoloads sdcv-autoloads
telega-autoloads tab-line-nerd-icons-autoloads keycast-autoloads
rust-mode-autoloads cargo-autoloads toml-autoloads rg-autoloads
writeroom-mode-autoloads nov-autoloads esxml-autoloads kv-autoloads
makefile-executor-autoloads ultra-scroll-autoloads pdf-tools-autoloads
org-sliced-images-autoloads consult-org-roam-autoloads
org-roam-autoloads org-journal-autoloads org-download-autoloads
org-modern-autoloads orderless-autoloads mu4e-autoloads
cyphejor-autoloads symbol-overlay-autoloads qml-mode-autoloads
kkp-autoloads rfc-mode-autoloads string-inflection-autoloads
wakatime-mode-autoloads webpaste-autoloads systemd-autoloads
minuet-autoloads pr-review-autoloads forge-autoloads closql-autoloads
emacsql-autoloads ghub-autoloads treepy-autoloads yaml-autoloads
lsp-pyright-autoloads consult-lsp-autoloads lsp-ui-autoloads
lsp-mode-autoloads groovy-mode-autoloads imenu-list-autoloads
hungry-delete-autoloads hide-comnt-autoloads minibuffer-header-autoloads
gptel-quick-autoloads gptel-autoloads gotest-autoloads fzf-autoloads
flycheck-golangci-lint-autoloads flycheck-clj-kondo-autoloads
pos-tip-autoloads consult-flycheck-autoloads flycheck-rust-autoloads
flycheck-posframe-autoloads flycheck-autoloads engine-mode-autoloads
ement-autoloads taxy-magit-section-autoloads taxy-autoloads
embark-consult-autoloads embark-autoloads ellama-autoloads llm-autoloads
plz-event-source-autoloads plz-media-type-autoloads plz-autoloads
symex-autoloads tree-sitter-autoloads tsc-autoloads lispy-autoloads
iedit-autoloads swiper-autoloads ivy-autoloads zoutline-autoloads
evil-cleverparens-autoloads smartparens-autoloads combobulate-autoloads
combobulate-go combobulate-json combobulate-yaml combobulate-css
combobulate-js-ts combobulate-python combobulate-html combobulate-toml
combobulate-cursor multiple-cursors mc-separate-operations
rectangular-region-mode mc-mark-pop mc-edit-lines
mc-hide-unmatched-lines-mode mc-mark-more sgml-mode mc-cycle-cursors
multiple-cursors-core combobulate-query savehist evil-collection-scheme
scheme combobulate-ui combobulate-display let-alist combobulate-ztree
combobulate-envelope combobulate-manipulation evil-collection-python
python combobulate-procedure combobulate-navigation combobulate-misc
combobulate-setup tempo combobulate-interface combobulate-settings
combobulate-rules elisp-def-autoloads elfeed-tube-mpv-autoloads
elfeed-tube-autoloads elfeed-autoloads eee-autoloads eee
dired-git-info-autoloads dired-hacks-autoloads dired-preview-autoloads
diredfl-autoloads git-gutter-autoloads cmake-mode-autoloads
consult-yasnippet-autoloads yasnippet-capf-autoloads yasnippet-autoloads
cape-autoloads kind-icon-autoloads svg-lib-autoloads
corfu-terminal-autoloads popon-autoloads corfu-autoloads
copilot-autoloads copilot-chat-autoloads consult-ls-git-autoloads
paredit-autoloads clojure-ts-mode-autoloads cider-autoloads
clojure-mode-autoloads queue-autoloads spinner-autoloads
sesman-autoloads chatgpt-shell-autoloads shell-maker-autoloads
cargo-jump-xref-autoloads breadcrumb-autoloads
bookmark-in-project-autoloads bookmark+-autoloads babashka-autoloads
parseedn-autoloads parseclj-autoloads aidermacs-autoloads
mediawiki-autoloads markdown-mode-autoloads treemacs-magit-autoloads
magit-autoloads with-editor-autoloads nerd-icons-ibuffer-autoloads
treemacs-nerd-icons-autoloads treemacs-autoloads pfuture-autoloads
cfrs-autoloads cnfonts-autoloads burly-autoloads compile-multi-autoloads
form-feed-st-autoloads google-this-autoloads echo-bar-autoloads
zoom-autoloads fcitx-autoloads eat-autoloads vterm-autoloads
chatgpt-autoloads polymode-autoloads ox-reveal-autoloads
htmlize-autoloads wordreference-autoloads explain-pause-mode-autoloads
weather-metno-autoloads display-wttr-autoloads kdeconnect-autoloads
emms-autoloads crux-autoloads pest-mode-autoloads popwin-autoloads
modus-themes-autoloads blackboard-theme-autoloads
standard-themes-autoloads nimbus-theme-autoloads tok-theme-autoloads
danneskjold-theme-autoloads srcery-theme-autoloads
subatomic256-theme-autoloads iscroll-autoloads xml+-autoloads
multiple-cursors-autoloads evil-textobj-tree-sitter-autoloads
evil-numbers-autoloads ctable-autoloads color-rg-autoloads
line-reminder-autoloads fringe-helper-autoloads ov-autoloads
solarized-theme-autoloads sqlup-mode-autoloads bm-autoloads
zen-mode-autoloads sly-autoloads expand-region-autoloads
highlight-defined-autoloads base16-theme-autoloads
idea-darkula-theme-autoloads hybrid-reverse-theme-autoloads
material-theme-autoloads doom-themes-autoloads nyan-mode-autoloads
organic-green-theme-autoloads inkpot-theme-autoloads
github-dark-vscode-theme-autoloads almost-mono-themes-autoloads
cyberpunk-theme-autoloads soothe-theme-autoloads zenburn-theme-autoloads
mindre-theme-autoloads kaolin-themes-autoloads
tron-legacy-theme-autoloads wildcharm-theme-autoloads
atom-one-dark-theme-autoloads parchment-theme-autoloads
autothemer-autoloads visual-fill-column-autoloads
transpose-frame-autoloads gameoflife-autoloads docker-autoloads
aio-autoloads dockerfile-mode-autoloads emacs-everywhere-autoloads
cus-dir-autoloads dumb-jump-autoloads popup-autoloads
bing-dict-autoloads hl-todo-autoloads atom-dark-theme-autoloads
ef-themes-autoloads uwu-theme-autoloads vagrant-autoloads ag-autoloads
alarm-clock-autoloads pinentry-autoloads hackernews-autoloads
notmuch-autoloads fussy-autoloads flx-autoloads affe-autoloads
consult-autoloads clang-format-autoloads apheleia-autoloads
elisp-autofmt-autoloads vimrc-mode-autoloads mpv-autoloads
gnuplot-autoloads mermaid-mode-autoloads atomic-chrome-autoloads
websocket-autoloads restore-point-autoloads ace-window-autoloads
avy-autoloads olivetti-autoloads super-save-autoloads helpful-autoloads
elisp-refs-autoloads solidity-mode-autoloads git-timemachine-autoloads
web-mode-autoloads adoc-mode-autoloads go-mode-autoloads
js2-mode-autoloads rust-playground-autoloads evil-collection-which-key
which-key super-hint-xref super-hint-rg super-hint evil-collection-xref
xref evil-collection-rg rg piper ob-shell ob-gnuplot ob-C
evil-collection-org org ob ob-tangle ob-ref ob-lob ob-table ob-exp
org-macro org-src evil-collection-sh-script sh-script executable
ob-comint org-pcomplete org-list org-footnote org-faces org-entities
ob-emacs-lisp ob-core ob-eval org-cycle org-table ol org-fold
org-fold-core org-keys oc org-loaddefs org-version org-compat org-macs
molecule-mode lsp hyperbole hideshow gptel-manual-complete
evil-collection-gptel gptel windmove evil-collection-flycheck flycheck
erc erc-backend erc-networks erc-common erc-compat erc-loaddefs
evil-collection-ediff ediff ediff-merg ediff-mult ediff-wind ediff-diff
ediff-help ediff-init ediff-util dired-x consult-ripgrep-all desktop
frameset server evil-collection-eww eww vtable mule-util url-queue
mm-url evil-collection-gnus gnus nnheader gnus-util range epa-file
evil-collection-epa epa derived epg rfc6068 epg-config saveplace recentf
tree-widget winner edit-list refine loop list-utils prompts file-info
browse-at-remote f image-roll evil-collection-image image-mode exif
toc-mode rst scratch sql evil-collection-view view persistent-scratch
exercism persist async-await iter2 generator promise url-http url-auth
mail-parse rfc2231 rfc2047 rfc2045 mm-util ietf-drums mail-prsvr url-gw
nsm promise-rejection-tracking promise-finally promise-done
promise-es6-extensions promise-core async request mailheader mail-utils
a indent-bars evil-collection-outline noutline outline mode-line-bell
powerthesaurus jeison dash s evil-collection-ripgrep ripgrep
evil-collection-wgrep wgrep evil-collection-grep grep
evil-collection-vlf vlf vlf-base vlf-tune gptai ctrlf hl-line
nerd-icons-completion nerd-icons nerd-icons-faces nerd-icons-data
nerd-icons-data-mdicon nerd-icons-data-flicon nerd-icons-data-codicon
nerd-icons-data-devicon nerd-icons-data-sucicon nerd-icons-data-wicon
nerd-icons-data-faicon nerd-icons-data-powerline nerd-icons-data-octicon
nerd-icons-data-pomicon nerd-icons-data-ipsicon disable-mouse mingus
libmpdee evil-collection-mpdel mpdel mpdel-browser libmpdel-directory
mpdel-playlist mpdel-tablist mpdel-song mpdel-core navigel
evil-collection-bookmark bookmark evil-collection-tablist tablist
tablist-filter semantic/wisent/comp semantic/wisent
semantic/wisent/wisent semantic/util-modes semantic/util semantic
semantic/tag semantic/lex semantic/fw mode-local find-func cedet
libmpdel tq time-stamp posframe esup esup-child benchmark
ssh-config-mode jq-mode json-mode json-snatcher js c-ts-common treesit
cc-mode cc-fonts cc-guess cc-menus cc-cmds cc-styles cc-align cc-engine
cc-vars cc-defs evil-collection-yaml-mode yaml-mode toml-mode conf-mode
align highlight facemenu nix-mode ffap smie nix-repl nix-shell nix-store
evil-collection-magit-section magit-section cursor-sensor llama nix-log
nix-instantiate nix-shebang nix-format nix sudo-edit tramp trampver
tramp-integration tramp-message tramp-compat shell pcomplete parse-time
iso8601 time-date tramp-loaddefs evil-collection-devdocs devdocs mathjax
evil-terminal-cursor-changer evil-visualstar evil-commentary
evil-commentary-integration evil-collection-evil-mc evil-mc
evil-mc-command-execute evil-mc-command-record evil-mc-cursor-make
evil-mc-region evil-mc-cursor-state evil-mc-undo evil-mc-vars
evil-mc-known-commands evil-mc-common evil-exchange evil-lion evil-args
smartscan timeout ess ess-utils ess-custom evil-collection-unimpaired
evil-collection-vc-git evil-collection-tabulated-list
evil-collection-tab-bar evil-collection-simple evil-collection-replace
evil-collection-process-menu evil-collection-package-menu
evil-collection-minibuffer evil-collection-man evil-collection-kmacro
evil-collection-indent evil-collection-imenu evil-collection-help
evil-collection-flymake evil-collection-elisp-mode evil-collection-eldoc
evil-collection-elpaca evil-collection-dired evil-collection-diff-mode
evil-collection-custom evil-collection-compile evil-collection-comint
evil-collection-calendar evil-collection-buff-menu evil-collection
annalist sqlite3 sqlite3-api treebundel vc-git diff-mode track-changes
files-x git-link dired dired-loaddefs texfrag face-remap shr pixel-fill
kinsoku url-file puny svg dom preview latex latex-flymake flymake
project compile text-property-search comint ansi-osc tex-ispell
tex-style tex dbus xml crm texmathp auctex display-line-numbers
elec-pair lisp-mnt package browse-url xdg url-handlers xterm-color
edit-list-autoloads refine-autoloads list-utils-autoloads loop-autoloads
prompts-autoloads file-info-autoloads hydra-autoloads lv-autoloads
browse-at-remote-autoloads image-roll-autoloads
saveplace-pdf-view-autoloads pdfgrep-autoloads toc-mode-autoloads
scratch-autoloads persistent-scratch-autoloads exercism-autoloads
a-autoloads request-autoloads async-autoloads async-await-autoloads
promise-autoloads iter2-autoloads persist-autoloads
indent-bars-autoloads rainbow-delimiters-autoloads
rainbow-mode-autoloads mode-line-bell-autoloads powerthesaurus-autoloads
hydra lv jeison-autoloads ripgrep-autoloads wgrep-autoloads
vlf-autoloads gptai-autoloads popper-autoloads ctrlf-autoloads
nerd-icons-dired-autoloads nerd-icons-completion-autoloads
nerd-icons-autoloads disable-mouse-autoloads mingus-autoloads
libmpdee-autoloads mpdel-autoloads libmpdel-autoloads navigel-autoloads
tablist-autoloads posframe-autoloads esup-autoloads quickrun-autoloads
ht-autoloads ssh-config-mode-autoloads jq-mode-autoloads
json-mode-autoloads json-snatcher-autoloads yaml-mode-autoloads
toml-mode-autoloads highlight-escape-sequences-autoloads
highlight-autoloads highlight-numbers-autoloads parent-mode-autoloads
nix-mode-autoloads magit-section-autoloads llama-autoloads
sudo-edit-autoloads attrap-autoloads f-autoloads dash-autoloads
s-autoloads devdocs-autoloads mathjax-autoloads
evil-terminal-cursor-changer-autoloads evil-surround-autoloads
evil-visualstar-autoloads evil-commentary-autoloads evil-mc-autoloads
evil-exchange-autoloads evil-lion-autoloads evil-args-autoloads
smartscan-autoloads timeout-autoloads ess-autoloads
info-colors-autoloads evil-collection-autoloads annalist-autoloads
sqlite3-autoloads treebundel-autoloads git-link-autoloads
texfrag-autoloads auctex-autoloads tex-site xterm-color-autoloads ispell
which-func imenu man ansi-color autorevert filenotify cal-menu calendar
cal-loaddefs advice evil evil-integration evil-maps evil-commands reveal
evil-jumps evil-command-window evil-types evil-search evil-ex
evil-macros evil-repeat evil-states evil-core comp comp-cstr warnings
comp-run comp-common rx evil-common thingatpt rect evil-vars ring
undo-fu goto-chg evil-autoloads undo-fu-autoloads goto-chg-autoloads
transient pcase format-spec transient-autoloads general memoize
sanityinc-tomorrow-bright-theme color-theme-sanityinc-tomorrow color
minions compat general-autoloads memoize-autoloads
color-theme-sanityinc-tomorrow-autoloads minions-autoloads
el-patch-autoloads el-patch el-patch-stub edmacro kmacro vc
vc-dispatcher cl-extra help-mode elpaca-use-package use-package
use-package-ensure use-package-delight use-package-diminish
use-package-bind-key bind-key easy-mmode use-package-core
elpaca-use-package-autoloads elpaca-log elpaca-ui elpaca-menu-elpa
elpaca-menu-melpa url url-proxy url-privacy url-expand url-methods
url-history url-cookie generate-lisp-file url-domsuf url-util url-parse
auth-source cl-seq eieio eieio-core cl-macs password-cache json subr-x
map byte-opt gv bytecomp byte-compile url-vars mailcap elpaca-menu-org
elpaca elpaca-process elpaca-autoloads early-init cus-edit pp cus-load
icons wid-edit cl-loaddefs cl-lib rmc iso-transl tooltip cconv eldoc
paren electric uniquify ediff-hook vc-hooks lisp-float-type elisp-mode
mwheel term/pgtk-win pgtk-win term/common-win touch-screen pgtk-dnd
tool-bar dnd fontset image regexp-opt fringe tabulated-list replace
newcomment text-mode lisp-mode prog-mode register page tab-bar menu-bar
rfn-eshadow isearch easymenu timer select scroll-bar mouse jit-lock
font-lock syntax font-core term/tty-colors frame minibuffer nadvice seq
simple cl-generic indonesian philippine cham georgian utf-8-lang
misc-lang vietnamese tibetan thai tai-viet lao korean japanese eucjp-ms
cp51932 hebrew greek romanian slovak czech european ethiopic indian
cyrillic chinese composite emoji-zwj charscript charprop case-table
epa-hook jka-cmpr-hook help abbrev obarray oclosure cl-preloaded button
loaddefs theme-loaddefs faces cus-face macroexp files window
text-properties overlay sha1 md5 base64 format env code-pages mule
custom widget keymap hashtable-print-readable backquote threads dbusbind
inotify dynamic-setting system-font-setting font-render-setting cairo
gtk pgtk lcms2 multi-tty move-toolbar make-network-process
tty-child-frames native-compile mps emacs)

Memory information:
((conses 24 0 0) (symbols 56 0 0) (strings 40 0 0) (string-bytes 1 0)
  (vectors 24 0) (vector-slots 8 0 0) (floats 24 0 0) (intervals 64 0 0)
  (buffers 1000 0))

-- 

Message #8 received at submit <at> debbugs.gnu.org (full text, mbox):

From: Vincenzo Pupillo <v.pupillo <at> gmail.com>
To: 77914 <at> debbugs.gnu.org, bug-gnu-emacs <at> gnu.org
Cc: Eval Exec <execvy <at> gmail.com>
Subject: Re: bug#77914: 31.0.50;
 treesit-font-lock-level set to 4 cause rust-ts-mode lost all color
Date: Sun, 20 Apr 2025 00:12:34 +0200

[Message part 1 (text/plain, inline)]

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

[rust-grammar-bug.png (image/png, attachment)]

Message #14 received at 77914 <at> debbugs.gnu.org (full text, mbox):

From: Juri Linkov <juri <at> linkov.net>
To: Vincenzo Pupillo <v.pupillo <at> gmail.com>
Cc: Eval Exec <execvy <at> gmail.com>, 77914 <at> debbugs.gnu.org
Subject: Re: bug#77914: 31.0.50; treesit-font-lock-level set to 4 cause
 rust-ts-mode lost all color
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

Message #17 received at submit <at> debbugs.gnu.org (full text, mbox):

From: Eval Exec <execvy <at> gmail.com>
To: Vincenzo Pupillo <v.pupillo <at> gmail.com>, 77914 <at> debbugs.gnu.org,
 bug-gnu-emacs <at> gnu.org
Subject: Re: bug#77914: 31.0.50; treesit-font-lock-level set to 4 cause
 rust-ts-mode lost all color
Date: Sun, 20 Apr 2025 15:19:20 +0800

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

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

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

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


Can you reproduce this?

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

Message #23 received at 77914 <at> debbugs.gnu.org (full text, mbox):

From: Eli Zaretskii <eliz <at> gnu.org>
To: Juri Linkov <juri <at> linkov.net>
Cc: execvy <at> gmail.com, v.pupillo <at> gmail.com, 77914 <at> debbugs.gnu.org
Subject: Re: bug#77914: 31.0.50;
 treesit-font-lock-level set to 4 cause rust-ts-mode lost all color
Date: Sun, 20 Apr 2025 11:17:44 +0300

> Cc: Eval Exec <execvy <at> gmail.com>, 77914 <at> debbugs.gnu.org
> From: Juri Linkov <juri <at> linkov.net>
> 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 #26 received at 77914 <at> debbugs.gnu.org (full text, mbox):

From: Eli Zaretskii <eliz <at> gnu.org>
To: Eval Exec <execvy <at> gmail.com>
Cc: v.pupillo <at> gmail.com, 77914 <at> debbugs.gnu.org
Subject: Re: bug#77914: 31.0.50;
 treesit-font-lock-level set to 4 cause rust-ts-mode lost all color
Date: Sun, 20 Apr 2025 12:29:07 +0300

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

Message #29 received at submit <at> debbugs.gnu.org (full text, mbox):

From: Vincenzo Pupillo <v.pupillo <at> gmail.com>
To: 77914 <at> debbugs.gnu.org, bug-gnu-emacs <at> gnu.org,
 Eval Exec <execvy <at> gmail.com>, Juri Linkov <juri <at> linkov.net>,
 Eli Zaretskii <eliz <at> gnu.org>
Subject: Re: bug#77914: 31.0.50;
 treesit-font-lock-level set to 4 cause rust-ts-mode lost all color
Date: Mon, 21 Apr 2025 23:21:23 +0200

[Message part 1 (text/plain, inline)]

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

Vincenzo

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


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

[rust-ts-issue.png (image/png, attachment)]

Message #35 received at 77914 <at> debbugs.gnu.org (full text, mbox):

From: Juri Linkov <juri <at> linkov.net>
To: Vincenzo Pupillo <v.pupillo <at> gmail.com>
Cc: Eli Zaretskii <eliz <at> gnu.org>, Eval Exec <execvy <at> gmail.com>,
 77914 <at> debbugs.gnu.org
Subject: Re: bug#77914: 31.0.50; treesit-font-lock-level set to 4 cause
 rust-ts-mode lost all color
Date: Tue, 22 Apr 2025 09:42:59 +0300

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

Maybe because they only bumped the ABI version from 14 to 15
without making more changes required for ABI 15:

  [dev-dependencies]
- tree-sitter = "0.24"
+ tree-sitter = "0.25"

Also see https://github.com/tree-sitter/tree-sitter-rust/issues/273

Message #38 received at 77914 <at> debbugs.gnu.org (full text, mbox):

From: Juri Linkov <juri <at> linkov.net>
To: Eval Exec <execvy <at> gmail.com>
Cc: v.pupillo <at> gmail.com, 77914 <at> debbugs.gnu.org
Subject: Re: bug#77914: 31.0.50; treesit-font-lock-level set to 4 cause
 rust-ts-mode lost all color
Date: Tue, 22 Apr 2025 21:30:04 +0300

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

The treesit-font-lock-level 4 contains the symbol 'error',
therefore it adds highlighting of the ERROR nodes.
At level 3 there are still errors, but whey are not highlighted.
Removing the macro removes the errors.

So if you are sure that the file is correct,
you can report the issue to the authors of
https://github.com/tree-sitter/tree-sitter-rust

Then they can answer why everything in the first macro
is the error:

  (ERROR
   (ERROR (identifier))
   (identifier) {
   (ERROR ( $ ()
   (attribute_item # [
    (ERROR $ ()
    (attribute (metavariable))
    (ERROR : tt ) *)
    ])
   (ERROR ) * (metavariable) : ident)
   (identifier)
   (ERROR $ ( { $ ( (metavariable) :
    (try_expression (identifier)
     (ERROR ) * } ))
     ?)
    (metavariable) : (identifier)
    (ERROR $)
    (
    (ERROR , $)
    ( (metavariable))
   :
   (ERROR
    (try_expression (identifier)
     (ERROR ) * ))
     ?)
    ) => { $)

Message #41 received at 77914 <at> debbugs.gnu.org (full text, mbox):

From: Vincenzo Pupillo <v.pupillo <at> gmail.com>
To: Eval Exec <execvy <at> gmail.com>, Juri Linkov <juri <at> linkov.net>
Cc: 77914 <at> debbugs.gnu.org
Subject: Re: bug#77914: 31.0.50;
 treesit-font-lock-level set to 4 cause rust-ts-mode lost all color
Date: Tue, 22 Apr 2025 21:24:42 +0200

Yes, I add here the result returned by tree-sitter command line with rust 
grammar v0.23.2:

(ERROR [0, 0] - [1105, 0]
 (line_comment [0, 0] - [1, 0]
 inner: (inner_doc_comment_marker [0, 2] - [0, 3])
 doc: (doc_comment [0, 3] - [1, 0]))
 (line_comment [1, 0] - [2, 0]
 inner: (inner_doc_comment_marker [1, 2] - [1, 3])
 doc: (doc_comment [1, 3] - [2, 0]))
 (line_comment [2, 0] - [3, 0]
 inner: (inner_doc_comment_marker [2, 2] - [2, 3])
 doc: (doc_comment [2, 3] - [3, 0])
 (line_comment [3, 0] - [4, 0]
.....

This tool also marks the entire buffer as incorrect.

Vincenzo

In data martedì 22 aprile 2025 20:30:04 Ora legale dell’Europa centrale, Juri 
Linkov ha scritto:
> > 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.
> 
> The treesit-font-lock-level 4 contains the symbol 'error',
> therefore it adds highlighting of the ERROR nodes.
> At level 3 there are still errors, but whey are not highlighted.
> Removing the macro removes the errors.
> 
> So if you are sure that the file is correct,
> you can report the issue to the authors of
> https://github.com/tree-sitter/tree-sitter-rust
> 
> Then they can answer why everything in the first macro
> is the error:
> 
>   (ERROR
>    (ERROR (identifier))
>    (identifier) {
>    (ERROR ( $ ()
>    (attribute_item # [
>     (ERROR $ ()
>     (attribute (metavariable))
>     (ERROR : tt ) *)
>     ])
>    (ERROR ) * (metavariable) : ident)
>    (identifier)
>    (ERROR $ ( { $ ( (metavariable) :
>     (try_expression (identifier)
>      (ERROR ) * } ))
>      ?)
>     (metavariable) : (identifier)
>     (ERROR $)
>     (
>     (ERROR , $)
>     ( (metavariable))
> 
>    (ERROR
>     (try_expression (identifier)
>      (ERROR ) * ))
>      ?)
>     ) => { $)

Previous Next

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