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<(GenericParent, TUnion)>, ) -> 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, each specifying the origin (parent) and the constraint type.

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, ) -> &[(Atom, Vec<(GenericParent, TUnion)>)]

Returns a slice of the defined template parameters and their constraints for this context.

pub fn get_template_definitions_mut( &mut self, ) -> &mut [(Atom, Vec<(GenericParent, TUnion)>)]

Returns a mutable slice of the defined template parameters and their constraints for this context.

pub fn get_resolved_template_types(&self) -> &[(Atom, TUnion)]

Returns a slice of the template parameters that have resolved to concrete types in this context.

pub fn get_resolved_template_types_mut(&mut self) -> &mut [(Atom, TUnion)]

Returns a mutable slice of the template parameters that have resolved to concrete types in this context.

pub fn get_template_definition( &self, name: &str, ) -> Option<&Vec<(GenericParent, TUnion)>>

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: &str) -> 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 get_resolved_template_type(&self, name: &str) -> 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. Note: If multiple entries exist for the same name (due to shadowing or errors), this currently returns the first match found.

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: &str) -> 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 Hash for TypeResolutionContext

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

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