Struct TypeResolutionContext 

pub struct TypeResolutionContext { /* private fields */ }

Holds contextual information necessary for resolving generic template types (@template).

This context typically includes the definitions of template parameters available in the current scope (e.g., from class or function @template tags) and any concrete types that these templates have been resolved to (e.g., when a generic class is instantiated or a generic method is called).

Implementations

impl TypeResolutionContext

pub fn new() -> Self

Creates a new, empty TypeResolutionContext with no defined or resolved template types.

pub fn is_empty(&self) -> bool

Checks if this context is empty, meaning it has no template definitions or resolved types.

pub fn with_template_definition( self, name: Atom, constraints: Vec<GenericTemplate>, ) -> Self

Adds a template type definition (e.g., from an @template T of Constraint tag).

Arguments

• name: The name of the template parameter (e.g., "T").
• constraints: A list of constraints for the template parameter.

pub fn with_resolved_template_type( self, name: Atom, resolved_type: TUnion, ) -> Self

Adds a mapping indicating that a template parameter resolves to a specific concrete type within this context.

Arguments

• name: The name of the template parameter (e.g., "T").
• resolved_type: The concrete TUnion type that name resolves to here.

pub fn get_template_definitions(&self) -> &AtomMap<Vec<GenericTemplate>>

Returns a reference to the template definitions map.

pub fn get_template_definitions_mut( &mut self, ) -> &mut AtomMap<Vec<GenericTemplate>>

Returns a mutable reference to the template definitions map.

pub fn get_resolved_template_types(&self) -> &AtomMap<TUnion>

Returns a reference to the resolved template types map.

pub fn get_resolved_template_types_mut(&mut self) -> &mut AtomMap<TUnion>

Returns a mutable reference to the resolved template types map.

pub fn get_template_definition( &self, name: &Atom, ) -> Option<&Vec<GenericTemplate>>

Looks up the constraints for a specific template parameter defined in this context.

Arguments

• name: The name of the template parameter (e.g., "T") to look up.

Returns

Some containing a reference to the vector of constraints if the template is defined, None otherwise.

pub fn has_template_definition(&self, name: &Atom) -> bool

Checks if a specific template parameter is defined in this context.

Arguments

• name: The name of the template parameter (e.g., "T") to check.

Returns

true if the template parameter is defined, false otherwise.

pub fn with_type_aliases(self, aliases: AtomSet) -> Self

Adds type aliases from a class to this context.

Arguments

• aliases: A set of type alias names.

pub fn with_type_alias(self, name: Atom) -> Self

Adds a single type alias to this context.

Arguments

• name: The name of the type alias to add.

pub fn has_type_alias(&self, name: &Atom) -> bool

Checks if a specific type alias is defined in this context.

Arguments

• name: The name of the type alias to check.

pub fn with_imported_type_alias( self, local_name: Atom, source_class: Atom, original_name: Atom, ) -> Self

Adds an imported type alias to this context.

Arguments

• local_name: The local name of the imported alias (possibly renamed with “as”).
• source_class: The FQCN of the class where the type alias is defined.
• original_name: The original name of the type alias in the source class.

pub fn get_imported_type_alias(&self, name: &Atom) -> Option<&(Atom, Atom)>

Looks up an imported type alias in this context.

Arguments

• name: The local name of the imported alias to look up.

Returns

Some containing a reference to (source_class, original_name) if found, None otherwise.

pub fn has_imported_type_alias(&self, name: &Atom) -> bool

Checks if a specific imported type alias is defined in this context.

Arguments

• name: The local name of the imported alias to check.

pub fn get_resolved_template_type(&self, name: &Atom) -> Option<&TUnion>

Looks up the concrete type that a specific template parameter resolves to in this context.

Arguments

• name: The name of the template parameter (e.g., "T") to look up.

Returns

Some containing a reference to the resolved TUnion type if found, None otherwise.

pub fn has_templates(&self) -> bool

Checks if this context contains any template definitions or resolved template types.

pub fn is_template_resolved(&self, name: &Atom) -> bool

Checks if a specific template parameter has a concrete resolved type in this context.

pub fn merge(&mut self, other: TypeResolutionContext)

Merges another TypeResolutionContext into this one, combining their template definitions and resolved types.

Trait Implementations

impl Clone for TypeResolutionContext

fn clone(&self) -> TypeResolutionContext

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TypeResolutionContext

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

Formats the value using the given formatter.

impl Default for TypeResolutionContext

Provides a default, empty type resolution context.

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for TypeResolutionContext

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for TypeResolutionContext

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

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 TypeResolutionContext

impl StructuralPartialEq for TypeResolutionContext