Enum Ty 

pub enum Ty {
    Builtin(BuiltinId),
    Object(ClassId),
    ScriptRef(ScriptRefId),
    InnerClass(InnerClassRef),
    Array(Box<Ty>),
    Tuple(Vec<Ty>),
    Dict(Box<Ty>, Box<Ty>),
    Enum(EnumRef),
    Signal(Option<SignalSigId>),
    Callable,
    Void,
    Variant,
    Unknown,
    Error,
}

A Phase-2 type. Clone not Copy (the Boxes in Array/Dict).

Variants

Builtin(BuiltinId)

A builtin Variant type (int, float, String, Vector2, …).

Object(ClassId)

An engine class instance, this file’s own class, or an inner class.

ScriptRef(ScriptRefId)

Another script, opaque in Phase 2 (the seam yields Unknown instead).

InnerClass(InnerClassRef)

An inner class Name: declared in this (or another) script file — both the class value and an instance of it (collapsed, like ScriptRef). Members resolve against the inner class’s own item-tree + its extends chain.

Array(Box<Ty>)

Array[T]; a bare Array is Array(Box::new(Ty::Variant)).

Tuple(Vec<Ty>)

A SYNTHESIZED fixed-shape array with per-position element types ([Variant, Callable] — a React-style hook’s [value, setter] pair). GDScript has no tuple syntax, so no annotation ever resolves to this; it only arises from the ## @return-tuple(...) doc-tag (BUG A3). At runtime it IS an untyped Array: assignability widens it to Array[Variant], and label renders it as the array it is — the positional info exists solely so a constant index (pair[1]) projects the element’s real type.

Dict(Box<Ty>, Box<Ty>)

Dictionary[K, V]; a bare Dictionary is Dict(Variant, Variant).

Enum(EnumRef)

An enum type (an enum value is assignable to int).

Signal(Option<SignalSigId>)

A Signal value.

Callable

A Callable value.

Void

No value (void).

Variant

The gradual top / escape hatch (≈ engine VARIANT ≈ Pyright Any).

Unknown

The Phase-3 cross-file seam marker — distinct from Variant. Never warns, never appears in hover, never cascades a diagnostic.

Error

An already-reported error; suppresses downstream diagnostics.

Implementations

impl Ty

pub fn array_of_variant() -> Self

A bare Array (Array[Variant]).

pub fn dict_of_variant() -> Self

A bare Dictionary (Dictionary[Variant, Variant]).

pub fn widen_tuple(&self) -> Ty

The array a Ty::Tuple IS at runtime (Array[Variant]) — the widening every non-positional consumer (assignability, labels, iteration) sees. Identity otherwise.

pub fn is_variant(&self) -> bool

Whether this is the gradual top Variant.

pub fn is_unknown(&self) -> bool

Whether this is the cross-file seam marker.

pub fn is_error(&self) -> bool

Whether this is the already-reported error marker.

pub fn is_uninformative(&self) -> bool

Whether a diagnostic should be suppressed because this type carries no information (Variant/Unknown/Error) — the receivers on which UNSAFE_* etc. must never fire.

pub fn label(&self, api: &EngineApi) -> Option<String>

A display label for hover / inlay hints, or None when the type is Unknown (elided — the Phase-3 seam) so we never render a placeholder.

Trait Implementations

impl Clone for Ty

fn clone(&self) -> Ty

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Ty

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

Formats the value using the given formatter.

impl Eq for Ty

impl Hash for Ty

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Ty

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Ty