Enum ezno_parser::types::type_annotations::TypeAnnotation

pub enum TypeAnnotation {
    Name(String, Span),
    CommonName(CommonTypes, 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<GenericTypeConstraint>>,
        parameters: TypeAnnotationFunctionParameters,
        return_type: Box<TypeAnnotation>,
        position: Span,
    },
    ConstructorLiteral {
        new_keyword: Keyword<New>,
        type_parameters: Option<Vec<GenericTypeConstraint>>,
        parameters: TypeAnnotationFunctionParameters,
        return_type: Box<TypeAnnotation>,
        position: Span,
    },
    ObjectLiteral(Vec<Decorated<InterfaceMember>>, Span),
    TupleLiteral(Vec<(SpreadKind, AnnotationWithBinder)>, Span),
    TemplateLiteral(Vec<TemplateLiteralPart<AnnotationWithBinder>>, Span),
    Readonly(Box<TypeAnnotation>, Span),
    Index(Box<TypeAnnotation>, Box<TypeAnnotation>, Span),
    KeyOf(Box<TypeAnnotation>, Span),
    ParenthesizedReference(Box<TypeAnnotation>, Span),
    Conditional {
        condition: TypeCondition,
        resolve_true: TypeConditionResult,
        resolve_false: TypeConditionResult,
        position: Span,
    },
    Decorated(Decorator, Box<Self>, Span),
    Cursor(CursorId<TypeAnnotation>, Span),
}

A reference to a type

TODO need to figure out what [TypeId] is used for here and where it might be useful for the checker

Variants

Name(String, Span)

A name e.g. IPost

CommonName(CommonTypes, Span)

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

Fields

type_parameters: Option<Vec<GenericTypeConstraint>>

parameters: TypeAnnotationFunctionParameters

return_type: Box<TypeAnnotation>

position: Span

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

ConstructorLiteral

Fields

new_keyword: Keyword<New>

type_parameters: Option<Vec<GenericTypeConstraint>>

parameters: TypeAnnotationFunctionParameters

return_type: Box<TypeAnnotation>

position: Span

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

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

Object literal e.g. { y: string } Here [TypeId] refers to the type it declares

TupleLiteral(Vec<(SpreadKind, AnnotationWithBinder)>, 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

ParenthesizedReference(Box<TypeAnnotation>, Span)

For operation precedence reasons

Conditional

Fields

condition: TypeCondition

resolve_true: TypeConditionResult

resolve_false: TypeConditionResult

position: Span

Decorated(Decorator, Box<Self>, Span)

Cursor(CursorId<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, depth: u8 )

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, source: SourceId, offset: Option<u32> ) -> ParseResult<Self>

From string, with default impl to call abstract method from_reader

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 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: &VisitSettings, _chain: &mut Annex<'_, Chain> )

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

impl Eq for TypeAnnotation

impl StructuralEq for TypeAnnotation