Struct FunctionLikeMetadata 

pub struct FunctionLikeMetadata {

    pub kind: FunctionLikeKind,
    pub span: Span,
    pub name: Word,
    pub original_name: Word,
    pub name_span: Option<Span>,
    pub parameters: Vec<FunctionLikeParameterMetadata>,
    pub return_type_declaration_metadata: Option<TypeMetadata>,
    pub return_type_metadata: Option<TypeMetadata>,
    pub template_types: TemplateTypes,
    pub attributes: Vec<AttributeMetadata>,
    pub method_metadata: Option<MethodMetadata>,
    pub type_resolution_context: Option<TypeResolutionContext>,
    pub thrown_types: Vec<TypeMetadata>,
    pub issues: Vec<Issue>,
    pub assertions: BTreeMap<Word, Vec<Assertion>>,
    pub if_true_assertions: BTreeMap<Word, Vec<Assertion>>,
    pub if_false_assertions: BTreeMap<Word, Vec<Assertion>>,
    pub assertions_inferred: bool,
    pub globals_accessed: WordSet,
    pub has_docblock: bool,
    pub flags: MetadataFlags,
    pub version_constraint: VersionConstraint,
}

Fields

kind: FunctionLikeKind

The kind of function-like structure this metadata represents.

span: Span

The source code location (span) covering the entire function/method/closure definition. For closures/arrow functions, this covers the function(...) { ... } or fn(...) => ... part.

name: Word

The lookup name of the function or method. For named functions and methods this is the lowercased identifier (PHP-style case-insensitive lookup); for closures and arrow functions it is the synthetic {closure:path:line:col} word produced by crate::build_synthetic_name. Always set. Example: processrequest, __construct, my_global_func, {closure:src/foo.php:12:5}.

original_name: Word

The original-case name. Matches the source identifier for named functions/methods, and matches Self::name verbatim for closures.

name_span: Option<Span>

The specific source code location (span) of the function or method name identifier. None if the function/method has no name (closures/arrow functions).

parameters: Vec<FunctionLikeParameterMetadata>

Ordered list of metadata for each parameter defined in the signature.

return_type_declaration_metadata: Option<TypeMetadata>

The explicit return type declaration (type hint).

Example: For function getName(): string, this holds metadata for string. None if no return type is specified.

return_type_metadata: Option<TypeMetadata>

The explicit return type declaration (type hint) or docblock type (@return).

Example: For function getName(): string, this holds metadata for string, or for /** @return string */ function getName() { .. }, this holds metadata for string. None if neither is specified.

template_types: TemplateTypes

Generic type parameters (templates) defined for the function/method (e.g., @template T). Stores the template name and its constraint (defining entity and bound type). Example: { "T" => (GenericParent::FunctionLike(("funcName", "")), TUnion::object()) }

attributes: Vec<AttributeMetadata>

Attributes attached to the function/method/closure declaration (#[Attribute] function foo() {}).

method_metadata: Option<MethodMetadata>

Specific metadata relevant only to methods (visibility, final, static, etc.). This is Some if kind is FunctionLikeKind::Method, None otherwise.

type_resolution_context: Option<TypeResolutionContext>

Contains context information needed for resolving types within this function’s scope (e.g., use statements, current namespace, class context). Often populated during analysis.

thrown_types: Vec<TypeMetadata>

A list of types that this function/method might throw, derived from @throws docblock tags or inferred from throw statements within the body.

issues: Vec<Issue>

List of issues specifically related to parsing or interpreting this function’s docblock.

assertions: BTreeMap<Word, Vec<Assertion>>

Assertions about parameter types or variable types that are guaranteed to be true after this function/method returns normally. From @psalm-assert, @phpstan-assert, etc. Maps variable/parameter name to a list of type assertions.

if_true_assertions: BTreeMap<Word, Vec<Assertion>>

Assertions about parameter/variable types that are guaranteed to be true if this function/method returns true. From @psalm-assert-if-true, etc.

if_false_assertions: BTreeMap<Word, Vec<Assertion>>

Assertions about parameter/variable types that are guaranteed to be true if this function/method returns false. From @psalm-assert-if-false, etc.

assertions_inferred: bool

Set when the assertions in if_true_assertions / if_false_assertions were auto-inferred from the body rather than declared explicitly via docblock. The populator uses this to know it can safely override them with assertions inherited from a parent method, so explicit contracts on a parent always win.

globals_accessed: WordSet

Names of variables this function/method imports from the global scope via a global $x; statement anywhere in its body. Used by the invocation post-processor to invalidate caller-side narrowings of those globals on every call, since the callee can reassign them behind the caller’s back.

has_docblock: bool

Tracks whether this function/method has a docblock comment. Used to determine if docblock inheritance should occur implicitly.

flags: MetadataFlags

version_constraint: VersionConstraint

PHP version range in which this function-like is available, derived from Mago\AvailableSince / Mago\AvailableUntil attributes during scanning.

Implementations

impl FunctionLikeMetadata

Contains comprehensive metadata for any function-like structure in PHP.

pub fn new( kind: FunctionLikeKind, name: Word, original_name: Word, span: Span, flags: MetadataFlags, ) -> Self

Creates new FunctionLikeMetadata with basic information and default flags.

Pass the lookup name (lowercased identifier for named functions/methods, synthetic {closure:...} word for closures) and original_name (source casing for named items, identical to name for closures).

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

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

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

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

pub fn get_kind(&self) -> FunctionLikeKind

Returns the kind of function-like (Function, Method, Closure, ArrowFunction).

pub fn get_parameters_mut(&mut self) -> &mut [FunctionLikeParameterMetadata]

Returns a mutable slice of the parameter metadata.

pub fn get_parameter( &self, name: Word, ) -> Option<&FunctionLikeParameterMetadata>

Returns a reference to specific parameter metadata by name, if it exists.

pub fn get_parameter_mut( &mut self, name: Word, ) -> Option<&mut FunctionLikeParameterMetadata>

Returns a mutable reference to specific parameter metadata by name, if it exists.

pub fn get_template_types_mut(&mut self) -> &mut TemplateTypes

Returns a mutable reference to the template type parameters.

pub fn get_attributes(&self) -> &[AttributeMetadata]

Returns a slice of the attributes.

pub fn get_method_metadata_mut(&mut self) -> Option<&mut MethodMetadata>

Returns a mutable reference to the method-specific info, if this is a method.

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

Returns a mutable slice of docblock issues.

pub fn set_parameters( &mut self, parameters: impl IntoIterator<Item = FunctionLikeParameterMetadata>, )

Sets the parameters, replacing existing ones.

pub fn with_parameters( self, parameters: impl IntoIterator<Item = FunctionLikeParameterMetadata>, ) -> Self

Returns a new instance with the parameters replaced.

pub fn set_return_type_metadata(&mut self, return_type: Option<TypeMetadata>)

pub fn set_return_type_declaration_metadata( &mut self, return_type: Option<TypeMetadata>, )

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

Adds a single template type definition.

pub fn apply_patch(&mut self, patch: &mut FunctionLikeMetadata)

Applies a patch to this entry in place, refining type information only.

Refined fields — return type, per-parameter types, @param-out, default-value types, @throws, @template, and assertions — are each copied only when the patch specifies them, so a sparsely-typed patch never erases richer existing information. Structural identity (span, file, kind, parameter count, visibility) is left to whichever non-patch source declared the symbol. Diagnostics are appended to patch.issues; the full set of patching rules is documented in the [source] patching guide.

Trait Implementations

impl Clone for FunctionLikeMetadata

fn clone(&self) -> FunctionLikeMetadata

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FunctionLikeMetadata

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

Formats the value using the given formatter.

impl Eq for FunctionLikeMetadata

impl PartialEq for FunctionLikeMetadata

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