Enum TyRef 

pub enum TyRef {
    Void,
    Variant,
    Builtin(BuiltinId),
    Class(ClassId),
    TypedArray(ElemRef),
    TypedDict(ElemRef, ElemRef),
    Enum {
        qualified: String,
        bitfield: bool,
    },
}

An unresolved API type reference, parsed from the extension_api.json type-string grammar (Playbook §4.2). Builtin/Class are already resolved to ids at codegen time (second pass, after the name tables are built); Enum keeps its qualified string for gdscript-hir to resolve against a class’s / the global enum set.

Variants

Void

No value (void return).

Variant

The dynamic Variant top type.

Builtin(BuiltinId)

A builtin Variant type.

Class(ClassId)

An engine class.

TypedArray(ElemRef)

typedarray::T → Array[T].

TypedDict(ElemRef, ElemRef)

typeddictionary::K::V → Dictionary[K, V].

Enum

enum::Class.Enum, enum::GlobalEnum, or bitfield::… — kept qualified.

Fields

qualified: String

The dotted name as written after enum::/bitfield::.

bitfield: bool

Whether the source prefix was bitfield::.

Trait Implementations

impl Archive for TyRef

where BuiltinId: Archive, ClassId: Archive, ElemRef: Archive, String: Archive, bool: Archive,

type Archived = ArchivedTyRef

The archived representation of this type.

type Resolver = TyRefResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve( &self, resolver: <Self as Archive>::Resolver, out: Place<<Self as Archive>::Archived>, )

Creates the archived version of this value at the given position and writes it to the given output.

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

impl Clone for TyRef

fn clone(&self) -> TyRef

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TyRef

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

Formats the value using the given formatter.

impl<__D: Fallible + ?Sized> Deserialize<TyRef, __D> for Archived<TyRef>

where BuiltinId: Archive, <BuiltinId as Archive>::Archived: Deserialize<BuiltinId, __D>, ClassId: Archive, <ClassId as Archive>::Archived: Deserialize<ClassId, __D>, ElemRef: Archive, <ElemRef as Archive>::Archived: Deserialize<ElemRef, __D>, String: Archive, <String as Archive>::Archived: Deserialize<String, __D>, bool: Archive, <bool as Archive>::Archived: Deserialize<bool, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<TyRef, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl Eq for TyRef

impl PartialEq for TyRef

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<__S: Fallible + ?Sized> Serialize<__S> for TyRef

where BuiltinId: Serialize<__S>, ClassId: Serialize<__S>, ElemRef: Serialize<__S>, String: Serialize<__S>, bool: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl StructuralPartialEq for TyRef