Struct stc_ts_types::type_id::ClassId

pub struct ClassId(u64);

Used to distinguish private class properties.

Context

derivedClassTransitivity.ts:

// subclassing is not transitive when you can remove required parameters and add optional parameters

class C {
    foo(x: number) { }
}

class D extends C {
    foo() { } // ok to drop parameters
}

class E extends D {
    foo(x?: string) { } // ok to add optional parameters
}

var c: C;
var d: D;
var e: E;
c = e;
var r = c.foo(1);
var r2 = e.foo('');

---

As derived class may have different signature than parent class, we can’t use super class to assign classes.

Because of it, we should assign properties directly.

It means we need a way to know if two class properties are exactly identical i.e. declared in same class.

Note

Alternative

[WIP] (Seeing if span is enough)

lo and hi of a swc_common::Span can be also used to check if two private properties are identical, but I(kdy1) decided to use a new type because

Not data

This is not data part of class and as a result type_eq and eq_ignore_span always return true.

Tuple Fields

0: u64

Implementations

impl ClassId

pub fn generate() -> Self

Trait Implementations

impl Clone for ClassId

fn clone(&self) -> ClassId

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ClassId

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl EqIgnoreSpan for ClassId

Always true.

fn eq_ignore_span(&self, _: &Self) -> bool

impl<V> FoldWith<V> for ClassIdwhere
    V: ?Sized,

fn fold_children_with(self, _visitor: &mut V) -> Self

fn fold_with(self, visitor: &mut V) -> Selfwhere
    V: Fold<Self>,

impl Hash for ClassId

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,

Feeds a slice of this type into the given Hasher.

impl PartialEq<ClassId> for ClassId

fn eq(&self, other: &ClassId) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TypeEq for ClassId

Always true.

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

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

impl<V> VisitMutWith<V> for ClassIdwhere
    V: ?Sized,

fn visit_mut_children_with(&mut self, _visitor: &mut V)

fn visit_mut_with(&mut self, visitor: &mut V)where
    V: VisitMut<Self>,

impl<V> VisitWith<V> for ClassIdwhere
    V: ?Sized,

fn visit_children_with(&self, _visitor: &mut V)

fn visit_with(&self, visitor: &mut V)where
    V: Visit<Self>,

impl Copy for ClassId

impl Eq for ClassId

impl StructuralEq for ClassId

impl StructuralPartialEq for ClassId

impl Visitable for ClassId