Trait swc_core::common::TypeEq

pub trait TypeEq {
    // Required method
    fn type_eq(&self, other: &Self) -> bool;
}

Available on crate feature __common only.

Derive with #[derive(TypeEq)].

Required Methods

fn type_eq(&self, other: &Self) -> bool

Note: This method should return true for non-type values.

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl TypeEq for bool

fn type_eq(&self, other: &bool) -> bool

impl TypeEq for char

fn type_eq(&self, other: &char) -> bool

impl TypeEq for f32

fn type_eq(&self, other: &f32) -> bool

impl TypeEq for f64

fn type_eq(&self, other: &f64) -> bool

impl TypeEq for i8

fn type_eq(&self, other: &i8) -> bool

impl TypeEq for i16

fn type_eq(&self, other: &i16) -> bool

impl TypeEq for i32

fn type_eq(&self, other: &i32) -> bool

impl TypeEq for i64

fn type_eq(&self, other: &i64) -> bool

impl TypeEq for i128

fn type_eq(&self, other: &i128) -> bool

impl TypeEq for isize

fn type_eq(&self, other: &isize) -> bool

impl TypeEq for str

fn type_eq(&self, other: &str) -> bool

impl TypeEq for u8

fn type_eq(&self, other: &u8) -> bool

impl TypeEq for u16

fn type_eq(&self, other: &u16) -> bool

impl TypeEq for u32

fn type_eq(&self, other: &u32) -> bool

impl TypeEq for u64

fn type_eq(&self, other: &u64) -> bool

impl TypeEq for u128

fn type_eq(&self, other: &u128) -> bool

impl TypeEq for usize

fn type_eq(&self, other: &usize) -> bool

impl TypeEq for String

fn type_eq(&self, other: &String) -> bool

impl TypeEq for BigInt

fn type_eq(&self, other: &BigInt) -> bool

impl<'a, N> TypeEq for &'a N

where N: TypeEq,

fn type_eq(&self, other: &&'a N) -> bool

impl<B, A> TypeEq for (B, A)

where B: TypeEq, A: TypeEq,

fn type_eq(&self, rhs: &(B, A)) -> bool

impl<C, B, A> TypeEq for (C, B, A)

where C: TypeEq, B: TypeEq, A: TypeEq,

fn type_eq(&self, rhs: &(C, B, A)) -> bool

impl<D, C, B, A> TypeEq for (D, C, B, A)

where D: TypeEq, C: TypeEq, B: TypeEq, A: TypeEq,

fn type_eq(&self, rhs: &(D, C, B, A)) -> bool

impl<E, D, C, B, A> TypeEq for (E, D, C, B, A)

where E: TypeEq, D: TypeEq, C: TypeEq, B: TypeEq, A: TypeEq,

fn type_eq(&self, rhs: &(E, D, C, B, A)) -> bool

impl<F, E, D, C, B, A> TypeEq for (F, E, D, C, B, A)

where F: TypeEq, E: TypeEq, D: TypeEq, C: TypeEq, B: TypeEq, A: TypeEq,

fn type_eq(&self, rhs: &(F, E, D, C, B, A)) -> bool

impl<G, F, E, D, C, B, A> TypeEq for (G, F, E, D, C, B, A)

where G: TypeEq, F: TypeEq, E: TypeEq, D: TypeEq, C: TypeEq, B: TypeEq, A: TypeEq,

fn type_eq(&self, rhs: &(G, F, E, D, C, B, A)) -> bool

impl<H, G, F, E, D, C, B, A> TypeEq for (H, G, F, E, D, C, B, A)

where H: TypeEq, G: TypeEq, F: TypeEq, E: TypeEq, D: TypeEq, C: TypeEq, B: TypeEq, A: TypeEq,

fn type_eq(&self, rhs: &(H, G, F, E, D, C, B, A)) -> bool

impl<I, H, G, F, E, D, C, B, A> TypeEq for (I, H, G, F, E, D, C, B, A)

where I: TypeEq, H: TypeEq, G: TypeEq, F: TypeEq, E: TypeEq, D: TypeEq, C: TypeEq, B: TypeEq, A: TypeEq,

fn type_eq(&self, rhs: &(I, H, G, F, E, D, C, B, A)) -> bool

impl<J, I, H, G, F, E, D, C, B, A> TypeEq for (J, I, H, G, F, E, D, C, B, A)

where J: TypeEq, I: TypeEq, H: TypeEq, G: TypeEq, F: TypeEq, E: TypeEq, D: TypeEq, C: TypeEq, B: TypeEq, A: TypeEq,

fn type_eq(&self, rhs: &(J, I, H, G, F, E, D, C, B, A)) -> bool

impl<K, J, I, H, G, F, E, D, C, B, A> TypeEq for (K, J, I, H, G, F, E, D, C, B, A)

where K: TypeEq, J: TypeEq, I: TypeEq, H: TypeEq, G: TypeEq, F: TypeEq, E: TypeEq, D: TypeEq, C: TypeEq, B: TypeEq, A: TypeEq,

fn type_eq(&self, rhs: &(K, J, I, H, G, F, E, D, C, B, A)) -> bool

impl<L, K, J, I, H, G, F, E, D, C, B, A> TypeEq for (L, K, J, I, H, G, F, E, D, C, B, A)

where L: TypeEq, K: TypeEq, J: TypeEq, I: TypeEq, H: TypeEq, G: TypeEq, F: TypeEq, E: TypeEq, D: TypeEq, C: TypeEq, B: TypeEq, A: TypeEq,

fn type_eq(&self, rhs: &(L, K, J, I, H, G, F, E, D, C, B, A)) -> bool

impl<M, L, K, J, I, H, G, F, E, D, C, B, A> TypeEq for (M, L, K, J, I, H, G, F, E, D, C, B, A)

where M: TypeEq, L: TypeEq, K: TypeEq, J: TypeEq, I: TypeEq, H: TypeEq, G: TypeEq, F: TypeEq, E: TypeEq, D: TypeEq, C: TypeEq, B: TypeEq, A: TypeEq,

fn type_eq(&self, rhs: &(M, L, K, J, I, H, G, F, E, D, C, B, A)) -> bool

impl<N> TypeEq for Box<N>

where N: TypeEq,

fn type_eq(&self, other: &Box<N>) -> bool

impl<N> TypeEq for Rc<N>

where N: TypeEq,

fn type_eq(&self, other: &Rc<N>) -> bool

impl<N> TypeEq for RefCell<N>

where N: TypeEq,

fn type_eq(&self, other: &RefCell<N>) -> bool

impl<N, M, L, K, J, I, H, G, F, E, D, C, B, A> TypeEq for (N, M, L, K, J, I, H, G, F, E, D, C, B, A)

where N: TypeEq, M: TypeEq, L: TypeEq, K: TypeEq, J: TypeEq, I: TypeEq, H: TypeEq, G: TypeEq, F: TypeEq, E: TypeEq, D: TypeEq, C: TypeEq, B: TypeEq, A: TypeEq,

fn type_eq(&self, rhs: &(N, M, L, K, J, I, H, G, F, E, D, C, B, A)) -> bool

impl<O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> TypeEq for (O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

where O: TypeEq, N: TypeEq, M: TypeEq, L: TypeEq, K: TypeEq, J: TypeEq, I: TypeEq, H: TypeEq, G: TypeEq, F: TypeEq, E: TypeEq, D: TypeEq, C: TypeEq, B: TypeEq, A: TypeEq,

fn type_eq(&self, rhs: &(O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)) -> bool

impl<P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> TypeEq for (P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

where P: TypeEq, O: TypeEq, N: TypeEq, M: TypeEq, L: TypeEq, K: TypeEq, J: TypeEq, I: TypeEq, H: TypeEq, G: TypeEq, F: TypeEq, E: TypeEq, D: TypeEq, C: TypeEq, B: TypeEq, A: TypeEq,

fn type_eq( &self, rhs: &(P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A) ) -> bool

impl<Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> TypeEq for (Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

where Q: TypeEq, P: TypeEq, O: TypeEq, N: TypeEq, M: TypeEq, L: TypeEq, K: TypeEq, J: TypeEq, I: TypeEq, H: TypeEq, G: TypeEq, F: TypeEq, E: TypeEq, D: TypeEq, C: TypeEq, B: TypeEq, A: TypeEq,

fn type_eq( &self, rhs: &(Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A) ) -> bool

impl<R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> TypeEq for (R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

where R: TypeEq, Q: TypeEq, P: TypeEq, O: TypeEq, N: TypeEq, M: TypeEq, L: TypeEq, K: TypeEq, J: TypeEq, I: TypeEq, H: TypeEq, G: TypeEq, F: TypeEq, E: TypeEq, D: TypeEq, C: TypeEq, B: TypeEq, A: TypeEq,

fn type_eq( &self, rhs: &(R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A) ) -> bool

impl<S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> TypeEq for (S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

where S: TypeEq, R: TypeEq, Q: TypeEq, P: TypeEq, O: TypeEq, N: TypeEq, M: TypeEq, L: TypeEq, K: TypeEq, J: TypeEq, I: TypeEq, H: TypeEq, G: TypeEq, F: TypeEq, E: TypeEq, D: TypeEq, C: TypeEq, B: TypeEq, A: TypeEq,

fn type_eq( &self, rhs: &(S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A) ) -> bool

impl<T> TypeEq for Option<T>

where T: TypeEq,

fn type_eq(&self, other: &Option<T>) -> bool

impl<T> TypeEq for Vec<T>

where T: TypeEq,

fn type_eq(&self, other: &Vec<T>) -> bool

impl<T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> TypeEq for (T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

where T: TypeEq, S: TypeEq, R: TypeEq, Q: TypeEq, P: TypeEq, O: TypeEq, N: TypeEq, M: TypeEq, L: TypeEq, K: TypeEq, J: TypeEq, I: TypeEq, H: TypeEq, G: TypeEq, F: TypeEq, E: TypeEq, D: TypeEq, C: TypeEq, B: TypeEq, A: TypeEq,

fn type_eq( &self, rhs: &(T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A) ) -> bool

impl<U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> TypeEq for (U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

where U: TypeEq, T: TypeEq, S: TypeEq, R: TypeEq, Q: TypeEq, P: TypeEq, O: TypeEq, N: TypeEq, M: TypeEq, L: TypeEq, K: TypeEq, J: TypeEq, I: TypeEq, H: TypeEq, G: TypeEq, F: TypeEq, E: TypeEq, D: TypeEq, C: TypeEq, B: TypeEq, A: TypeEq,

fn type_eq( &self, rhs: &(U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A) ) -> bool

impl<V, U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> TypeEq for (V, U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

where V: TypeEq, U: TypeEq, T: TypeEq, S: TypeEq, R: TypeEq, Q: TypeEq, P: TypeEq, O: TypeEq, N: TypeEq, M: TypeEq, L: TypeEq, K: TypeEq, J: TypeEq, I: TypeEq, H: TypeEq, G: TypeEq, F: TypeEq, E: TypeEq, D: TypeEq, C: TypeEq, B: TypeEq, A: TypeEq,

fn type_eq( &self, rhs: &(V, U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A) ) -> bool

impl<W, V, U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> TypeEq for (W, V, U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

where W: TypeEq, V: TypeEq, U: TypeEq, T: TypeEq, S: TypeEq, R: TypeEq, Q: TypeEq, P: TypeEq, O: TypeEq, N: TypeEq, M: TypeEq, L: TypeEq, K: TypeEq, J: TypeEq, I: TypeEq, H: TypeEq, G: TypeEq, F: TypeEq, E: TypeEq, D: TypeEq, C: TypeEq, B: TypeEq, A: TypeEq,

fn type_eq( &self, rhs: &(W, V, U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A) ) -> bool

impl<X, W, V, U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> TypeEq for (X, W, V, U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

where X: TypeEq, W: TypeEq, V: TypeEq, U: TypeEq, T: TypeEq, S: TypeEq, R: TypeEq, Q: TypeEq, P: TypeEq, O: TypeEq, N: TypeEq, M: TypeEq, L: TypeEq, K: TypeEq, J: TypeEq, I: TypeEq, H: TypeEq, G: TypeEq, F: TypeEq, E: TypeEq, D: TypeEq, C: TypeEq, B: TypeEq, A: TypeEq,

fn type_eq( &self, rhs: &(X, W, V, U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A) ) -> bool

impl<Y, X, W, V, U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> TypeEq for (Y, X, W, V, U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

where Y: TypeEq, X: TypeEq, W: TypeEq, V: TypeEq, U: TypeEq, T: TypeEq, S: TypeEq, R: TypeEq, Q: TypeEq, P: TypeEq, O: TypeEq, N: TypeEq, M: TypeEq, L: TypeEq, K: TypeEq, J: TypeEq, I: TypeEq, H: TypeEq, G: TypeEq, F: TypeEq, E: TypeEq, D: TypeEq, C: TypeEq, B: TypeEq, A: TypeEq,

fn type_eq( &self, rhs: &(Y, X, W, V, U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A) ) -> bool

impl<Z, Y, X, W, V, U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> TypeEq for (Z, Y, X, W, V, U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A)

where Z: TypeEq, Y: TypeEq, X: TypeEq, W: TypeEq, V: TypeEq, U: TypeEq, T: TypeEq, S: TypeEq, R: TypeEq, Q: TypeEq, P: TypeEq, O: TypeEq, N: TypeEq, M: TypeEq, L: TypeEq, K: TypeEq, J: TypeEq, I: TypeEq, H: TypeEq, G: TypeEq, F: TypeEq, E: TypeEq, D: TypeEq, C: TypeEq, B: TypeEq, A: TypeEq,

fn type_eq( &self, rhs: &(Z, Y, X, W, V, U, T, S, R, Q, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A) ) -> bool

Implementors

impl TypeEq for BytePos

impl TypeEq for Span

impl TypeEq for SyntaxContext

impl<N> TypeEq for Arc<N>

where N: TypeEq,