Enum ezno_parser::types::type_annotations::TypeAnnotation

pub enum TypeAnnotation {
    Name(String, Span),
    CommonName(CommonTypes, Span),
    This(Span),
    NamespacedName(String, String, Span),
    NameWithGenericArguments(String, Vec<TypeAnnotation>, Span),
    Union(Vec<TypeAnnotation>, Span),
    Intersection(Vec<TypeAnnotation>, Span),
    StringLiteral(String, Quoted, Span),
    NumberLiteral(NumberRepresentation, Span),
    BooleanLiteral(bool, Span),
    ArrayLiteral(Box<TypeAnnotation>, Span),
    FunctionLiteral {
        type_parameters: Option<Vec<TypeParameter>>,
        parameters: TypeAnnotationFunctionParameters,
        return_type: Box<TypeAnnotation>,
        position: Span,
    },
    ConstructorLiteral {
        type_parameters: Option<Vec<TypeParameter>>,
        parameters: TypeAnnotationFunctionParameters,
        return_type: Box<TypeAnnotation>,
        position: Span,
    },
    ObjectLiteral(Vec<WithComment<Decorated<InterfaceMember>>>, Span),
    TupleLiteral(Vec<TupleLiteralElement>, Span),
    TemplateLiteral(Vec<TemplateLiteralPart<AnnotationWithBinder>>, Span),
    Readonly(Box<TypeAnnotation>, Span),
    Index(Box<TypeAnnotation>, Box<TypeAnnotation>, Span),
    KeyOf(Box<TypeAnnotation>, Span),
    TypeOf(Box<VariableOrPropertyAccess>, Span),
    Infer(String, Span),
    Asserts(Box<TypeAnnotation>, Span),
    Extends {
        item: Box<TypeAnnotation>,
        extends: Box<TypeAnnotation>,
        position: Span,
    },
    Is {
        item: Box<TypeAnnotation>,
        is: Box<TypeAnnotation>,
        position: Span,
    },
    Conditional {
        condition: Box<TypeAnnotation>,
        resolve_true: Box<TypeAnnotation>,
        resolve_false: Box<TypeAnnotation>,
        position: Span,
    },
    Symbol {
        unique: bool,
        name: Option<String>,
        position: Span,
    },
    ParenthesizedReference(Box<TypeAnnotation>, Span),
    Decorated(Decorator, Box<Self>, Span),
    Marker(Marker<TypeAnnotation>, Span),
}

A reference to a type

Variants

Name(String, Span)

A name e.g. IPost

CommonName(CommonTypes, Span)

This(Span)

WIP

NamespacedName(String, String, Span)

A name e.g. Intl.IPost. TODO can there be more than 2 members

NameWithGenericArguments(String, Vec<TypeAnnotation>, Span)

A name with generics e.g. Array<number>

Union(Vec<TypeAnnotation>, Span)

Union e.g. number | string

Intersection(Vec<TypeAnnotation>, Span)

Intersection e.g. c & d

StringLiteral(String, Quoted, Span)

String literal e.g. "foo"

NumberLiteral(NumberRepresentation, Span)

Number literal e.g. 45

BooleanLiteral(bool, Span)

Boolean literal e.g. true

ArrayLiteral(Box<TypeAnnotation>, Span)

Array literal e.g. string[]. This is syntactic sugar for Array with type arguments. This is not the same as a TypeAnnotation::TupleLiteral

FunctionLiteral

Function literal e.g. (x: string) => string

Fields

type_parameters: Option<Vec<TypeParameter>>

parameters: TypeAnnotationFunctionParameters

return_type: Box<TypeAnnotation>

position: Span

ConstructorLiteral

Construction literal e.g. new (x: string) => string

Fields

type_parameters: Option<Vec<TypeParameter>>

parameters: TypeAnnotationFunctionParameters

return_type: Box<TypeAnnotation>

position: Span

ObjectLiteral(Vec<WithComment<Decorated<InterfaceMember>>>, Span)

Object literal e.g. { y: string }

TupleLiteral(Vec<TupleLiteralElement>, Span)

Tuple literal e.g. [number, x: string]

TemplateLiteral(Vec<TemplateLiteralPart<AnnotationWithBinder>>, Span)

?

Readonly(Box<TypeAnnotation>, Span)

Declares type as not assignable (still has interior mutability) e.g. readonly number

Index(Box<TypeAnnotation>, Box<TypeAnnotation>, Span)

Declares type as being union type of all property types e.g. T[K]

KeyOf(Box<TypeAnnotation>, Span)

KeyOf

TypeOf(Box<VariableOrPropertyAccess>, Span)

Infer(String, Span)

Asserts(Box<TypeAnnotation>, Span)

This is technically a special return type in TypeScript but we can make a superset behavior here

Extends

Fields

item: Box<TypeAnnotation>

extends: Box<TypeAnnotation>

position: Span

Is

Fields

item: Box<TypeAnnotation>

is: Box<TypeAnnotation>

position: Span

Conditional

Fields

condition: Box<TypeAnnotation>

resolve_true: Box<TypeAnnotation>

resolve_false: Box<TypeAnnotation>

position: Span

Symbol

Fields

unique: bool

TODO unsure

name: Option<String>

position: Span

ParenthesizedReference(Box<TypeAnnotation>, Span)

For operation precedence reasons

Decorated(Decorator, Box<Self>, Span)

Marker(Marker<TypeAnnotation>, Span)

Trait Implementations

impl ASTNode for TypeAnnotation

fn from_reader( reader: &mut impl TokenReader<TSXToken, TokenStart>, state: &mut ParsingState, options: &ParseOptions ) -> ParseResult<Self>

fn to_string_from_buffer<T: ToString>( &self, buf: &mut T, options: &ToStringOptions, local: LocalToStringInformation )

fn get_position(&self) -> Span

Returns position of node as span AS IT WAS PARSED. May be Span::NULL if AST was doesn’t match anything in source

fn from_string(script: String, options: ParseOptions) -> ParseResult<Self>

From string, with default impl to call abstract method from_reader

fn from_string_with_options( script: String, options: ParseOptions, offset: Option<u32> ) -> ParseResult<(Self, ParsingState)>

fn to_string(&self, options: &ToStringOptions) -> String

Returns structure as valid string

impl Clone for TypeAnnotation

fn clone(&self) -> TypeAnnotation

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TypeAnnotation

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

Formats the value using the given formatter.

impl GetFieldByType<BaseSpan<()>> for TypeAnnotation

fn get(&self) -> &Span

Get the value of a field that has type T

impl ListItem for TypeAnnotation

const EMPTY: Option<Self> = None

fn allow_comma_after(&self) -> bool

impl PartialEq for TypeAnnotation

fn eq(&self, other: &Self) -> 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 SelfRustTokenize for TypeAnnotation

fn append_to_token_stream(&self, token_stream: &mut TokenStream)

fn to_tokens(&self) -> TokenStream

Returns the tokens used to construct self

impl Serialize for TypeAnnotation

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Visitable for TypeAnnotation

fn visit<TData>( &self, _visitors: &mut (impl VisitorReceiver<TData> + ?Sized), _data: &mut TData, _options: &VisitOptions, _chain: &mut Annex<'_, Chain> )

fn visit_mut<TData>( &mut self, _visitors: &mut (impl VisitorMutReceiver<TData> + ?Sized), _data: &mut TData, _options: &VisitOptions, _chain: &mut Annex<'_, Chain> )