Enum TypeAnnotationKind 

pub enum TypeAnnotationKind {
    Name {
        name: Ident,
        args: Vec<TypeAnnotation>,
    },
    Qualified {
        path: Vec<Ident>,
        args: Vec<TypeAnnotation>,
    },
    StringLiteral(String),
    TemplateLiteral {
        parts: Vec<String>,
        substitutions: Vec<TypeAnnotation>,
    },
    NumberLiteral(LiteralF64),
    BigIntLiteral(String),
    BooleanLiteral(bool),
    Array(Box<TypeAnnotation>),
    Tuple(Vec<TypeAnnotation>),
    Optional(Box<TypeAnnotation>),
    Readonly(Box<TypeAnnotation>),
    Object {
        fields: Vec<TypeAnnotationField>,
        index: Option<Box<IndexSignatureAnnotation>>,
    },
    Function {
        params: Vec<TypeAnnotationField>,
        return_type: Box<TypeAnnotation>,
    },
    Union(Vec<TypeAnnotation>),
    KeyOf(Box<TypeAnnotation>),
    IndexedAccess {
        object: Box<TypeAnnotation>,
        index: Box<TypeAnnotation>,
    },
    TypeOf {
        path: Vec<Ident>,
    },
}

Variants

Name

name.span covers the identifier only; outer span includes any <…> args.

Fields

name: Ident

args: Vec<TypeAnnotation>

Qualified

Dotted type like Temporal.Instant. path.len() >= 2; last segment is the type name.

Fields

path: Vec<Ident>

args: Vec<TypeAnnotation>

StringLiteral(String)

TemplateLiteral

Fields

parts: Vec<String>

substitutions: Vec<TypeAnnotation>

NumberLiteral(LiteralF64)

Parser canonicalizes -0.0 to 0.0.

BigIntLiteral(String)

Decimal digits with a leading - when negative, as in crate::Type::BigIntLiteral.

BooleanLiteral(bool)

Array(Box<TypeAnnotation>)

Tuple(Vec<TypeAnnotation>)

Element labels ([x: number, y: number]) are documentation only, so the parser checks and drops them.

Optional(Box<TypeAnnotation>)

An omittable tuple element (T? or name?: T).

Readonly(Box<TypeAnnotation>)

readonly T[] / readonly [A, B]. The parser only builds this around an Array or Tuple operand.

Object

Fields

fields: Vec<TypeAnnotationField>

index: Option<Box<IndexSignatureAnnotation>>

Function

Function type annotation. Only the named-parameter form is accepted.

Fields

params: Vec<TypeAnnotationField>

return_type: Box<TypeAnnotation>

Union(Vec<TypeAnnotation>)

Always ≥2 members; single-element unions are unwrapped by the parser.

KeyOf(Box<TypeAnnotation>)

keyof T — the union of T’s member names as string literal types.

IndexedAccess

T[K] — the type of T’s property K.

Fields

object: Box<TypeAnnotation>

index: Box<TypeAnnotation>

TypeOf

typeof x — the type of the value x, looked up in the value namespace rather than the type namespace. path is the dotted reference, one span per segment (typeof o.k has two). Resolved eagerly.

Fields

path: Vec<Ident>

Trait Implementations

impl Clone for TypeAnnotationKind

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TypeAnnotationKind

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

Formats the value using the given formatter.

impl PartialEq for TypeAnnotationKind

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for TypeAnnotationKind