Struct TypeMetadata 

#[non_exhaustive]
pub struct TypeMetadata {
    pub span: Span,
    pub type_union: TUnion,
    pub from_docblock: bool,
    pub inferred: bool,
}

Contains metadata associated with a specific type instance within the type system.

This struct combines the core type information (TUnion) with contextual details about how and where this type information was determined or declared in the source code or related documentation.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

span: Span

The specific location (span) in the source code or documentation that this type metadata corresponds to.

This could be:

• The span of a type annotation (e.g., : string).
• The span of an expression whose type was inferred (e.g., $x = 10 -> span of 10).
• The span of a type mentioned in a documentation block (e.g., @param int -> span of int).

type_union: TUnion

The core representation of the type itself.

from_docblock: bool

Distinguishes whether this type information originated from analyzing executable code constructs (e.g., type declarations, assignments) or from documentation blocks.

• true if the type information was extracted from a docblock comment.
• false if the type information came from actual code analysis.

inferred: bool

Indicates whether this type was explicitly declared in the source or deduced (“inferred”) by the type checker based on context.

• true if the type checker inferred this type (e.g., from a variable initialization like $x = 10;).
• false if the type was explicitly written by the user (e.g., int $x;).

Implementations

impl TypeMetadata

pub fn new(type_union: TUnion, span: Span) -> Self

Creates new TypeMetadata for an explicitly declared type from code.

This is a convenience constructor assuming the common case where a type is directly specified in the code, and wasn’t just inferred or from a docblock.

Arguments

• type_union: The core type information (TUnion).
• span: The source code location associated with this type.

Returns

A new TypeMetadata instance with is_nullable, from_docblock, and inferred set to false.

pub fn from_docblock(type_union: TUnion, span: Span) -> Self

Creates new TypeMetadata for a type extracted from a documentation block.

This constructor is used when type information is sourced from docblock comments rather than executable code.

Arguments

• type_union: The core type information (TUnion).
• span: The source code location associated with this docblock type.

Returns

A new TypeMetadata instance with from_docblock set to true and inferred set to false.

pub fn map_type_union<F>(self, f: F) -> Self

where F: FnOnce(TUnion) -> TUnion,

Creates a new TypeMetadata by applying a function to the inner TUnion.

This allows transforming the core type while preserving the surrounding metadata.

Arguments

• f: A function that takes the current TUnion and returns a new TUnion.

Returns

A new TypeMetadata instance with the transformed TUnion and the same metadata flags and span.

Trait Implementations

impl Clone for TypeMetadata

fn clone(&self) -> TypeMetadata

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TypeMetadata

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TypeMetadata

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for TypeMetadata

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 TypeMetadata

fn eq(&self, other: &TypeMetadata) -> 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 Serialize for TypeMetadata

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for TypeMetadata

impl StructuralPartialEq for TypeMetadata