Struct ClassLikeMetadata 

#[non_exhaustive]
pub struct ClassLikeMetadata {

    pub name: Word,
    pub original_name: Word,
    pub span: Span,
    pub direct_parent_interfaces: WordSet,
    pub all_parent_interfaces: WordSet,
    pub direct_parent_class: Option<Word>,
    pub require_extends: WordSet,
    pub require_implements: WordSet,
    pub all_parent_classes: WordSet,
    pub used_traits: WordSet,
    pub trait_alias_map: WordMap<Word>,
    pub trait_visibility_map: WordMap<Visibility>,
    pub trait_final_map: WordSet,
    pub child_class_likes: Option<WordSet>,
    pub name_span: Option<Span>,
    pub kind: SymbolKind,
    pub template_types: TemplateTypes,
    pub template_readonly: WordSet,
    pub template_variance: Vec<Variance>,
    pub template_extended_offsets: WordMap<Vec<TUnion>>,
    pub template_extended_parameters: WordMap<IndexMap<Word, TUnion, RandomState>>,
    pub template_extended_parameter_paths: WordMap<Vec<IndexMap<Word, TUnion, RandomState>>>,
    pub template_type_extends_count: WordMap<usize>,
    pub template_type_implements_count: WordMap<usize>,
    pub template_type_uses_count: WordMap<usize>,
    pub methods: WordSet,
    pub pseudo_methods: WordSet,
    pub static_pseudo_methods: WordSet,
    pub declaring_method_ids: WordMap<MethodIdentifier>,
    pub appearing_method_ids: WordMap<MethodIdentifier>,
    pub inheritable_method_ids: WordMap<MethodIdentifier>,
    pub overridden_method_ids: WordMap<IndexMap<Word, MethodIdentifier, RandomState>>,
    pub properties: WordMap<PropertyMetadata>,
    pub magic_properties: WordMap<PropertyMetadata>,
    pub magic_property_ids: WordMap<Word>,
    pub appearing_property_ids: WordMap<Word>,
    pub declaring_property_ids: WordMap<Word>,
    pub inheritable_property_ids: WordMap<Word>,
    pub overridden_property_ids: WordMap<WordSet>,
    pub initialized_properties: WordSet,
    pub constants: WordMap<ClassLikeConstantMetadata>,
    pub trait_constant_ids: WordMap<Word>,
    pub enum_cases: WordMap<EnumCaseMetadata>,
    pub invalid_dependencies: WordSet,
    pub attributes: Vec<AttributeMetadata>,
    pub enum_type: Option<TAtomic>,
    pub has_sealed_methods: Option<bool>,
    pub has_sealed_properties: Option<bool>,
    pub permitted_inheritors: Option<WordSet>,
    pub issues: Vec<Issue>,
    pub attribute_flags: Option<AttributeFlags>,
    pub flags: MetadataFlags,
    pub type_aliases: WordMap<TypeMetadata>,
    pub imported_type_aliases: WordMap<(Word, Word, Span)>,
    pub mixins: Vec<TypeMetadata>,
    pub version_constraint: VersionConstraint,
}

Contains comprehensive metadata for a PHP class-like structure (class, interface, trait, enum).

Aggregates information about inheritance, traits, generics, methods, properties, constants, attributes, docblock tags, analysis flags, and more.

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.

name: Word

original_name: Word

span: Span

direct_parent_interfaces: WordSet

all_parent_interfaces: WordSet

direct_parent_class: Option<Word>

require_extends: WordSet

require_implements: WordSet

all_parent_classes: WordSet

used_traits: WordSet

trait_alias_map: WordMap<Word>

trait_visibility_map: WordMap<Visibility>

trait_final_map: WordSet

child_class_likes: Option<WordSet>

name_span: Option<Span>

kind: SymbolKind

template_types: TemplateTypes

template_readonly: WordSet

template_variance: Vec<Variance>

template_extended_offsets: WordMap<Vec<TUnion>>

template_extended_parameters: WordMap<IndexMap<Word, TUnion, RandomState>>

template_extended_parameter_paths: WordMap<Vec<IndexMap<Word, TUnion, RandomState>>>

template_type_extends_count: WordMap<usize>

template_type_implements_count: WordMap<usize>

template_type_uses_count: WordMap<usize>

methods: WordSet

pseudo_methods: WordSet

static_pseudo_methods: WordSet

declaring_method_ids: WordMap<MethodIdentifier>

appearing_method_ids: WordMap<MethodIdentifier>

inheritable_method_ids: WordMap<MethodIdentifier>

overridden_method_ids: WordMap<IndexMap<Word, MethodIdentifier, RandomState>>

properties: WordMap<PropertyMetadata>

magic_properties: WordMap<PropertyMetadata>

Magic properties documented via @property/@property-read/@property-write in this class-like’s own docblock.

These describe the external __get/__set interface and are kept separate from the real declarations in properties; which of the two governs a given access is decided at resolution time from the call site’s scope. Inherited tags are reachable through magic_property_ids, mirroring how declaring_property_ids works for real properties.

magic_property_ids: WordMap<Word>

Maps every magic property name reachable on this class-like (own or inherited) to the class-like whose docblock declares the tag. An own tag beats inherited ones; between tags inherited from unrelated parents, the first-populated parent wins (as with real property inheritance).

appearing_property_ids: WordMap<Word>

declaring_property_ids: WordMap<Word>

inheritable_property_ids: WordMap<Word>

overridden_property_ids: WordMap<WordSet>

initialized_properties: WordSet

constants: WordMap<ClassLikeConstantMetadata>

trait_constant_ids: WordMap<Word>

enum_cases: WordMap<EnumCaseMetadata>

invalid_dependencies: WordSet

attributes: Vec<AttributeMetadata>

enum_type: Option<TAtomic>

has_sealed_methods: Option<bool>

has_sealed_properties: Option<bool>

permitted_inheritors: Option<WordSet>

issues: Vec<Issue>

attribute_flags: Option<AttributeFlags>

flags: MetadataFlags

type_aliases: WordMap<TypeMetadata>

imported_type_aliases: WordMap<(Word, Word, Span)>

Imported type aliases in the form of (from_fqcn, type_name, span)

mixins: Vec<TypeMetadata>

Mixin types from @mixin annotations - these types’ methods/properties can be accessed via magic methods (__call, __get, __set, __callStatic)

version_constraint: VersionConstraint

Implementations

impl ClassLikeMetadata

pub fn has_incomplete_hierarchy(&self) -> bool

Returns whether this class-like’s inherited metadata is incomplete.

Synthetic enum contracts are materialized by the scanner and do not make an enum incomplete when their own metadata is unavailable.

pub fn incomplete_hierarchy_dependencies( &self, ) -> impl Iterator<Item = Word> + '_

Returns the unresolved dependencies that make this class-like’s inherited metadata incomplete.

Synthetic enum contracts are materialized by the scanner and are not exposed as unresolved hierarchy dependencies.

pub fn new( name: Word, original_name: Word, span: Span, name_span: Option<Span>, flags: MetadataFlags, ) -> ClassLikeMetadata

pub fn is_available_in_version(&self, version: PHPVersion) -> bool

Returns true when this class-like is available in the given PHP version.

pub fn is_available_in_version_range(&self, range: PHPVersionRange) -> bool

Returns true when this class-like is available across the entire supplied PHPVersionRange.

pub fn get_trait_alias_map(&self) -> &WordMap<Word>

Returns a reference to the map of trait method aliases.

pub fn get_template_type_names(&self) -> Vec<Word>

Returns a vector of the generic type parameter names.

pub fn get_template_type(&self, name: Word) -> Option<&GenericTemplate>

Returns type parameters for a specific generic parameter name.

pub fn get_template_name_for_index(&self, index: usize) -> Option<Word>

pub fn get_template_index_for_name(&self, name: Word) -> Option<usize>

pub fn has_parent(&self, parent: Word) -> bool

Checks if a specific parent is either a parent class or interface.

pub fn has_appearing_method(&self, method: Word) -> bool

Checks if a specific method appears in this class-like.

pub fn get_property_names(&self) -> WordSet

Returns a vector of property names.

pub fn has_appearing_property(&self, name: Word) -> bool

Checks if a specific property appears in this class-like.

pub fn take_issues(&mut self) -> Vec<Issue>

Takes ownership of the issues found for this class-like structure.

pub fn add_direct_parent_interface(&mut self, interface: Word)

Adds a single direct parent interface.

pub fn add_used_trait(&mut self, trait_name: Word) -> bool

Adds a single used trait. Returns true if the trait was not already present.

pub fn add_used_traits(&mut self, traits: impl IntoIterator<Item = Word>)

Adds multiple used traits.

pub fn add_trait_alias(&mut self, method: Word, alias: Word) -> Option<Word>

Adds or updates a single trait alias. Returns the previous original name if one existed for the alias.

pub fn add_trait_visibility( &mut self, method: Word, visibility: Visibility, ) -> Option<Visibility>

Adds or updates a single trait visibility override. Returns the previous visibility if one existed.

pub fn add_template_type(&mut self, name: Word, constraint: GenericTemplate)

Adds a single template type definition.

pub fn set_template_variance(&mut self, template_variance: Vec<Variance>)

Set the variance for the template parameters

pub fn add_template_extended_offset( &mut self, name: Word, types: Vec<TUnion>, ) -> Option<Vec<TUnion>>

Adds or replaces the offset types for a specific template parameter name.

pub fn extend_template_extended_parameters( &mut self, template_extended_parameters: WordMap<IndexMap<Word, TUnion, RandomState>>, )

Adds or replaces the resolved parameters for a specific parent FQCN.

pub fn add_template_extended_parameter( &mut self, parent_fqcn: Word, parameter_name: Word, parameter_type: TUnion, ) -> Option<TUnion>

Adds or replaces a single resolved parameter for the parent FQCN.

pub fn record_template_extended_path( &mut self, ancestor: Word, parameters: IndexMap<Word, TUnion, RandomState>, )

Records one complete parameterization of ancestor (a single inheritance path), de-duplicating against parameterizations already recorded.

pub fn add_declaring_method_id( &mut self, method: Word, declaring_method_id: MethodIdentifier, ) -> Option<MethodIdentifier>

Adds or updates the declaring method identifier for a method name.

pub fn add_appearing_method_id( &mut self, method: Word, appearing_method_id: MethodIdentifier, ) -> Option<MethodIdentifier>

Adds or updates the appearing method identifier for a method name.

pub fn add_overridden_method_parent( &mut self, method: Word, parent_method_id: MethodIdentifier, ) -> Option<MethodIdentifier>

Adds a parent method identifier to the map for an overridden method. Initializes map if needed. Returns the previous value if one existed.

pub fn add_property( &mut self, name: Word, property_metadata: PropertyMetadata, ) -> Option<PropertyMetadata>

Adds or updates a property’s metadata. Returns the previous metadata if the property existed.

pub fn add_property_metadata( &mut self, property_metadata: PropertyMetadata, ) -> Option<PropertyMetadata>

Adds or updates a property’s metadata using just the property metadata. Returns the previous metadata if the property existed.

pub fn add_declaring_property_id( &mut self, prop: Word, declaring_fqcn: Word, ) -> Option<Word>

Adds or updates the declaring class FQCN for a property name.

pub fn get_missing_required_interface<'meta>( &self, other: &'meta ClassLikeMetadata, ) -> Option<&'meta Word>

pub fn get_missing_required_extends<'meta>( &self, other: &'meta ClassLikeMetadata, ) -> Option<&'meta Word>

pub fn is_permitted_to_inherit(&self, other: &ClassLikeMetadata) -> bool

pub fn mark_as_populated(&mut self)

pub fn apply_patch( &mut self, patch: &mut ClassLikeMetadata, inherited_methods: &WordSet, )

Applies a patch to this class in place, refining member type information while leaving structure (hierarchy, override chains, initialization state, enum cases) untouched.

At most one patch targets a given symbol, so there is no accumulation to worry about. Diagnostics about the patch are appended to patch.issues, where scan-time diagnostics also live, so they flow out through take_issues. The full set of rules a patch must obey is documented in the [source] patching guide.

pub fn shrink_to_fit(&mut self)

Trait Implementations

impl Clone for ClassLikeMetadata

fn clone(&self) -> ClassLikeMetadata

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ClassLikeMetadata

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

Formats the value using the given formatter.

impl Eq for ClassLikeMetadata

impl PartialEq for ClassLikeMetadata

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ClassLikeMetadata