Struct CodebaseMetadata 

#[non_exhaustive]
pub struct CodebaseMetadata {
    pub infer_types_from_usage: bool,
    pub class_likes: AtomMap<ClassLikeMetadata>,
    pub function_likes: HashMap<(Atom, Atom), FunctionLikeMetadata>,
    pub symbols: Symbols,
    pub constants: AtomMap<ConstantMetadata>,
    pub all_class_like_descendants: AtomMap<AtomSet>,
    pub direct_classlike_descendants: AtomMap<AtomSet>,
    pub safe_symbols: AtomSet,
    pub safe_symbol_members: HashSet<(Atom, Atom)>,
    pub file_signatures: HashMap<FileId, FileSignature>,
}

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: AtomMap<ClassLikeMetadata>

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

function_likes: HashMap<(Atom, Atom), 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 Atom::empty() for global functions.

symbols: Symbols

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

constants: AtomMap<ConstantMetadata>

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

all_class_like_descendants: AtomMap<AtomSet>

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

direct_classlike_descendants: AtomMap<AtomSet>

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

safe_symbols: AtomSet

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

safe_symbol_members: HashSet<(Atom, Atom)>

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).

Implementations

impl CodebaseMetadata

pub fn new() -> Self

Creates a new, empty CodebaseMetadata with default values.

pub fn class_exists(&self, name: &str) -> 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: &str) -> bool

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

pub fn trait_exists(&self, name: &str) -> bool

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

pub fn enum_exists(&self, name: &str) -> bool

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

pub fn class_like_exists(&self, name: &str) -> bool

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

pub fn namespace_exists(&self, name: &str) -> bool

Checks if a namespace exists (case-insensitive).

pub fn class_or_trait_exists(&self, name: &str) -> bool

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

pub fn class_or_interface_exists(&self, name: &str) -> 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: &str) -> bool

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

pub fn constant_exists(&self, name: &str) -> 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: &str, method: &str) -> bool

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

pub fn property_exists(&self, class: &str, property: &str) -> bool

Checks if a property exists on a class-like, including inherited properties. Class name is case-insensitive, property name is case-sensitive.

pub fn class_constant_exists(&self, class: &str, constant: &str) -> 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 method_is_declared_in_class(&self, class: &str, method: &str) -> bool

Checks if a method is declared directly in a class (not inherited).

pub fn property_is_declared_in_class(&self, class: &str, property: &str) -> bool

Checks if a property is declared directly in a class (not inherited).

pub fn get_class(&self, name: &str) -> 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: &str) -> Option<&ClassLikeMetadata>

Retrieves metadata for an interface (case-insensitive).

pub fn get_trait(&self, name: &str) -> Option<&ClassLikeMetadata>

Retrieves metadata for a trait (case-insensitive).

pub fn get_enum(&self, name: &str) -> Option<&ClassLikeMetadata>

Retrieves metadata for an enum (case-insensitive).

pub fn get_class_like(&self, name: &str) -> Option<&ClassLikeMetadata>

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

pub fn get_function(&self, name: &str) -> Option<&FunctionLikeMetadata>

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

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

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

pub fn get_closure( &self, file_id: &FileId, position: &Position, ) -> Option<&FunctionLikeMetadata>

Retrieves metadata for a closure based on its file and position.

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

Retrieves method metadata by MethodIdentifier.

pub fn get_declaring_method( &self, class: &str, method: &str, ) -> 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: &str) -> Option<&ConstantMetadata>

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

pub fn get_class_constant( &self, class: &str, constant: &str, ) -> 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: &str, case: &str, ) -> Option<&EnumCaseMetadata>

Retrieves metadata for an enum case.

pub fn get_property( &self, class: &str, property: &str, ) -> 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.

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

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

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

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

pub fn get_class_constant_type<'a>( &'a self, class: &str, constant: &str, ) -> Option<Cow<'a, TUnion>>

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

pub fn get_class_constant_literal_value( &self, class: &str, constant: &str, ) -> Option<&TAtomic>

Gets the literal value of a class constant if it was inferred.

pub fn class_extends(&self, child: &str, parent: &str) -> bool

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

pub fn class_directly_extends(&self, child: &str, parent: &str) -> bool

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

pub fn class_implements(&self, class: &str, interface: &str) -> bool

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

pub fn class_directly_implements(&self, class: &str, interface: &str) -> bool

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

pub fn class_uses_trait(&self, class: &str, trait_name: &str) -> bool

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

pub fn trait_requires_extends(&self, trait_name: &str, class_name: &str) -> bool

Checks if a trait has @require-extends for a class (case-insensitive). Returns true if the trait requires extending the specified class or any of its parents.

pub fn is_instance_of(&self, child: &str, parent: &str) -> bool

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

pub fn is_enum_or_final_class(&self, name: &str) -> bool

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

pub fn is_inheritable(&self, name: &str) -> 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: &str) -> AtomSet

Gets all descendants of a class (recursive).

pub fn get_class_ancestors(&self, class: &str) -> AtomSet

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

pub fn get_declaring_method_class( &self, class: &str, method: &str, ) -> Option<Atom>

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

pub fn get_appearing_method_class( &self, class: &str, method: &str, ) -> Option<Atom>

Gets the class where a method appears (could be the declaring class or child class).

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: &str, method: &str) -> bool

Checks if a method is overriding a parent method.

pub fn method_is_abstract(&self, class: &str, method: &str) -> bool

Checks if a method is abstract.

pub fn method_is_static(&self, class: &str, method: &str) -> bool

Checks if a method is static.

pub fn method_is_final(&self, class: &str, method: &str) -> bool

Checks if a method is final.

pub fn get_method_visibility( &self, class: &str, method: &str, ) -> 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<'a>( &'a self, class_like: Option<&'a ClassLikeMetadata>, function_like: &'a FunctionLikeMetadata, ) -> &'a [TypeMetadata]

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

pub fn get_declaring_property_class( &self, class: &str, property: &str, ) -> Option<Atom>

Gets the class where a property is declared.

pub fn get_appearing_property_class( &self, class: &str, property: &str, ) -> Option<Atom>

Gets the class where a property appears.

pub fn get_all_descendants(&self, class: &str) -> AtomSet

Gets all descendants of a class (recursive).

pub fn get_anonymous_class_name(span: Span) -> Atom

Generates a unique name for an anonymous class based on its span.

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

Retrieves the metadata for an anonymous class based on its 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 remove_file_signature( &mut self, file_id: &FileId, ) -> Option<FileSignature>

Removes the file signature for a given file ID.

Arguments

• file_id - The file identifier

Returns

The removed FileSignature if it existed.

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 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() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CodebaseMetadata

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for CodebaseMetadata

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

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 CodebaseMetadata