Struct Type 

pub struct Type {
    pub types: AtomicVec,
    pub possibly_undefined: bool,
    pub from_docblock: bool,
}

Fields

types: AtomicVec

possibly_undefined: bool

The variable holding this type may not be initialized at this point.

from_docblock: bool

This type originated from a docblock annotation rather than inference.

Implementations

impl Type

pub fn empty() -> Self

pub fn single(atomic: Atomic) -> Self

pub fn mixed() -> Self

pub fn void() -> Self

pub fn never() -> Self

pub fn null() -> Self

pub fn bool() -> Self

pub fn int() -> Self

pub fn float() -> Self

pub fn string() -> Self

pub fn nullable(atomic: Atomic) -> Self

T|null

pub fn from_vec(atomics: Vec<Atomic>) -> Self

Build a union from multiple atomics, de-duplicating on the fly.

pub fn is_empty(&self) -> bool

pub fn is_single(&self) -> bool

pub fn is_nullable(&self) -> bool

pub fn is_mixed(&self) -> bool

pub fn is_never(&self) -> bool

pub fn clone_validity(&self) -> CloneValidity

Classify this type for clone validity. Recurses into template-param bounds (like Type::is_mixed). Callers handle mixed separately.

pub fn is_void(&self) -> bool

pub fn can_be_falsy(&self) -> bool

pub fn can_be_truthy(&self) -> bool

pub fn contains<F: Fn(&Atomic) -> bool>(&self, f: F) -> bool

pub fn has_named_object(&self, fqcn: &str) -> bool

pub fn add_type(&mut self, atomic: Atomic)

Add an atomic to this union, skipping duplicates. Subsumption rules: anything ⊆ TMixed; TLiteralInt ⊆ TInt; etc.

pub fn remove_null(&self) -> Type

Remove null from the union (e.g. after a null check).

pub fn remove_false(&self) -> Type

Remove false from the union.

pub fn core_type(&self) -> Type

Remove both null and false from the union (core type without nullable/falsy variants).

pub fn narrow_to_truthy(&self) -> Type

Keep only truthy atomics (e.g. after if ($x)).

pub fn narrow_to_falsy(&self) -> Type

Keep only falsy atomics (e.g. after if (!$x)).

pub fn narrow_instanceof(&self, class: &str) -> Type

Narrow this type as if $x instanceof ClassName is true.

The instanceof check guarantees the value IS an instance of class, so we replace any object / mixed constituents with the specific named object. Scalar constituents are dropped (they can never satisfy instanceof).

pub fn narrow_to_string(&self) -> Type

Narrow as if is_string($x) is true.

pub fn narrow_to_int(&self) -> Type

Narrow as if is_int($x) is true.

pub fn narrow_to_float(&self) -> Type

Narrow as if is_float($x) is true.

pub fn narrow_to_bool(&self) -> Type

Narrow as if is_bool($x) is true.

pub fn narrow_to_null(&self) -> Type

Narrow as if is_null($x) is true.

pub fn narrow_to_array(&self) -> Type

Narrow as if is_array($x) is true.

pub fn narrow_to_object(&self) -> Type

Narrow as if is_object($x) is true.

pub fn narrow_to_callable(&self) -> Type

Narrow as if is_callable($x) is true.

pub fn narrow_to_scalar(&self) -> Type

Narrow as if is_scalar($x) is true (int | string | float | bool).

pub fn narrow_to_iterable(&self) -> Type

Narrow as if is_iterable($x) is true (array | Traversable). For simplicity, this narrows to arrays or objects (can’t easily verify interfaces).

pub fn narrow_to_countable(&self) -> Type

Narrow as if is_countable($x) is true (array | Countable). For simplicity, this narrows to arrays or objects (can’t easily verify Countable interface).

pub fn narrow_to_resource(&self) -> Type

Narrow as if is_resource($x) is true. Note: No TResource atomic type exists in the type system; this is a no-op. Resources are declining in modern PHP and not actively tracked.

pub fn merge(a: &Type, b: &Type) -> Type

Merge two unions at a branch join point (e.g. after if/else). The result is the union of all types in both.

pub fn merge_with(&mut self, other: &Type)

Merge other into self in-place (avoids cloning self).

pub fn intersect_with(&self, other: &Type) -> Type

Intersect with another union: keep only types present in other, widening where self contains mixed (which is compatible with everything). Used for match-arm subject narrowing.

pub fn substitute_templates(&self, bindings: &FxHashMap<Name, Type>) -> Type

Replace template param references with their resolved types.

pub fn resolve_conditional_returns<F>(self, lookup: F) -> Type

where F: Fn(&str) -> Option<Type>,

Resolves TConditional atoms whose discriminator is known at the call site.

lookup(param_name) returns the call-site argument type for the named parameter, or None if the argument is not available. Handles is null, is string, and is array conditions; other condition types pass through unchanged.

pub fn is_subtype_structural(&self, other: &Type) -> bool

Returns true if every atomic in self is a subtype of some atomic in other, using only structural rules — no extends / implements walk.

Two distinct user-defined classes are never related here, even when one extends the other. Within mir-analyzer, when a db is in scope, prefer crate::subtype::is_subtype(db, sub, sup) which layers inheritance resolution on top of this check.

pub fn possibly_undefined(self) -> Self

Mark this union as possibly-undefined and return it.

pub fn from_docblock(self) -> Self

Mark this union as coming from a docblock annotation.

Trait Implementations

impl Clone for Type

fn clone(&self) -> Type

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Type

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Type

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Type

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

Formats the value using the given formatter.

impl Eq for Type

impl Hash for Type

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 Type

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Type