Enum biome_js_syntax::AnyTsType

pub enum AnyTsType {
    TsAnyType(TsAnyType),
    TsArrayType(TsArrayType),
    TsBigintLiteralType(TsBigintLiteralType),
    TsBigintType(TsBigintType),
    TsBogusType(TsBogusType),
    TsBooleanLiteralType(TsBooleanLiteralType),
    TsBooleanType(TsBooleanType),
    TsConditionalType(TsConditionalType),
    TsConstructorType(TsConstructorType),
    TsFunctionType(TsFunctionType),
    TsImportType(TsImportType),
    TsIndexedAccessType(TsIndexedAccessType),
    TsInferType(TsInferType),
    TsIntersectionType(TsIntersectionType),
    TsMappedType(TsMappedType),
    TsNeverType(TsNeverType),
    TsNonPrimitiveType(TsNonPrimitiveType),
    TsNullLiteralType(TsNullLiteralType),
    TsNumberLiteralType(TsNumberLiteralType),
    TsNumberType(TsNumberType),
    TsObjectType(TsObjectType),
    TsParenthesizedType(TsParenthesizedType),
    TsReferenceType(TsReferenceType),
    TsStringLiteralType(TsStringLiteralType),
    TsStringType(TsStringType),
    TsSymbolType(TsSymbolType),
    TsTemplateLiteralType(TsTemplateLiteralType),
    TsThisType(TsThisType),
    TsTupleType(TsTupleType),
    TsTypeOperatorType(TsTypeOperatorType),
    TsTypeofType(TsTypeofType),
    TsUndefinedType(TsUndefinedType),
    TsUnionType(TsUnionType),
    TsUnknownType(TsUnknownType),
    TsVoidType(TsVoidType),
}

Variants

TsAnyType(TsAnyType)

TsArrayType(TsArrayType)

TsBigintLiteralType(TsBigintLiteralType)

TsBigintType(TsBigintType)

TsBogusType(TsBogusType)

TsBooleanLiteralType(TsBooleanLiteralType)

TsBooleanType(TsBooleanType)

TsConditionalType(TsConditionalType)

TsConstructorType(TsConstructorType)

TsFunctionType(TsFunctionType)

TsImportType(TsImportType)

TsIndexedAccessType(TsIndexedAccessType)

TsInferType(TsInferType)

TsIntersectionType(TsIntersectionType)

TsMappedType(TsMappedType)

TsNeverType(TsNeverType)

TsNonPrimitiveType(TsNonPrimitiveType)

TsNullLiteralType(TsNullLiteralType)

TsNumberLiteralType(TsNumberLiteralType)

TsNumberType(TsNumberType)

TsObjectType(TsObjectType)

TsParenthesizedType(TsParenthesizedType)

TsReferenceType(TsReferenceType)

TsStringLiteralType(TsStringLiteralType)

TsStringType(TsStringType)

TsSymbolType(TsSymbolType)

TsTemplateLiteralType(TsTemplateLiteralType)

TsThisType(TsThisType)

TsTupleType(TsTupleType)

TsTypeOperatorType(TsTypeOperatorType)

TsTypeofType(TsTypeofType)

TsUndefinedType(TsUndefinedType)

TsUnionType(TsUnionType)

TsUnknownType(TsUnknownType)

TsVoidType(TsVoidType)

Implementations

impl AnyTsType

pub fn as_ts_any_type(&self) -> Option<&TsAnyType>

pub fn as_ts_array_type(&self) -> Option<&TsArrayType>

pub fn as_ts_bigint_literal_type(&self) -> Option<&TsBigintLiteralType>

pub fn as_ts_bigint_type(&self) -> Option<&TsBigintType>

pub fn as_ts_bogus_type(&self) -> Option<&TsBogusType>

pub fn as_ts_boolean_literal_type(&self) -> Option<&TsBooleanLiteralType>

pub fn as_ts_boolean_type(&self) -> Option<&TsBooleanType>

pub fn as_ts_conditional_type(&self) -> Option<&TsConditionalType>

pub fn as_ts_constructor_type(&self) -> Option<&TsConstructorType>

pub fn as_ts_function_type(&self) -> Option<&TsFunctionType>

pub fn as_ts_import_type(&self) -> Option<&TsImportType>

pub fn as_ts_indexed_access_type(&self) -> Option<&TsIndexedAccessType>

pub fn as_ts_infer_type(&self) -> Option<&TsInferType>

pub fn as_ts_intersection_type(&self) -> Option<&TsIntersectionType>

pub fn as_ts_mapped_type(&self) -> Option<&TsMappedType>

pub fn as_ts_never_type(&self) -> Option<&TsNeverType>

pub fn as_ts_non_primitive_type(&self) -> Option<&TsNonPrimitiveType>

pub fn as_ts_null_literal_type(&self) -> Option<&TsNullLiteralType>

pub fn as_ts_number_literal_type(&self) -> Option<&TsNumberLiteralType>

pub fn as_ts_number_type(&self) -> Option<&TsNumberType>

pub fn as_ts_object_type(&self) -> Option<&TsObjectType>

pub fn as_ts_parenthesized_type(&self) -> Option<&TsParenthesizedType>

pub fn as_ts_reference_type(&self) -> Option<&TsReferenceType>

pub fn as_ts_string_literal_type(&self) -> Option<&TsStringLiteralType>

pub fn as_ts_string_type(&self) -> Option<&TsStringType>

pub fn as_ts_symbol_type(&self) -> Option<&TsSymbolType>

pub fn as_ts_template_literal_type(&self) -> Option<&TsTemplateLiteralType>

pub fn as_ts_this_type(&self) -> Option<&TsThisType>

pub fn as_ts_tuple_type(&self) -> Option<&TsTupleType>

pub fn as_ts_type_operator_type(&self) -> Option<&TsTypeOperatorType>

pub fn as_ts_typeof_type(&self) -> Option<&TsTypeofType>

pub fn as_ts_undefined_type(&self) -> Option<&TsUndefinedType>

pub fn as_ts_union_type(&self) -> Option<&TsUnionType>

pub fn as_ts_unknown_type(&self) -> Option<&TsUnknownType>

pub fn as_ts_void_type(&self) -> Option<&TsVoidType>

impl AnyTsType

pub fn omit_parentheses(self) -> AnyTsType

Try to extract non TsParenthesizedType from AnyTsType

pub fn is_literal_type(&self) -> bool

Returns true if self is a literal type.

Examples

use biome_js_factory::make;
use biome_js_syntax::T;
use biome_js_syntax::AnyTsType;

let boolean_literal = make::ts_boolean_literal_type(make::token(T![true]));
let bigint_literal = make::ts_bigint_literal_type(make::js_number_literal("1n")).build();
let null_literal = make::ts_null_literal_type(make::token(T![null]));
let number_literal = make::ts_number_literal_type(make::js_number_literal("1")).build();
let string_literal = make::ts_string_literal_type(make::js_string_literal("s"));
let undefined = make::ts_undefined_type(make::token(T![undefined]));

assert!(AnyTsType::TsBooleanLiteralType(boolean_literal).is_literal_type());
assert!(AnyTsType::TsBigintLiteralType(bigint_literal).is_literal_type());
assert!(AnyTsType::TsNullLiteralType(null_literal).is_literal_type());
assert!(AnyTsType::TsNumberLiteralType(number_literal).is_literal_type());
assert!(AnyTsType::TsStringLiteralType(string_literal).is_literal_type());
assert!(AnyTsType::TsUndefinedType(undefined).is_literal_type());

pub fn is_primitive_type(&self) -> bool

Returns true if self is a primitive type.

Examples

use biome_js_factory::make;
use biome_js_syntax::T;
use biome_js_syntax::AnyTsType;

let boolean = make::ts_boolean_type(make::token(T![boolean]));
let bigint = make::ts_bigint_type(make::token(T![bigint]));
let number = make::ts_number_type(make::token(T![number]));
let string = make::ts_string_type(make::token(T![string]));

assert!(AnyTsType::TsBooleanType(boolean).is_primitive_type());
assert!(AnyTsType::TsBigintType(bigint).is_primitive_type());
assert!(AnyTsType::TsNumberType(number).is_primitive_type());
assert!(AnyTsType::TsStringType(string).is_primitive_type());

pub fn in_conditional_true_type(&self) -> bool

Checks if self stands as the true_type of a conditional type in Typescript.

Examples

use biome_js_factory::make;
use biome_js_syntax::T;
use biome_js_syntax::AnyTsType;

let check_type = AnyTsType::TsNumberType(make::ts_number_type(make::token(T![number])));
let extends_type = AnyTsType::TsNumberType(make::ts_number_type(make::token(T![number])));
let true_type = AnyTsType::TsNumberType(make::ts_number_type(make::token(T![number])));
let false_type = AnyTsType::TsNumberType(make::ts_number_type(make::token(T![number])));

let conditional = make::ts_conditional_type(
    check_type,
    make::token(T![extends]),
    extends_type,
    make::token(T![?]),
    true_type,
    make::token(T![:]),
    false_type,
);

assert!(!conditional.check_type().unwrap().in_conditional_true_type());
assert!(!conditional.extends_type().unwrap().in_conditional_true_type());
assert!(conditional.true_type().unwrap().in_conditional_true_type());
assert!(!conditional.false_type().unwrap().in_conditional_true_type());

Trait Implementations

impl AstNode for AnyTsType

type Language = JsLanguage

const KIND_SET: SyntaxKindSet<Language> = _

fn can_cast(kind: SyntaxKind) -> bool

Returns true if a node with the given kind can be cased to this AST node.

fn cast(syntax: SyntaxNode) -> Option<Self>

Tries to cast the passed syntax node to this AST node.

fn syntax(&self) -> &SyntaxNode

Returns the underlying syntax node.

fn into_syntax(self) -> SyntaxNode

Returns the underlying syntax node.

fn cast_ref(syntax: &SyntaxNode<Self::Language>) -> Option<Self>

where Self: Sized,

Takes a reference of a syntax node and tries to cast it to this AST node.

fn try_cast( syntax: SyntaxNode<Self::Language> ) -> Result<Self, SyntaxNode<Self::Language>>

Tries to cast the passed syntax node to this AST node.

fn try_cast_node<T>(node: T) -> Result<Self, T>

where T: AstNode<Language = Self::Language>,

Tries to cast the AST node into this node.

fn unwrap_cast(syntax: SyntaxNode<Self::Language>) -> Self

where Self: Sized,

Cast this node to this AST node

fn text(&self) -> String

Returns the string representation of this node without the leading and trailing trivia

fn range(&self) -> TextRange

fn clone_subtree(&self) -> Self

where Self: Sized,

fn parent<T>(&self) -> Option<T>

where T: AstNode<Language = Self::Language>,

fn with_leading_trivia_pieces<I>(self, trivia: I) -> Option<Self>

where I: IntoIterator<Item = SyntaxTriviaPiece<Self::Language>>, <I as IntoIterator>::IntoIter: ExactSizeIterator,

Return a new version of this node with the leading trivia of its first token replaced with trivia.

fn with_trailing_trivia_pieces<I>(self, trivia: I) -> Option<Self>

where I: IntoIterator<Item = SyntaxTriviaPiece<Self::Language>>, <I as IntoIterator>::IntoIter: ExactSizeIterator,

Return a new version of this node with the trailing trivia of its last token replaced with trivia.

fn prepend_trivia_pieces<I>(self, trivia: I) -> Option<Self>

where I: IntoIterator<Item = SyntaxTriviaPiece<Self::Language>>, <I as IntoIterator>::IntoIter: ExactSizeIterator,

fn append_trivia_pieces<I>(self, trivia: I) -> Option<Self>

where I: IntoIterator<Item = SyntaxTriviaPiece<Self::Language>>, <I as IntoIterator>::IntoIter: ExactSizeIterator,

fn trim_trivia(self) -> Option<Self>

Return a new version of this node without leading and trailing newlines and whitespaces.

fn trim_leading_trivia(self) -> Option<Self>

Return a new version of this node without leading newlines and whitespaces.

fn trim_trailing_trivia(self) -> Option<Self>

Return a new version of this node without trailing newlines and whitespaces.

impl Clone for AnyTsType

fn clone(&self) -> AnyTsType

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AnyTsType

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

Formats the value using the given formatter.

impl Display for AnyTsType

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

Formats the value using the given formatter.

impl From<AnyTsType> for JsSyntaxElement

fn from(n: AnyTsType) -> SyntaxElement

Converts to this type from the input type.

impl From<AnyTsType> for JsSyntaxNode

fn from(n: AnyTsType) -> SyntaxNode

Converts to this type from the input type.

impl From<TsAnyType> for AnyTsType

fn from(node: TsAnyType) -> AnyTsType

Converts to this type from the input type.

impl From<TsArrayType> for AnyTsType

fn from(node: TsArrayType) -> AnyTsType

Converts to this type from the input type.

impl From<TsBigintLiteralType> for AnyTsType

fn from(node: TsBigintLiteralType) -> AnyTsType

Converts to this type from the input type.

impl From<TsBigintType> for AnyTsType

fn from(node: TsBigintType) -> AnyTsType

Converts to this type from the input type.

impl From<TsBogusType> for AnyTsType

fn from(node: TsBogusType) -> AnyTsType

Converts to this type from the input type.

impl From<TsBooleanLiteralType> for AnyTsType

fn from(node: TsBooleanLiteralType) -> AnyTsType

Converts to this type from the input type.

impl From<TsBooleanType> for AnyTsType

fn from(node: TsBooleanType) -> AnyTsType

Converts to this type from the input type.

impl From<TsConditionalType> for AnyTsType

fn from(node: TsConditionalType) -> AnyTsType

Converts to this type from the input type.

impl From<TsConstructorType> for AnyTsType

fn from(node: TsConstructorType) -> AnyTsType

Converts to this type from the input type.

impl From<TsFunctionType> for AnyTsType

fn from(node: TsFunctionType) -> AnyTsType

Converts to this type from the input type.

impl From<TsImportType> for AnyTsType

fn from(node: TsImportType) -> AnyTsType

Converts to this type from the input type.

impl From<TsIndexedAccessType> for AnyTsType

fn from(node: TsIndexedAccessType) -> AnyTsType

Converts to this type from the input type.

impl From<TsInferType> for AnyTsType

fn from(node: TsInferType) -> AnyTsType

Converts to this type from the input type.

impl From<TsIntersectionType> for AnyTsType

fn from(node: TsIntersectionType) -> AnyTsType

Converts to this type from the input type.

impl From<TsMappedType> for AnyTsType

fn from(node: TsMappedType) -> AnyTsType

Converts to this type from the input type.

impl From<TsNeverType> for AnyTsType

fn from(node: TsNeverType) -> AnyTsType

Converts to this type from the input type.

impl From<TsNonPrimitiveType> for AnyTsType

fn from(node: TsNonPrimitiveType) -> AnyTsType

Converts to this type from the input type.

impl From<TsNullLiteralType> for AnyTsType

fn from(node: TsNullLiteralType) -> AnyTsType

Converts to this type from the input type.

impl From<TsNumberLiteralType> for AnyTsType

fn from(node: TsNumberLiteralType) -> AnyTsType

Converts to this type from the input type.

impl From<TsNumberType> for AnyTsType

fn from(node: TsNumberType) -> AnyTsType

Converts to this type from the input type.

impl From<TsObjectType> for AnyTsType

fn from(node: TsObjectType) -> AnyTsType

Converts to this type from the input type.

impl From<TsParenthesizedType> for AnyTsType

fn from(node: TsParenthesizedType) -> AnyTsType

Converts to this type from the input type.

impl From<TsReferenceType> for AnyTsType

fn from(node: TsReferenceType) -> AnyTsType

Converts to this type from the input type.

impl From<TsStringLiteralType> for AnyTsType

fn from(node: TsStringLiteralType) -> AnyTsType

Converts to this type from the input type.

impl From<TsStringType> for AnyTsType

fn from(node: TsStringType) -> AnyTsType

Converts to this type from the input type.

impl From<TsSymbolType> for AnyTsType

fn from(node: TsSymbolType) -> AnyTsType

Converts to this type from the input type.

impl From<TsTemplateLiteralType> for AnyTsType

fn from(node: TsTemplateLiteralType) -> AnyTsType

Converts to this type from the input type.

impl From<TsThisType> for AnyTsType

fn from(node: TsThisType) -> AnyTsType

Converts to this type from the input type.

impl From<TsTupleType> for AnyTsType

fn from(node: TsTupleType) -> AnyTsType

Converts to this type from the input type.

impl From<TsTypeOperatorType> for AnyTsType

fn from(node: TsTypeOperatorType) -> AnyTsType

Converts to this type from the input type.

impl From<TsTypeofType> for AnyTsType

fn from(node: TsTypeofType) -> AnyTsType

Converts to this type from the input type.

impl From<TsUndefinedType> for AnyTsType

fn from(node: TsUndefinedType) -> AnyTsType

Converts to this type from the input type.

impl From<TsUnionType> for AnyTsType

fn from(node: TsUnionType) -> AnyTsType

Converts to this type from the input type.

impl From<TsUnknownType> for AnyTsType

fn from(node: TsUnknownType) -> AnyTsType

Converts to this type from the input type.

impl From<TsVoidType> for AnyTsType

fn from(node: TsVoidType) -> AnyTsType

Converts to this type from the input type.

impl Hash for AnyTsType

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for AnyTsType

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

impl StructuralPartialEq for AnyTsType