compiler/rustc_feature/src/unstable.rs:
⋮
│impl Features {
⋮
│    pub fn gca(&self) -> bool {
⋮
compiler/rustc_middle/src/mir/interpret/error.rs:
⋮
│impl<'tcx, T> InterpResult<'tcx, T> {
⋮
│    pub fn unwrap_or_else(self, f: impl FnOnce(InterpErrorInfo<'tcx>) -> T) -> T {
⋮
compiler/rustc_middle/src/mir/interpret/mod.rs:
⋮
│pub enum GlobalAlloc<'tcx> {
⋮
compiler/rustc_public/src/mir/alloc.rs:
⋮
│pub enum GlobalAlloc {
⋮
compiler/rustc_resolve/src/macros.rs:
⋮
│impl<'ra, 'tcx> ResolverExpand for Resolver<'ra, 'tcx> {
⋮
│    fn cfg_accessible(
│        &mut self,
│        expn_id: LocalExpnId,
│        path: &ast::Path,
⋮
compiler/rustc_type_ir/src/binder.rs:
⋮
│impl<I: Interner> BoundRegion<I> {
⋮
│    pub fn assert_eq(self, var: BoundVariableKind<I>) {
⋮
│impl<I: Interner> BoundTy<I> {
⋮
│    pub fn assert_eq(self, var: BoundVariableKind<I>) {
⋮
│impl<I: Interner> BoundConst<I> {
⋮
│    pub fn assert_eq(self, var: BoundVariableKind<I>) {
⋮
library/alloc/src/string.rs:
⋮
│pub trait ToString {
⋮
library/core/src/alloc/global.rs:
⋮
│pub unsafe trait GlobalAlloc {
⋮
library/core/src/fmt/mod.rs:
⋮
│impl<'a> Formatter<'a> {
⋮
│    pub fn debug_struct<'b>(&'b mut self, name: &str) -> DebugStruct<'b, 'a> {
⋮
library/core/src/iter/traits/exact_size.rs:
⋮
│pub trait ExactSizeIterator: Iterator {
⋮
library/core/src/iter/traits/marker.rs:
⋮
│pub trait FusedIterator: Iterator {}
⋮
│pub const unsafe trait TrustedLen: [const] Iterator {}
⋮
library/core/src/macros/mod.rs:
⋮
│macro_rules! assert_eq {
⋮
│macro_rules! assert_ne {
⋮
│macro_rules! debug_assert {
⋮
│macro_rules! debug_assert_eq {
⋮
│macro_rules! debug_assert_ne {
⋮
│macro_rules! unimplemented {
⋮
│macro_rules! todo {
⋮
│pub(crate) mod builtin {
⋮
│    macro_rules! format_args {
⋮
│    macro_rules! include_str {
⋮
library/core/src/marker.rs:
⋮
│macro_rules! gca {
⋮
│pub trait Reborrow {
⋮
library/core/src/ops/deref.rs:
⋮
│pub unsafe trait DerefPure: PointeeSized {}
⋮
library/core/src/option.rs:
⋮
│    pub const fn is_some_and(self, f: impl [const] FnOnce(T) -> bool + [const] Destruct) -> bool {
│        match self {
│            None => false,
│            Some(x) => f(x),
⋮
│    pub const fn unwrap_or(self, default: T) -> T
│    where
│        T: [const] Destruct,
⋮
library/core/src/prelude/v1.rs:
⋮
│mod ambiguous_macros_only {
⋮
library/core/src/ptr/const_ptr.rs:
⋮
│impl<T: PointeeSized> *const T {
⋮
│    pub const fn wrapping_sub(self, count: usize) -> Self
│    where
│        T: Sized,
⋮
library/core/src/ptr/mut_ptr.rs:
⋮
│impl<T: PointeeSized> *mut T {
⋮
│    pub const fn wrapping_sub(self, count: usize) -> Self
│    where
│        T: Sized,
⋮
library/core/src/slice/iter/macros.rs:
⋮
│macro_rules! if_zst {
⋮
library/core/src/time.rs:
⋮
│impl Duration {
⋮
│    pub const fn checked_sub(self, rhs: Duration) -> Option<Duration> {
⋮
library/portable-simd/crates/core_simd/src/iter.rs:
⋮
│macro_rules! impl_traits {
⋮
library/portable-simd/crates/core_simd/src/simd/ptr/const_ptr.rs:
⋮
│impl<T, const N: usize> SimdConstPtr for Simd<*const T, N> {
⋮
│    fn wrapping_sub(self, count: Self::Usize) -> Self {
⋮
library/portable-simd/crates/core_simd/src/simd/ptr/mut_ptr.rs:
⋮
│impl<T, const N: usize> SimdMutPtr for Simd<*mut T, N> {
⋮
│    fn wrapping_sub(self, count: Self::Usize) -> Self {
⋮
library/std/src/macros.rs:
⋮
│macro_rules! println {
⋮
library/std/src/os/xous/ffi/definitions/memoryflags.rs:
⋮
│pub struct MemoryFlags {
⋮
library/std/src/prelude/v1.rs:
⋮
│mod ambiguous_macros_only {
⋮
library/std/src/time.rs:
⋮
│impl Instant {
⋮
│    pub fn checked_sub(&self, duration: Duration) -> Option<Instant> {
⋮
│impl SystemTime {
⋮
│    pub fn checked_sub(&self, duration: Duration) -> Option<SystemTime> {
⋮
src/tools/miri/tests/genmc/pass/atomics/rmw_ops.rs:
⋮
│macro_rules! test_rmw_edge_cases {
⋮
src/tools/rust-analyzer/crates/hir-def/src/macro_expansion_tests/builtin_fn_macro.rs:
⋮
│fn cfg_select() {
⋮
src/tools/rust-analyzer/crates/rust-analyzer/src/cli/progress_report.rs:
⋮
│impl<'a> ProgressReport<'a> {
⋮
│    pub(crate) fn println<I: Into<String>>(&mut self, msg: I) {
⋮
src/tools/rust-analyzer/crates/test-utils/src/minicore.rs:
⋮
│    pub trait Reborrow {}
⋮
│pub mod ops {
⋮
│    mod deref {
⋮
│        pub trait DerefMut: Deref + PointeeSized {
⋮
│        pub unsafe trait DerefPure: PointeeSized {}
⋮
│    mod try_ {
⋮
│pub mod cmp {
⋮
│    pub trait PartialEq<Rhs: PointeeSized = Self>: PointeeSized {
⋮
│    pub trait PartialOrd<Rhs: PointeeSized = Self>: PartialEq<Rhs> + PointeeSized {
⋮
│pub mod fmt {
⋮
│    impl Formatter<'_> {
⋮
│        pub fn debug_struct(&mut self, _name: &str) -> DebugStruct {
⋮
│pub mod option {
⋮
│    impl<T> Option<T> {
⋮
│        pub fn unwrap_or(self, default: T) -> T {
⋮
│        pub fn unwrap_or_else<F>(self, _f: F) -> T
│        where
│            F: FnOnce() -> T,
⋮
│pub mod result {
⋮
│    impl<T, E> Result<T, E> {
⋮
│        pub const fn unwrap_or(self, default: T) -> T {
⋮
│        pub const fn unwrap_or_else<F>(self, op: F) -> T
│        where
│            F: FnOnce(E) -> T,
⋮
│pub mod iter {
⋮
│    mod traits {
⋮
│        mod collect {
│            pub trait IntoIterator {
⋮
│mod macros {
⋮
│    macro_rules! format_args {
⋮
│    macro_rules! todo {
⋮
│    macro_rules! unimplemented {
⋮
src/tools/rust-analyzer/lib/text-size/src/range.rs:
⋮
│impl TextRange {
⋮
│    pub fn checked_sub(self, offset: TextSize) -> Option<TextRange> {
⋮
src/tools/rust-analyzer/lib/text-size/src/size.rs:
⋮
│impl TextSize {
⋮
│    pub const fn checked_sub(self, rhs: TextSize) -> Option<TextSize> {
⋮
src/tools/test-float-parse/src/ui.rs:
⋮
│impl Progress {
⋮
│    pub fn println(&self, msg: &str) {
⋮
