Struct CodebaseMetadata 

#[non_exhaustive]
pub struct CodebaseMetadata {

    pub infer_types_from_usage: bool,
    pub class_likes: WordMap<ClassLikeMetadata>,
    pub function_likes: HashMap<(Word, Word), FunctionLikeMetadata>,
    pub symbols: Symbols,
    pub constants: WordMap<ConstantMetadata>,
    pub all_class_like_descendants: WordMap<WordSet>,
    pub direct_classlike_descendants: WordMap<WordSet>,
    pub safe_symbols: WordSet,
    pub safe_symbol_members: HashSet<(Word, Word)>,
    pub file_signatures: HashMap<FileId, FileSignature>,
    pub patch_class_likes: WordMap<ClassLikeMetadata>,
    pub patch_function_likes: HashMap<(Word, Word), FunctionLikeMetadata>,
    pub patch_constants: WordMap<ConstantMetadata>,
}

Holds all analyzed information about the symbols, structures, and relationships within a codebase.

This acts as the central repository for metadata gathered during static analysis, including details about classes, interfaces, traits, enums, functions, constants, their members, inheritance, dependencies, and associated types.

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.

infer_types_from_usage: bool

Configuration flag: Should types be inferred based on usage patterns?

class_likes: WordMap<ClassLikeMetadata>

Map from class-like FQCN (Word) to its detailed metadata (ClassLikeMetadata).

function_likes: HashMap<(Word, Word), FunctionLikeMetadata>

Map from a function/method identifier tuple (scope_id, function_id) to its metadata (FunctionLikeMetadata). scope_id is the FQCN for methods or often Word::empty() for global functions.

symbols: Symbols

Stores the kind (Class, Interface, etc.) for every known symbol FQCN.

constants: WordMap<ConstantMetadata>

Map from global constant FQN (Word) to its metadata (ConstantMetadata).

all_class_like_descendants: WordMap<WordSet>

Map from class/interface FQCN to the set of all its descendants (recursive).

direct_classlike_descendants: WordMap<WordSet>

Map from class/interface FQCN to the set of its direct descendants (children).

safe_symbols: WordSet

Set of symbols (FQCNs) that are considered safe/validated.

safe_symbol_members: HashSet<(Word, Word)>

Set of specific members (SymbolFQCN, MemberName) that are considered safe/validated.

file_signatures: HashMap<FileId, FileSignature>

Each FileSignature contains a hierarchical tree of DefSignatureNode representing top-level symbols (classes, functions, constants) and their nested members (methods, properties).

patch_class_likes: WordMap<ClassLikeMetadata>

Per-patch class-like metadata, keyed by FQCN.

Vendor and patch files declare symbols under the same FQCN, so patches cannot share the class_likes map. At most one patch may target a given symbol; a second patch for the same FQCN is diagnosed as a PatchDuplicateTarget rather than silently overwriting the first. Entries here are folded into class_likes by apply_patches_pass.

patch_function_likes: HashMap<(Word, Word), FunctionLikeMetadata>

Per-patch function-like metadata, keyed by (scope, name).

The key matches the existing function_likes key shape: the FQCN for methods, empty_word() for free functions.

patch_constants: WordMap<ConstantMetadata>

Per-patch constant metadata, keyed by FQN.

Implementations

impl CodebaseMetadata

pub fn new() -> Self

Creates a new, empty CodebaseMetadata with default values.

pub fn class_exists(&self, name: &[u8]) -> bool

Checks if a class exists in the codebase (case-insensitive).

Examples

if codebase.class_exists("MyClass") {
    // MyClass is a class
}

pub fn interface_exists(&self, name: &[u8]) -> bool

Checks if an interface exists in the codebase (case-insensitive).

pub fn trait_exists(&self, name: &[u8]) -> bool

Checks if a trait exists in the codebase (case-insensitive).

pub fn enum_exists(&self, name: &[u8]) -> bool

Checks if an enum exists in the codebase (case-insensitive).

pub fn class_like_exists(&self, name: &[u8]) -> bool

Checks if a class-like (class, interface, trait, or enum) exists (case-insensitive).

pub fn namespace_exists(&self, name: &[u8]) -> bool

Checks if a namespace exists (case-insensitive).

pub fn class_or_trait_exists(&self, name: &[u8]) -> bool

Checks if a class or trait exists in the codebase (case-insensitive).

pub fn class_or_interface_exists(&self, name: &[u8]) -> bool

Checks if a class or interface exists in the codebase (case-insensitive).

pub fn method_identifier_exists(&self, method_id: &MethodIdentifier) -> bool

Checks if a method identifier exists in the codebase.

pub fn function_exists(&self, name: &[u8]) -> bool

Checks if a global function exists in the codebase (case-insensitive).

pub fn constant_exists(&self, name: &[u8]) -> bool

Checks if a global constant exists in the codebase. The namespace part is case-insensitive, but the constant name is case-sensitive.

pub fn method_exists(&self, class: &[u8], method: &[u8]) -> bool

Checks if a method exists on a class-like, including inherited methods (case-insensitive).

pub fn property_exists(&self, class: &[u8], property: &[u8]) -> bool

Checks if a property exists on a class-like, including inherited properties. Class name is case-insensitive, property name is case-sensitive. Sees real declarations only; magic @property* tags are reachable through ClassLikeMetadata::magic_property_ids.

pub fn magic_property_exists(&self, class: &[u8], property: &[u8]) -> bool

Checks if a magic @property* exists on a class-like, including inherited tags. Class name is case-insensitive, property name is case-sensitive.

pub fn class_constant_exists(&self, class: &[u8], constant: &[u8]) -> bool

Checks if a class constant or enum case exists on a class-like. Class name is case-insensitive, constant/case name is case-sensitive.

pub fn get_class(&self, name: &[u8]) -> Option<&ClassLikeMetadata>

Retrieves metadata for a class (case-insensitive). Returns None if the name doesn’t correspond to a class.

pub fn get_interface(&self, name: &[u8]) -> Option<&ClassLikeMetadata>

Retrieves metadata for an interface (case-insensitive).

pub fn get_trait(&self, name: &[u8]) -> Option<&ClassLikeMetadata>

Retrieves metadata for a trait (case-insensitive).

pub fn get_enum(&self, name: &[u8]) -> Option<&ClassLikeMetadata>

Retrieves metadata for an enum (case-insensitive).

pub fn get_class_like(&self, name: &[u8]) -> Option<&ClassLikeMetadata>

Retrieves metadata for any class-like structure (case-insensitive).

pub fn get_function(&self, name: &[u8]) -> Option<&FunctionLikeMetadata>

Retrieves metadata for a global function (case-insensitive).

pub fn get_method( &self, class: &[u8], method: &[u8], ) -> Option<&FunctionLikeMetadata>

Retrieves metadata for a method (case-insensitive for both class and method names).

pub fn get_closure( &self, synthetic_name: &Word, ) -> Option<&FunctionLikeMetadata>

Retrieves metadata for a closure or arrow function by its synthetic name (e.g. {closure:src/foo.php:12:5}).

pub fn get_closure_at( &self, file: &File, span: Span, ) -> Option<&FunctionLikeMetadata>

Retrieves metadata for a closure declared at the given file and span. Convenience wrapper that rebuilds the synthetic name and delegates to Self::get_closure.

pub fn get_method_by_id( &self, method_id: &MethodIdentifier, ) -> Option<&FunctionLikeMetadata>

Retrieves method metadata by MethodIdentifier.

pub fn get_declaring_method( &self, class: &[u8], method: &[u8], ) -> Option<&FunctionLikeMetadata>

Retrieves the declaring method metadata, following the inheritance chain. This finds where the method is actually implemented.

pub fn get_function_like( &self, identifier: &FunctionLikeIdentifier, ) -> Option<&FunctionLikeMetadata>

Retrieves metadata for any function-like construct (function, method, or closure). This is a convenience method that delegates to the appropriate getter based on the identifier type.

pub fn get_constant(&self, name: &[u8]) -> Option<&ConstantMetadata>

Retrieves metadata for a global constant. Namespace lookup is case-insensitive, constant name is case-sensitive.

pub fn span_of(&self, name: &[u8]) -> Option<Span>

The declaration name span of a top-level symbol named name: a class-like (class/interface/trait/enum), a function, or a constant.

Prefers the symbol’s name span over its full declaration span, so callers land on the identifier rather than the whole declaration body. The lookup is case-insensitive, like every symbol lookup here.

pub fn get_class_constant( &self, class: &[u8], constant: &[u8], ) -> Option<&ClassLikeConstantMetadata>

Retrieves metadata for a class constant. Class name is case-insensitive, constant name is case-sensitive.

pub fn get_enum_case( &self, class: &[u8], case: &[u8], ) -> Option<&EnumCaseMetadata>

Retrieves metadata for an enum case.

pub fn get_property( &self, class: &[u8], property: &[u8], ) -> Option<&PropertyMetadata>

Retrieves metadata for a property directly from the class where it’s declared. Class name is case-insensitive, property name is case-sensitive. Sees real declarations only; magic @property* tags are reachable through ClassLikeMetadata::magic_property_ids.

pub fn get_magic_property( &self, class: &[u8], property: &[u8], ) -> Option<&PropertyMetadata>

Retrieves magic @property* metadata declared directly on a class-like. Class name is case-insensitive, property name is case-sensitive.

pub fn get_declaring_property( &self, class: &[u8], property: &[u8], ) -> Option<&PropertyMetadata>

Retrieves the property metadata, potentially from a parent class if inherited.

pub fn get_declaring_magic_property( &self, class: &[u8], property: &[u8], ) -> Option<&PropertyMetadata>

Retrieves magic @property* metadata, potentially from an inherited tag. Class name is case-insensitive, property name is case-sensitive.

pub fn get_property_type( &self, class: &[u8], property: &[u8], ) -> Option<&TUnion>

Gets the type of a property, resolving it from the declaring class if needed.

pub fn get_class_constant_type<'meta>( &'meta self, class: &[u8], constant: &[u8], ) -> Option<Cow<'meta, TUnion>>

Gets the type of a class constant, considering both type hints and inferred types.

pub fn class_extends(&self, child: &[u8], parent: &[u8]) -> bool

Checks if a child class extends a parent class (case-insensitive).

pub fn class_implements(&self, class: &[u8], interface: &[u8]) -> bool

Checks if a class implements an interface (case-insensitive).

pub fn class_uses_trait(&self, class: &[u8], trait_name: &[u8]) -> bool

Checks if a class uses a trait (case-insensitive).

pub fn is_instance_of(&self, child: &[u8], parent: &[u8]) -> bool

Checks if child is an instance of parent (via extends or implements).

pub fn is_enum_or_final_class(&self, name: &[u8]) -> bool

Checks if the given name is an enum or final class.

pub fn is_inheritable(&self, name: &[u8]) -> bool

Checks if a class-like can be part of an intersection. Generally, only final classes and enums cannot be intersected.

pub fn get_class_descendants(&self, class: &[u8]) -> WordSet

Gets all descendants of a class (recursive).

pub fn get_class_ancestors(&self, class: &[u8]) -> WordSet

Gets all ancestors of a class (parents + interfaces).

pub fn get_declaring_method_class( &self, class: &[u8], method: &[u8], ) -> Option<Word>

Gets the class where a method is declared (following inheritance).

pub fn get_declaring_method_identifier( &self, method_id: &MethodIdentifier, ) -> MethodIdentifier

Gets the declaring method identifier for a method.

pub fn method_is_overriding(&self, class: &[u8], method: &[u8]) -> bool

Checks if a method is overriding a parent method.

pub fn method_is_abstract(&self, class: &[u8], method: &[u8]) -> bool

Checks if a method is abstract.

pub fn method_is_final(&self, class: &[u8], method: &[u8]) -> bool

Checks if a method is final.

pub fn get_method_visibility( &self, class: &[u8], method: &[u8], ) -> Option<Visibility>

Gets the effective visibility of a method, taking into account trait alias visibility overrides.

When a trait method is aliased with a visibility modifier (e.g., use Trait { method as public aliasedMethod; }), the visibility is stored in the class’s trait_visibility_map. This method checks that map first, then falls back to the method’s declared visibility.

pub fn get_function_like_thrown_types<'meta>( &'meta self, class_like: Option<&'meta ClassLikeMetadata>, function_like: &'meta FunctionLikeMetadata, ) -> &'meta [TypeMetadata]

Gets thrown types for a function-like, including inherited throws.

pub fn get_declaring_property_class( &self, class: &[u8], property: &[u8], ) -> Option<Word>

Gets the class where a property is declared. Sees real declarations only; magic @property* tags are reachable through ClassLikeMetadata::magic_property_ids.

pub fn get_all_descendants(&self, class: &[u8]) -> WordSet

Gets all descendants of a class (recursive).

pub fn get_anonymous_class_name(file: &File, span: Span) -> Word

Generates the synthetic display name for an anonymous class based on its declaring file and span. Delegates to crate::get_anonymous_class_name.

pub fn get_anonymous_class( &self, file: &File, span: Span, ) -> Option<&ClassLikeMetadata>

Retrieves the metadata for an anonymous class based on its declaring file and span.

pub fn get_file_signature(&self, file_id: &FileId) -> Option<&FileSignature>

Gets the file signature for a given file ID.

Arguments

• file_id - The file identifier

Returns

A reference to the FileSignature if it exists, or None if the file has no signature.

pub fn set_file_signature( &mut self, file_id: FileId, signature: FileSignature, ) -> Option<FileSignature>

Adds or updates a file signature for a given file ID.

Arguments

• file_id - The file identifier
• signature - The file signature

Returns

The previous FileSignature if it existed.

pub fn mark_safe_symbols( &mut self, diff: &CodebaseDiff, references: &SymbolReferences, ) -> Option<WordSet>

Marks safe symbols based on diff and invalidation cascade.

After this function runs, self.safe_symbols and self.safe_symbol_members will contain all symbols that can be safely skipped during analysis.

Arguments

• diff - The computed diff between old and new code
• references - Symbol reference graph from previous run

Returns

Returns the logical names of files whose top-level code references an invalidated symbol. Returns None if the cascade was too large to compute.

pub fn extend(&mut self, other: CodebaseMetadata)

Merges information from another CodebaseMetadata into this one.

When both metadata have the same priority, the one with the smaller span is kept for deterministic results regardless of scan order.

pub fn extend_ref(&mut self, other: &CodebaseMetadata)

Extends this codebase with another by reference, cloning only individual entries.

This is more efficient than extend(other.clone()) because it avoids allocating a full clone of the source metadata’s outer HashMap/WordMap structures. Only individual entries that need insertion are cloned.

pub fn convert_partial_to_patch(&mut self)

Moves every scanned entry of this per-file partial into the patch maps.

Called on a per-file partial right after scan_program when the file is a [FileType::Patch]. Symbols and descendants from a patch partial are dropped — the FQCN belongs to whichever non-patch source originally declared it (or it’s an orphan which apply_patches_pass will diagnose later).

pub fn apply_patches_pass(&mut self)

Folds every entry in the patch_* maps into the matching vendor / built-in entry, attaching validation diagnostics to the patch entry’s issues list.

At most one patch may target a given symbol, so each entry is applied directly to its target. A patch whose target is user-defined is inert (user definitions win); a patch with no matching target is diagnosed as an orphan.

Must be called after all partials have been merged so the slots patches target are present.

pub fn extract_owned_keys(&self, merged: &CodebaseMetadata) -> CodebaseEntryKeys

Extracts only the keys that this per-file metadata currently “owns” in the given merged codebase; i.e. keys whose span in merged matches this metadata’s span.

This is what you want for incremental fingerprints. extract_keys captures every key the scan produced, including ones that lost the tiebreak in extend / extend_ref when another file defined the same FQN. Using extract_keys as a removal fingerprint then causes a nasty cross-file bug: touching file B can remove an entry that file A actually owns, because remove_entries_by_keys deletes by FQN without checking who the current owner is. The analyzer then reports a spurious “duplicate definition” when it walks A and finds B’s span in the codebase.

By only recording the keys whose spans still match this metadata, removing the fingerprint later becomes a safe no-op when another file won the merge. The removal only drops the entries this file genuinely put into the merged codebase.

pub fn remove_entries_by_keys(&mut self, keys: &CodebaseEntryKeys)

Removes entries whose keys match the given CodebaseEntryKeys.

This is the lightweight equivalent of [remove_entries_of()] — it performs the same removals but from a compact key set instead of a full CodebaseMetadata reference.

pub fn take_issues(&mut self, user_defined: bool) -> IssueCollection

Takes all issues from the codebase metadata.

pub fn get_all_file_ids(&self) -> Vec<FileId>

Gets all file IDs that have signatures in this metadata.

This is a helper method for incremental analysis to iterate over all files.

Trait Implementations

impl Clone for CodebaseMetadata

fn clone(&self) -> CodebaseMetadata

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CodebaseMetadata

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

Formats the value using the given formatter.

impl Default for CodebaseMetadata

fn default() -> CodebaseMetadata

Returns the “default value” for a type.

impl PartialEq for CodebaseMetadata

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for CodebaseMetadata