Enum ezno_parser::type_references::TypeReference

pub enum TypeReference {
    Name(String, Span),
    NamespacedName(String, String, Span),
    NameWithGenericArguments(String, Vec<TypeReference>, Span),
    Union(Vec<TypeReference>),
    Intersection(Vec<TypeReference>),
    StringLiteral(String, Span),
    NumberLiteral(NumberStructure, Span),
    BooleanLiteral(bool, Span),
    ArrayLiteral(Box<TypeReference>, Span),
    FunctionLiteral {
        type_parameters: Option<Vec<GenericTypeConstraint>>,
        parameters: TypeReferenceFunctionParameters,
        return_type: Box<TypeReference>,
        type_id: TypeId,
    },
    ConstructorLiteral {
        new_keyword: Keyword<New>,
        type_parameters: Option<Vec<GenericTypeConstraint>>,
        parameters: TypeReferenceFunctionParameters,
        return_type: Box<TypeReference>,
    },
    ObjectLiteral(Vec<Decorated<InterfaceMember>>, TypeId, Span),
    TupleLiteral(Vec<TupleElement>, TypeId, Span),
    TemplateLiteral(Vec<TemplateLiteralPart<TypeReference>>, Span),
    Readonly(Box<TypeReference>, Span),
    Index(Box<TypeReference>, Box<TypeReference>, Span),
    KeyOf(Box<TypeReference>, Span),
    ParenthesizedReference(Box<TypeReference>, Span),
    Conditional {
        condition: TypeCondition,
        resolve_true: TypeConditionResult,
        resolve_false: TypeConditionResult,
        position: Span,
    },
    Decorated(Decorator, Box<Self>, Span),
    Cursor(CursorId<TypeReference>, 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<TypeReference>, Span)

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

Union(Vec<TypeReference>)

Union e.g. number | string

Intersection(Vec<TypeReference>)

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

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

FunctionLiteral

Fields

type_parameters: Option<Vec<GenericTypeConstraint>>

parameters: TypeReferenceFunctionParameters

return_type: Box<TypeReference>

type_id: TypeId

TODO…

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

ConstructorLiteral

Fields

new_keyword: Keyword<New>

type_parameters: Option<Vec<GenericTypeConstraint>>

parameters: TypeReferenceFunctionParameters

return_type: Box<TypeReference>

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

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

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

TupleLiteral(Vec<TupleElement>, TypeId, Span)

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

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

Readonly(Box<TypeReference>, Span)

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

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

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

KeyOf(Box<TypeReference>, Span)

KeyOf

ParenthesizedReference(Box<TypeReference>, Span)

For operation precedence reasons

Conditional

Fields

condition: TypeCondition

resolve_true: TypeConditionResult

resolve_false: TypeConditionResult

position: Span

Decorated(Decorator, Box<Self>, Span)

Cursor(CursorId<TypeReference>, Span)

Trait Implementations

impl ASTNode for TypeReference

fn from_reader( reader: &mut impl TokenReader<TSXToken, Span>, state: &mut ParsingState, settings: &ParseSettings ) -> ParseResult<Self>

fn to_string_from_buffer<T: ToString>( &self, buf: &mut T, settings: &ToStringSettingsAndData, 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: ParseSettings, source_id: SourceId, offset: Option<usize>, cursors: Vec<(usize, EmptyCursorId)> ) -> ParseResult<ParseOutput<Self>>

From string, with default impl to call abstract method from_reader

fn to_string(&self, settings: &ToStringSettingsAndData) -> String

Returns structure as valid string

impl Clone for TypeReference

fn clone(&self) -> TypeReference

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TypeReference

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

Formats the value using the given formatter.

impl PartialEq<TypeReference> for TypeReference

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 TypeReference

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 TypeReference

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

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

impl Eq for TypeReference

impl StructuralEq for TypeReference