Struct NamespaceScope 

pub struct NamespaceScope { /* private fields */ }

Represents the scope for resolving PHP names, holding the current namespace and any ‘use’ aliases defined within it.

This struct keeps track of the current namespace and the different types of aliases (use, use function, use const). It provides methods to manage aliases and resolve names according to PHP’s rules (handling FQNs, aliases, the namespace keyword, and namespace relativity).

Aliases are stored case-insensitively (keys in the maps are lowercase) but resolve to the original case-sensitive FQN.

Implementations

impl NamespaceScope

pub fn new(namespace_name: Option<String>) -> Self

Creates a new, empty scope, optionally associated with a namespace.

pub fn global() -> Self

Creates a new, empty scope representing the global namespace.

pub fn for_namespace(namespace: impl Into<String>) -> Self

Creates a new, empty scope representing the given namespace.

pub fn has_aliases(&self) -> bool

Checks if any aliases have been defined in this scope.

pub fn namespace_name(&self) -> Option<&str>

Returns the name of the current namespace, if this scope represents one.

pub fn default_aliases(&self) -> &HashMap<String, String>

Returns a reference to the map of default (class/namespace) aliases.

pub fn function_aliases(&self) -> &HashMap<String, String>

Returns a reference to the map of function aliases.

pub fn constant_aliases(&self) -> &HashMap<String, String>

Returns a reference to the map of constant aliases.

pub fn populate_from_use(&mut self, use: &Use<'_>)

Populates the scope’s alias tables based on a PHP use statement AST node.

This method processes the different forms of use statements (simple, function/const, grouped) and registers the corresponding aliases within this NamespaceScope. It iterates through the items declared in the use statement and calls self.add for each one with the appropriate kind, fully qualified name, and optional alias.

Arguments

• interner - A string interner used to resolve identifiers/names from the AST nodes into actual string (&str) representations.
• r#use - A reference to the Use AST node representing the use statement. (Parameter is named r#use because use is a Rust keyword).

pub fn add( &mut self, kind: NameKind, name: impl AsRef<str>, alias: &Option<impl AsRef<str>>, )

Adds a new alias based on a ‘use’ statement to this scope.

Arguments

• kind - The type of alias (NameKind::Default, NameKind::Function, NameKind::Constant).
• name - The fully qualified name being imported (e.g., “App\Models\User”).
• alias - An optional explicit alias name (e.g., “UserModel”). If None, the alias is derived from the last part of the name (e.g., “User” from “App\Models\User”).

The alias name (explicit or derived) is stored lowercase as the key.

pub fn qualify_name(&self, name: impl AsRef<str>) -> String

Qualifies a simple name by prepending the current namespace, if applicable.

This method is intended for simple names (containing no \) that are not explicitly aliased or handled by \ or namespace\ prefixes. If the current scope has a non-empty namespace name, it will be prepended. Otherwise, the original name is returned.

Arguments

• name - The simple name to qualify (e.g., “User”).

Returns

The qualified name (e.g., “App\Models\User”) or the original name if in the global scope, the namespace is empty, or the input name was not simple.

pub fn resolve(&self, kind: NameKind, name: impl AsRef<str>) -> (String, bool)

Resolves a name fully according to PHP’s rules within this scope.

Arguments

• kind - The context (Default, Function, Constant).
• name - The name string to resolve.

Returns

A tuple (String, bool):

• The resolved or qualified name.
• true if resolved via explicit alias/construct (step 1), false otherwise.

pub fn resolve_str<'a>( &self, kind: NameKind, name_ref: &'a str, ) -> (Cow<'a, str>, bool)

non-generic version of resolve that takes a string slice.

pub fn resolve_alias( &self, kind: NameKind, name: impl AsRef<str>, ) -> Option<String>

Attempts to resolve a name using only explicit aliases and constructs.

Does not attempt to qualify simple names relative to the current namespace if they aren’t aliased.

Arguments

• kind - The context (Default, Function, Constant).
• name - The name string to resolve.

Returns

• Some(String) containing the resolved FQN if an explicit rule applies.
• None if no explicit rule resolves the name.

Trait Implementations

impl Clone for NamespaceScope

fn clone(&self) -> NamespaceScope

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NamespaceScope

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

Formats the value using the given formatter.

impl Default for NamespaceScope

fn default() -> NamespaceScope

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for NamespaceScope

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for NamespaceScope

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for NamespaceScope

impl StructuralPartialEq for NamespaceScope