Enum TypeAnnotation

pub enum TypeAnnotation {
    CommonName(CommonTypes, Span),
    Name(TypeName, Span),
    NameWithGenericArguments(TypeName, 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 {
        parts: Vec<(String, AnnotationWithBinder)>,
        last: String,
        position: Span,
    },
    Readonly(Box<TypeAnnotation>, Span),
    Abstract(Box<TypeAnnotation>, Span),
    Index(Box<TypeAnnotation>, Box<TypeAnnotation>, Span),
    KeyOf(Box<TypeAnnotation>, Span),
    TypeOf(Box<VariableOrPropertyAccess>, Span),
    Infer {
        name: String,
        extends: Option<Box<TypeAnnotation>>,
        position: Span,
    },
    Asserts(Box<TypeAnnotation>, Span),
    Extends {
        item: Box<TypeAnnotation>,
        extends: Box<TypeAnnotation>,
        position: Span,
    },
    Is {
        reference: IsItem,
        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),
    This(Span),
    Marker(Marker<TypeAnnotation>, Span),
}

A reference to a type

Variants

CommonName(CommonTypes, Span)

Common types that don’t have to allocate a string for

Name(TypeName, Span)

A name e.g. IPost

NameWithGenericArguments(TypeName, 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

?

Fields

parts: Vec<(String, AnnotationWithBinder)>

last: String

position: Span

Readonly(Box<TypeAnnotation>, Span)

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

Abstract(Box<TypeAnnotation>, Span)

I have no idea what this is for?

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

Fields

name: String

extends: Option<Box<TypeAnnotation>>

position: 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

reference: IsItem

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)

With decorators

This(Span)

Allowed in certain positions

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

type LAST = ()

const LAST_PREFIX: Option<TSXToken> = None

const EMPTY: Option<Self> = None

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

impl PartialEq for TypeAnnotation

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

Tests for self and other values to be equal, and is used by ==.

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

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>, )