Enum ezno_parser::types::type_annotations::TypeAnnotation

pub enum TypeAnnotation {
    Name(String, Span),
    NamespacedName(String, String, Span),
    NameWithGenericArguments(String, Vec<TypeAnnotation>, Span),
    Union(Vec<TypeAnnotation>),
    Intersection(Vec<TypeAnnotation>),
    StringLiteral(String, Span),
    NumberLiteral(NumberStructure, Span),
    BooleanLiteral(bool, Span),
    ArrayLiteral(Box<TypeAnnotation>, Span),
    FunctionLiteral {
        type_parameters: Option<Vec<GenericTypeConstraint>>,
        parameters: TypeAnnotationFunctionParameters,
        return_type: Box<TypeAnnotation>,
    },
    ConstructorLiteral {
        new_keyword: Keyword<New>,
        type_parameters: Option<Vec<GenericTypeConstraint>>,
        parameters: TypeAnnotationFunctionParameters,
        return_type: Box<TypeAnnotation>,
    },
    ObjectLiteral(Vec<Decorated<InterfaceMember>>, Span),
    TupleLiteral(Vec<TupleElement>, Span),
    TemplateLiteral(Vec<TemplateLiteralPart<TypeAnnotation>>, 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

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

Union e.g. number | string

Intersection(Vec<TypeAnnotation>)

Intersection e.g. c & d

StringLiteral(String, Span)

String literal e.g. "foo"

NumberLiteral(NumberStructure, 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>

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

ConstructorLiteral

Fields

new_keyword: Keyword<New>

type_parameters: Option<Vec<GenericTypeConstraint>>

parameters: TypeAnnotationFunctionParameters

return_type: Box<TypeAnnotation>

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

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

TemplateLiteral(Vec<TemplateLiteralPart<TypeAnnotation>>, 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, Span>, state: &mut ParsingState, settings: &ParseOptions ) -> ParseResult<Self>

fn to_string_from_buffer<T: ToString>( &self, buf: &mut T, settings: &ToStringOptions, depth: u8 )

fn get_position(&self) -> Cow<'_, Span>

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

fn from_string( source: String, settings: ParseOptions, source_id: SourceId, offset: Option<usize>, cursors: Vec<(usize, EmptyCursorId)> ) -> ParseResult<Self>

From string, with default impl to call abstract method from_reader

fn to_string(&self, settings: &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 PartialEq<TypeAnnotation> 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 Visitable for TypeAnnotation

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

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

impl Eq for TypeAnnotation

impl StructuralEq for TypeAnnotation