Enum stc_ts_types::Type

pub enum Type {
    Instance(Instance),
    StaticThis(StaticThis),
    This(ThisType),
    Lit(LitType),
    Query(QueryType),
    Infer(InferType),
    Import(ImportType),
    Predicate(Predicate),
    IndexedAccessType(IndexedAccessType),
    Ref(Ref),
    TypeLit(TypeLit),
    Keyword(KeywordType),
    Conditional(Conditional),
    Tuple(Tuple),
    Array(Array),
    Union(Union),
    Intersection(Intersection),
    Function(Function),
    Constructor(Constructor),
    Index(Index),
    Readonly(Readonly),
    Unique(Unique),
    Param(TypeParam),
    EnumVariant(EnumVariant),
    Interface(Interface),
    Enum(ArcCow<Enum>),
    Mapped(Mapped),
    Alias(Alias),
    Namespace(Namespace),
    Module(Module),
    Class(Class),
    ClassDef(ArcCow<ClassDef>),
    Arc(Freezed),
    Rest(RestType),
    Optional(OptionalType),
    Symbol(Symbol),
    Tpl(TplType),
    StringMapping(StringMapping),
}

A TypeScript type.

Invariants

• Type::Union cannot have a single element.

• Type::Intersection cannot have a single element.

• Type::Union cannot have Type::Union as a element,

• Type::Intersection cannot have Type::Intersection as a element,

Type::assert_valid can be used to ensure invariants. Note that this is noop in release build.

Clone

To reduce memory usage, this type should be freeze()-ed. Freezed type is immutable, and it’s cheap to clone. When required, you can use normalize_mut() or foldable() to get mutable version.

Note: You have to call normalize() while pattern matching.

To enforce this, deep cloning is not allowed by default. If you want to clone deeply, you have to clone this type in a closure passed to ALLOW_DEEP_CLONE. But this is not recommended, and should be avoided for performance.

Variants

Instance(Instance)

StaticThis(StaticThis)

This(ThisType)

Lit(LitType)

Query(QueryType)

Infer(InferType)

Import(ImportType)

Predicate(Predicate)

IndexedAccessType(IndexedAccessType)

Ref(Ref)

TypeLit(TypeLit)

Keyword(KeywordType)

Conditional(Conditional)

Tuple(Tuple)

Array(Array)

Union(Union)

Intersection(Intersection)

Function(Function)

Constructor(Constructor)

Index(Index)

Readonly(Readonly)

Unique(Unique)

Param(TypeParam)

EnumVariant(EnumVariant)

Interface(Interface)

Enum(ArcCow<Enum>)

Mapped(Mapped)

Alias(Alias)

export type A = Foo;

Namespace(Namespace)

Module(Module)

Class(Class)

Instance of a class.

ClassDef(ArcCow<ClassDef>)

Class definition itself.

Arc(Freezed)

Rest(RestType)

Optional(OptionalType)

Symbol(Symbol)

Tpl(TplType)

StringMapping(StringMapping)

Implementations

impl Type

pub fn is_this(&self) -> bool

pub fn as_this(&self) -> Option<&ThisType>

pub fn as_this_mut(&mut self) -> Option<&mut ThisType>

This method normalizes the type only if the underlying type is the required variant.

pub fn this(self) -> Option<ThisType>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_this(self) -> ThisType

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_lit(&self) -> bool

pub fn as_lit(&self) -> Option<&LitType>

pub fn as_lit_mut(&mut self) -> Option<&mut LitType>

This method normalizes the type only if the underlying type is the required variant.

pub fn lit(self) -> Option<LitType>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_lit(self) -> LitType

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_query(&self) -> bool

pub fn as_query(&self) -> Option<&QueryType>

pub fn as_query_mut(&mut self) -> Option<&mut QueryType>

This method normalizes the type only if the underlying type is the required variant.

pub fn query(self) -> Option<QueryType>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_query(self) -> QueryType

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_infer(&self) -> bool

pub fn as_infer(&self) -> Option<&InferType>

pub fn as_infer_mut(&mut self) -> Option<&mut InferType>

This method normalizes the type only if the underlying type is the required variant.

pub fn infer(self) -> Option<InferType>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_infer(self) -> InferType

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_import(&self) -> bool

pub fn as_import(&self) -> Option<&ImportType>

pub fn as_import_mut(&mut self) -> Option<&mut ImportType>

This method normalizes the type only if the underlying type is the required variant.

pub fn import(self) -> Option<ImportType>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_import(self) -> ImportType

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_predicate(&self) -> bool

pub fn as_predicate(&self) -> Option<&Predicate>

pub fn as_predicate_mut(&mut self) -> Option<&mut Predicate>

This method normalizes the type only if the underlying type is the required variant.

pub fn predicate(self) -> Option<Predicate>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_predicate(self) -> Predicate

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_indexed_access_type(&self) -> bool

pub fn as_indexed_access_type(&self) -> Option<&IndexedAccessType>

pub fn as_indexed_access_type_mut(&mut self) -> Option<&mut IndexedAccessType>

This method normalizes the type only if the underlying type is the required variant.

pub fn indexed_access_type(self) -> Option<IndexedAccessType>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_indexed_access_type(self) -> IndexedAccessType

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_ref_type(&self) -> bool

pub fn as_ref_type(&self) -> Option<&Ref>

pub fn as_ref_type_mut(&mut self) -> Option<&mut Ref>

This method normalizes the type only if the underlying type is the required variant.

pub fn ref_type(self) -> Option<Ref>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_ref_type(self) -> Ref

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_type_lit(&self) -> bool

pub fn as_type_lit(&self) -> Option<&TypeLit>

pub fn as_type_lit_mut(&mut self) -> Option<&mut TypeLit>

This method normalizes the type only if the underlying type is the required variant.

pub fn type_lit(self) -> Option<TypeLit>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_type_lit(self) -> TypeLit

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_keyword(&self) -> bool

pub fn as_keyword(&self) -> Option<&KeywordType>

pub fn as_keyword_mut(&mut self) -> Option<&mut KeywordType>

This method normalizes the type only if the underlying type is the required variant.

pub fn keyword(self) -> Option<KeywordType>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_keyword(self) -> KeywordType

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_conditional(&self) -> bool

pub fn as_conditional(&self) -> Option<&Conditional>

pub fn as_conditional_mut(&mut self) -> Option<&mut Conditional>

This method normalizes the type only if the underlying type is the required variant.

pub fn conditional(self) -> Option<Conditional>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_conditional(self) -> Conditional

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_tuple(&self) -> bool

pub fn as_tuple(&self) -> Option<&Tuple>

pub fn as_tuple_mut(&mut self) -> Option<&mut Tuple>

This method normalizes the type only if the underlying type is the required variant.

pub fn tuple(self) -> Option<Tuple>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_tuple(self) -> Tuple

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_array(&self) -> bool

pub fn as_array(&self) -> Option<&Array>

pub fn as_array_mut(&mut self) -> Option<&mut Array>

This method normalizes the type only if the underlying type is the required variant.

pub fn array(self) -> Option<Array>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_array(self) -> Array

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_union_type(&self) -> bool

pub fn as_union_type(&self) -> Option<&Union>

pub fn as_union_type_mut(&mut self) -> Option<&mut Union>

This method normalizes the type only if the underlying type is the required variant.

pub fn union_type(self) -> Option<Union>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_union_type(self) -> Union

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_intersection(&self) -> bool

pub fn as_intersection(&self) -> Option<&Intersection>

pub fn as_intersection_mut(&mut self) -> Option<&mut Intersection>

This method normalizes the type only if the underlying type is the required variant.

pub fn intersection(self) -> Option<Intersection>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_intersection(self) -> Intersection

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_fn_type(&self) -> bool

pub fn as_fn_type(&self) -> Option<&Function>

pub fn as_fn_type_mut(&mut self) -> Option<&mut Function>

This method normalizes the type only if the underlying type is the required variant.

pub fn fn_type(self) -> Option<Function>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_fn_type(self) -> Function

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_constructor(&self) -> bool

pub fn as_constructor(&self) -> Option<&Constructor>

pub fn as_constructor_mut(&mut self) -> Option<&mut Constructor>

This method normalizes the type only if the underlying type is the required variant.

pub fn constructor(self) -> Option<Constructor>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_constructor(self) -> Constructor

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_index(&self) -> bool

pub fn as_index(&self) -> Option<&Index>

pub fn as_index_mut(&mut self) -> Option<&mut Index>

This method normalizes the type only if the underlying type is the required variant.

pub fn index(self) -> Option<Index>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_index(self) -> Index

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_readonly(&self) -> bool

pub fn as_readonly(&self) -> Option<&Readonly>

pub fn as_readonly_mut(&mut self) -> Option<&mut Readonly>

This method normalizes the type only if the underlying type is the required variant.

pub fn readonly(self) -> Option<Readonly>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_readonly(self) -> Readonly

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_unique(&self) -> bool

pub fn as_unique(&self) -> Option<&Unique>

pub fn as_unique_mut(&mut self) -> Option<&mut Unique>

This method normalizes the type only if the underlying type is the required variant.

pub fn unique(self) -> Option<Unique>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_unique(self) -> Unique

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_type_param(&self) -> bool

pub fn as_type_param(&self) -> Option<&TypeParam>

pub fn as_type_param_mut(&mut self) -> Option<&mut TypeParam>

This method normalizes the type only if the underlying type is the required variant.

pub fn type_param(self) -> Option<TypeParam>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_type_param(self) -> TypeParam

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_enum_variant(&self) -> bool

pub fn as_enum_variant(&self) -> Option<&EnumVariant>

pub fn as_enum_variant_mut(&mut self) -> Option<&mut EnumVariant>

This method normalizes the type only if the underlying type is the required variant.

pub fn enum_variant(self) -> Option<EnumVariant>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_enum_variant(self) -> EnumVariant

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_interface(&self) -> bool

pub fn as_interface(&self) -> Option<&Interface>

pub fn as_interface_mut(&mut self) -> Option<&mut Interface>

This method normalizes the type only if the underlying type is the required variant.

pub fn interface(self) -> Option<Interface>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_interface(self) -> Interface

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_enum_type(&self) -> bool

pub fn as_enum_type(&self) -> Option<&ArcCow<Enum>>

pub fn as_enum_type_mut(&mut self) -> Option<&mut ArcCow<Enum>>

This method normalizes the type only if the underlying type is the required variant.

pub fn enum_type(self) -> Option<ArcCow<Enum>>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_enum_type(self) -> ArcCow<Enum>

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_mapped(&self) -> bool

pub fn as_mapped(&self) -> Option<&Mapped>

pub fn as_mapped_mut(&mut self) -> Option<&mut Mapped>

This method normalizes the type only if the underlying type is the required variant.

pub fn mapped(self) -> Option<Mapped>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_mapped(self) -> Mapped

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_alias(&self) -> bool

pub fn as_alias(&self) -> Option<&Alias>

pub fn as_alias_mut(&mut self) -> Option<&mut Alias>

This method normalizes the type only if the underlying type is the required variant.

pub fn alias(self) -> Option<Alias>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_alias(self) -> Alias

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_namespace(&self) -> bool

pub fn as_namespace(&self) -> Option<&Namespace>

pub fn as_namespace_mut(&mut self) -> Option<&mut Namespace>

This method normalizes the type only if the underlying type is the required variant.

pub fn namespace(self) -> Option<Namespace>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_namespace(self) -> Namespace

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_module(&self) -> bool

pub fn as_module(&self) -> Option<&Module>

pub fn as_module_mut(&mut self) -> Option<&mut Module>

This method normalizes the type only if the underlying type is the required variant.

pub fn module(self) -> Option<Module>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_module(self) -> Module

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_class(&self) -> bool

pub fn as_class(&self) -> Option<&Class>

pub fn as_class_mut(&mut self) -> Option<&mut Class>

This method normalizes the type only if the underlying type is the required variant.

pub fn class(self) -> Option<Class>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_class(self) -> Class

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_class_def(&self) -> bool

pub fn as_class_def(&self) -> Option<&ArcCow<ClassDef>>

pub fn as_class_def_mut(&mut self) -> Option<&mut ArcCow<ClassDef>>

This method normalizes the type only if the underlying type is the required variant.

pub fn class_def(self) -> Option<ArcCow<ClassDef>>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_class_def(self) -> ArcCow<ClassDef>

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_rest(&self) -> bool

pub fn as_rest(&self) -> Option<&RestType>

pub fn as_rest_mut(&mut self) -> Option<&mut RestType>

This method normalizes the type only if the underlying type is the required variant.

pub fn rest(self) -> Option<RestType>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_rest(self) -> RestType

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_optional(&self) -> bool

pub fn as_optional(&self) -> Option<&OptionalType>

pub fn as_optional_mut(&mut self) -> Option<&mut OptionalType>

This method normalizes the type only if the underlying type is the required variant.

pub fn optional(self) -> Option<OptionalType>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_optional(self) -> OptionalType

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_symbol(&self) -> bool

pub fn as_symbol(&self) -> Option<&Symbol>

pub fn as_symbol_mut(&mut self) -> Option<&mut Symbol>

This method normalizes the type only if the underlying type is the required variant.

pub fn symbol(self) -> Option<Symbol>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_symbol(self) -> Symbol

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_tpl(&self) -> bool

pub fn as_tpl(&self) -> Option<&TplType>

pub fn as_tpl_mut(&mut self) -> Option<&mut TplType>

This method normalizes the type only if the underlying type is the required variant.

pub fn tpl(self) -> Option<TplType>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_tpl(self) -> TplType

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_string_mapping(&self) -> bool

pub fn as_string_mapping(&self) -> Option<&StringMapping>

pub fn as_string_mapping_mut(&mut self) -> Option<&mut StringMapping>

This method normalizes the type only if the underlying type is the required variant.

pub fn string_mapping(self) -> Option<StringMapping>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_string_mapping(self) -> StringMapping

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn is_instance(&self) -> bool

pub fn as_instance(&self) -> Option<&Instance>

pub fn as_instance_mut(&mut self) -> Option<&mut Instance>

This method normalizes the type only if the underlying type is the required variant.

pub fn instance(self) -> Option<Instance>

This method normalizes the type only if the underlying type is the required variant.

pub fn expect_instance(self) -> Instance

Panics

Panics if the underlying type is not the required variant.

impl Type

pub fn assert_clone_cheap(&self)

pub fn new_intersection<I>(span: Span, iter: I) -> Selfwhere
    I: IntoIterator<Item = Type>,

pub fn new_union_without_dedup(span: Span, types: Vec<Type>) -> Self

pub fn new_union<I: IntoIterator<Item = Self> + Debug>(
    span: Span,
    iter: I
) -> Self

pub fn force_generalize_top_level_literals(self) -> Self

If self is Type::Lit, convert it to Type::Keyword.

pub fn is_void(&self) -> bool

pub fn contains_void(&self) -> bool

pub fn is_any(&self) -> bool

pub fn is_unknown(&self) -> bool

pub fn contains_undefined(&self) -> bool

pub fn as_array_without_readonly(&self) -> Option<&Array>

Returns Some if self is an array or an readonly array.

impl Type

pub fn is_clone_cheap(&self) -> bool

TODO

pub fn is_null(&self) -> bool

pub fn is_undefined(&self) -> bool

pub fn is_null_or_undefined(&self) -> bool

pub fn is_kwd(&self, k: TsKeywordTypeKind) -> bool

pub fn is_unique_symbol(&self) -> bool

pub fn is_symbol_like(&self) -> bool

pub fn is_never(&self) -> bool

pub fn never(span: Span, metadata: KeywordTypeMetadata) -> Self

pub fn undefined(span: Span, metadata: KeywordTypeMetadata) -> Self

pub fn any(span: Span, metadata: KeywordTypeMetadata) -> Self

pub fn void(span: Span, metadata: KeywordTypeMetadata) -> Self

pub fn unknown(span: Span, metadata: KeywordTypeMetadata) -> Self

pub fn is_str_like(&self) -> bool

pub fn is_num_like(&self) -> bool

pub fn is_bool_like(&self) -> bool

pub fn is_bigint_like(&self) -> bool

pub fn is_structured(&self) -> bool

pub fn is_substitution(&self) -> bool

pub fn is_instantiable_non_primitive(&self) -> bool

pub fn is_instantiable_primitive(&self) -> bool

pub fn is_instantiable(&self) -> bool

pub fn is_structured_or_instantiable(&self) -> bool

impl Type

pub fn metadata(&self) -> CommonTypeMetadata

pub fn metadata_mut(&mut self) -> &mut CommonTypeMetadata

pub fn reposition(&mut self, from: Span)

Respan but preserve SyntaxContext

pub fn respan(&mut self, span: Span)

impl Type

pub fn get_type_param_decl(&self) -> Option<&TypeParamDecl>

pub fn assert_valid(&self)

Panics if type is invalid. This is debug-build only and it’s noop on a release build.

Validity

For example, any | any is invalid because union should not have duplicate elements.

pub fn is_global_this(&self) -> bool

impl Type

pub fn foldable(self) -> Type

Converts this type to foldable type.

TODO(kdy1): Remove if possible

pub fn normalize<'s, 'c>(&'s self) -> &'c Typewhere
    's: 'c,

Type::Arc is normalized.

pub fn normalize_instance<'s, 'c>(&'s self) -> &'c Typewhere
    's: 'c,

Type::Arc and Type::Instance are normalized.

pub fn normalize_mut(&mut self) -> &mut Type

Type::Static is normalized.

pub fn iter_union(&self) -> impl Debug + Iterator<Item = &Type>

impl Type

pub fn is_builtin_interface(&self, name: &str) -> bool

Return true if self is a Type::Ref pointing to name.

pub fn is_str(&self) -> bool

Returns true if self is a string or a string literal.

pub fn is_str_lit(&self) -> bool

pub fn is_bool_lit(&self) -> bool

pub fn is_num(&self) -> bool

pub fn is_bigint(&self) -> bool

pub fn is_num_lit(&self) -> bool

pub fn is_bool(&self) -> bool

Returns true if self is a boolean or a boolean literal.

impl Type

pub fn as_bool(&self) -> Value<bool>

Trait Implementations

impl Clone for Type

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Type

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Type

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl EqIgnoreSpan for Type

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

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

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

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

impl Freeze for Type

fn is_clone_cheap(&self) -> bool

Returns true if `Clone::clone is cheap.

fn freeze(&mut self)

Make `Clone::clone cheap.

fn freezed(self) -> Self

Call Self::freeze and return self.

impl From<Alias> for Type

fn from(v: Alias) -> Self

Converts to this type from the input type.

impl From<ArcCow<ClassDef>> for Type

fn from(v: ArcCow<ClassDef>) -> Self

Converts to this type from the input type.

impl From<ArcCow<Enum>> for Type

fn from(v: ArcCow<Enum>) -> Self

Converts to this type from the input type.

impl From<Array> for Type

fn from(v: Array) -> Self

Converts to this type from the input type.

impl From<Class> for Type

fn from(v: Class) -> Self

Converts to this type from the input type.

impl From<Conditional> for Type

fn from(v: Conditional) -> Self

Converts to this type from the input type.

impl From<Constructor> for Type

fn from(v: Constructor) -> Self

Converts to this type from the input type.

impl From<EnumVariant> for Type

fn from(v: EnumVariant) -> Self

Converts to this type from the input type.

impl From<Freezed> for Type

fn from(v: Freezed) -> Self

Converts to this type from the input type.

impl From<Function> for Type

fn from(v: Function) -> Self

Converts to this type from the input type.

impl From<ImportType> for Type

fn from(v: ImportType) -> Self

Converts to this type from the input type.

impl From<Index> for Type

fn from(v: Index) -> Self

Converts to this type from the input type.

impl From<IndexedAccessType> for Type

fn from(v: IndexedAccessType) -> Self

Converts to this type from the input type.

impl From<InferType> for Type

fn from(v: InferType) -> Self

Converts to this type from the input type.

impl From<Instance> for Type

fn from(v: Instance) -> Self

Converts to this type from the input type.

impl From<Interface> for Type

fn from(v: Interface) -> Self

Converts to this type from the input type.

impl From<Intersection> for Type

fn from(v: Intersection) -> Self

Converts to this type from the input type.

impl From<KeywordType> for Type

fn from(v: KeywordType) -> Self

Converts to this type from the input type.

impl From<LitType> for Type

fn from(v: LitType) -> Self

Converts to this type from the input type.

impl From<Mapped> for Type

fn from(v: Mapped) -> Self

Converts to this type from the input type.

impl From<Module> for Type

fn from(v: Module) -> Self

Converts to this type from the input type.

impl From<Namespace> for Type

fn from(v: Namespace) -> Self

Converts to this type from the input type.

impl From<OptionalType> for Type

fn from(v: OptionalType) -> Self

Converts to this type from the input type.

impl From<Predicate> for Type

fn from(v: Predicate) -> Self

Converts to this type from the input type.

impl From<QueryType> for Type

fn from(v: QueryType) -> Self

Converts to this type from the input type.

impl From<Readonly> for Type

fn from(v: Readonly) -> Self

Converts to this type from the input type.

impl From<Ref> for Type

fn from(v: Ref) -> Self

Converts to this type from the input type.

impl From<RestType> for Type

fn from(v: RestType) -> Self

Converts to this type from the input type.

impl From<StaticThis> for Type

fn from(v: StaticThis) -> Self

Converts to this type from the input type.

impl From<StringMapping> for Type

fn from(v: StringMapping) -> Self

Converts to this type from the input type.

impl From<Symbol> for Type

fn from(v: Symbol) -> Self

Converts to this type from the input type.

impl From<ThisType> for Type

fn from(v: ThisType) -> Self

Converts to this type from the input type.

impl From<TplType> for Type

fn from(v: TplType) -> Self

Converts to this type from the input type.

impl From<Tuple> for Type

fn from(v: Tuple) -> Self

Converts to this type from the input type.

impl From<Type> for Box<RTsType>

fn from(t: Type) -> Self

Converts to this type from the input type.

impl From<Type> for RTsType

fn from(t: Type) -> Self

Converts to this type from the input type.

impl From<Type> for RTsTypeAnn

fn from(t: Type) -> Self

Converts to this type from the input type.

impl From<TypeLit> for Type

fn from(v: TypeLit) -> Self

Converts to this type from the input type.

impl From<TypeParam> for Type

fn from(v: TypeParam) -> Self

Converts to this type from the input type.

impl From<Union> for Type

fn from(v: Union) -> Self

Converts to this type from the input type.

impl From<Unique> for Type

fn from(v: Unique) -> Self

Converts to this type from the input type.

impl PartialEq<Type> for Type

fn eq(&self, other: &Type) -> 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 Serialize for Type

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl Spanned for Type

fn span(&self) -> Span

Get span of self.

fn span_lo(&self) -> BytePos

fn span_hi(&self) -> BytePos

impl TypeEq for Type

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

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

impl Valid for Type

fn is_valid(&self) -> bool

impl Visit<Type> for AssertCloneCheap

fn visit(&mut self, ty: &Type)

impl Visit<Type> for CheckCheapClone

fn visit(&mut self, ty: &Type)

impl<M> Visit<Type> for Finder<'_, M>where
    M: Fn(&Type) -> bool,

fn visit(&mut self, ty: &Type)

impl Visit<Type> for ValidityChecker

fn visit(&mut self, ty: &Type)

impl VisitMut<Type> for Freezer

fn visit_mut(&mut self, ty: &mut Type)

impl<M, R> VisitMut<Type> for TypeReplacer<'_, M, R>where
    M: Fn(&Type) -> bool,
    R: Fn(&mut Type) -> Option<Type>,

fn visit_mut(&mut self, ty: &mut Type)

impl<V> VisitMutWith<V> for Typewhere
    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 Typewhere
    V: ?Sized,

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

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

impl StructuralPartialEq for Type

impl Visitable for Type