Trait lark_test::DebugWith

pub trait DebugWith {
    fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error>
    where
        Cx: ?Sized;

    fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx>
    where
        Cx: ?Sized,
    { ... }
    fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx>
    where
        Cx: ?Sized,
    { ... }
}

A Debug trait that carries a context. Most types in Lark implement it, and you can use derive(DebugWith) to get Debug-like behavior (from the lark-debug-derive crate).

To use it, do something like format!("{}", value.debug_with(cx)).

Required methods

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

Loading content...

Provided methods

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

Loading content...

Implementations on Foreign Types

impl<T> DebugWith for Seq<T> where
    T: DebugWith, 

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl<I, T> DebugWith for IndexVec<I, T> where
    I: U32Index,
    T: DebugWith, 

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for char

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for isize

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for String

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl<A, B> DebugWith for (A, B) where
    A: DebugWith,
    B: DebugWith, 

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for i32

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for u16

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for str

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for bool

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl<T> DebugWith for Box<T> where
    T: DebugWith, 

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl<T> DebugWith for [T] where
    T: DebugWith, 

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl<'_, T> DebugWith for &'_ mut T where
    T: DebugWith + ?Sized, 

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl<T> DebugWith for Option<T> where
    T: DebugWith, 

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl<O, E> DebugWith for Result<O, E> where
    E: DebugWith,
    O: DebugWith, 

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for !

fn fmt_with<Cx>(&self, _cx: &Cx, _fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for u32

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl<A, B, C> DebugWith for (A, B, C) where
    A: DebugWith,
    B: DebugWith,
    C: DebugWith, 

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for u8

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for usize

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl<T> DebugWith for Vec<T> where
    T: DebugWith, 

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl<'_, T> DebugWith for &'_ T where
    T: DebugWith + ?Sized, 

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl<T> DebugWith for Arc<T> where
    T: DebugWith, 

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for i64

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl<T> DebugWith for Rc<T> where
    T: DebugWith, 

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for ()

fn fmt_with<Cx>(&self, _cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for i8

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for u64

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl<K, V, E> DebugWith for IndexMap<K, V, E> where
    E: BuildHasher,
    K: DebugWith + Hash + Eq,
    V: DebugWith, 

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for i16

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl<A, B, C, D> DebugWith for (A, B, C, D) where
    A: DebugWith,
    B: DebugWith,
    C: DebugWith,
    D: DebugWith, 

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for Curlies

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for ParsedMatch

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for HoverTargetKind

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for FunctionSignature

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for HoverTarget

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl<T> DebugWith for CommaList<T> where
    T: DebugWith, 

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for Let

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl<D> DebugWith for Matched<D> where
    D: DebugWith, 

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl<T> DebugWith for SkipNewline<T> where
    T: DebugWith, 

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for Plus

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl<G, V> DebugWith for Guard<G, V> where
    G: DebugWith,
    V: DebugWith, 

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for NamedTypeReference

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for OpenSquare

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for Parentheses

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for ParsedTypeReference

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for Member

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl<T, S> DebugWith for SeparatedList<T, S> where
    S: DebugWith,
    T: DebugWith, 

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for EntitySyntax

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for Semicolon

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for CloseParenthesis

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for TypeReference

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for CloseSquare

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for Comma

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for ParsedField

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for Slash

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for ParsedMethod

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for Field

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for ParsedFunctionSignature

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for ParsedEntityThunk

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for Star

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl<D, T> DebugWith for Delimited<D, T> where
    D: DebugWith,
    T: DebugWith, 

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for Equals

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for RightArrow

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for ParsedEntity

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for OpenParenthesis

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for Dot

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for CloseCurly

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for SpannedLocalIdentifier

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for Colon

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for ParsedFile

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for SpannedGlobalIdentifier

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for ExclamationPoint

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for Minus

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for OpenCurly

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for MemberKind

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for EntityData

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for LangItem

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for ItemKind

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for Entity

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for Diagnostic

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl<T> DebugWith for WithError<T> where
    T: DebugWith, 

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for ErrorReported

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl<File> DebugWith for Span<File> where
    File: SpanFile + DebugWith, 

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for ByteSize

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for CurrentEntity

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for CurrentFile

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for FileName

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl<T, File> DebugWith for Spanned<T, File> where
    File: SpanFile + DebugWith,
    T: DebugWith, 

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for ByteIndex

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for Location

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for Text

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for GlobalIdentifier

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for MetaIndex

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for UnaryOperator

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for FnBody

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for LiteralData

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for IdentifiedExpressionData

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for VariableData

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for Error

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for IdentifierData

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for FnBodyTables

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for IdentifiedExpression

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for PlaceData

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for Place

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for Identifier

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for BinaryOperator

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for Expression

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for ExpressionData

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for LiteralKind

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for Variable

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for Member

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for ErrorData

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl<I> DebugWith for List<I> where
    I: HirIndex, 

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for PermKind

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for BaseInferred

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl<T> DebugWith for BoundVarOr<T> where
    T: DebugWith, 

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for Base

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl<F> DebugWith for BaseKind<F> where
    F: TypeFamily + DebugWith, 

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for GenericDeclarations

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for GenericTyDeclaration

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for Perm

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for Universe

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl<F> DebugWith for Generics<F> where
    F: TypeFamily, 

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl<F> DebugWith for Ty<F> where
    F: TypeFamily + DebugWith, 

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for Base

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for FullInferred

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl<F> DebugWith for Signature<F> where
    F: TypeFamily + DebugWith, 

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for DeclaredPermKind

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for Placeholder

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for Base

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl<F> DebugWith for BaseData<F> where
    F: TypeFamily + DebugWith, 

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl<T> DebugWith for InferVarOr<T> where
    T: DebugWith, 

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for Declaration

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for BoundVar

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for Erased

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl<T> DebugWith for GenericKind<T> where
    T: DebugWith, 

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for ReprKind

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl DebugWith for InferVar

fn fmt_with<Cx>(&self, cx: &Cx, fmt: &mut Formatter) -> Result<(), Error> where
    Cx: ?Sized, 

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

Loading content...

Implementors

Loading content...