Struct GenericParams

pub struct GenericParams {
    pub regions: Vector<RegionId, RegionVar>,
    pub types: Vector<TypeVarId, TypeVar>,
    pub const_generics: Vector<ConstGenericVarId, ConstGenericVar>,
    pub trait_clauses: Vector<TraitClauseId, TraitClause>,
    pub regions_outlive: Vec<RegionBinder<RegionOutlives>>,
    pub types_outlive: Vec<RegionBinder<TypeOutlives>>,
    pub trait_type_constraints: Vec<RegionBinder<TraitTypeConstraint>>,
}

Generic parameters for a declaration. We group the generics which come from the Rust compiler substitutions (the regions, types and const generics) as well as the trait clauses. The reason is that we consider that those are parameters that need to be filled. We group in a different place the predicates which are not trait clauses, because those enforce constraints but do not need to be filled with witnesses/instances.

Fields

regions: Vector<RegionId, RegionVar>

types: Vector<TypeVarId, TypeVar>

const_generics: Vector<ConstGenericVarId, ConstGenericVar>

trait_clauses: Vector<TraitClauseId, TraitClause>

regions_outlive: Vec<RegionBinder<RegionOutlives>>

The first region in the pair outlives the second region

types_outlive: Vec<RegionBinder<TypeOutlives>>

The type outlives the region

trait_type_constraints: Vec<RegionBinder<TraitTypeConstraint>>

Constraints over trait associated types

Implementations

impl GenericParams

pub fn empty() -> Self

pub fn is_empty(&self) -> bool

pub fn has_predicates(&self) -> bool

pub fn check_consistency(&self)

Run some sanity checks.

pub fn len(&self) -> usize

pub fn identity_args(&self, target: GenericsSource) -> GenericArgs

Construct a set of generic arguments in the scope of self that matches self and feeds each required parameter with itself. E.g. given parameters for <T, U> where U: PartialEq<T>, the arguments would be <T, U>[@TraitClause0].

pub fn identity_args_at_depth( &self, target: GenericsSource, depth: DeBruijnId, ) -> GenericArgs

Like identity_args but uses variables bound at the given depth.

impl GenericParams

fn format_params<'a, C>( &'a self, ctx: &'a C, ) -> impl Iterator<Item = String> + use<'a, C>

where C: AstFormatter,

fn format_clauses<'a, C>( &'a self, ctx: &'a C, ) -> impl Iterator<Item = String> + use<'a, C>

where C: AstFormatter,

pub fn fmt_with_ctx_with_trait_clauses<C>( &self, ctx: &C, tab: &str, ) -> (String, String)

where C: AstFormatter,

pub fn fmt_with_ctx_single_line<C>(&self, ctx: &C) -> String

where C: AstFormatter,

Trait Implementations

impl AstVisitable for GenericParams

fn drive<V: VisitAst>(&self, v: &mut V) -> ControlFlow<V::Break>

Recursively visit this type with the provided visitor. This calls the visitor’s visit_$any method if it exists, otherwise visit_inner.

fn drive_mut<V: VisitAstMut>(&mut self, v: &mut V) -> ControlFlow<V::Break>

Recursively visit this type with the provided visitor. This calls the visitor’s visit_$any method if it exists, otherwise visit_inner.

fn name(&self) -> &'static str

The name of the type, used for debug logging.

fn dyn_visit<T: AstVisitable>(&self, f: impl FnMut(&T))

Visit all occurrences of that type inside self, in pre-order traversal.

fn dyn_visit_mut<T: AstVisitable>(&mut self, f: impl FnMut(&mut T))

Visit all occurrences of that type inside self, in pre-order traversal.

impl Clone for GenericParams

fn clone(&self) -> GenericParams

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for GenericParams

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

Formats the value using the given formatter.

impl Default for GenericParams

fn default() -> GenericParams

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for GenericParams

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for GenericParams

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

Formats the value using the given formatter.

impl<'s, V> Drive<'s, V> for GenericParams

where V: Visitor + Visit<'s, Vector<RegionId, RegionVar>> + Visit<'s, Vector<TypeVarId, TypeVar>> + Visit<'s, Vector<ConstGenericVarId, ConstGenericVar>> + Visit<'s, Vector<TraitClauseId, TraitClause>> + Visit<'s, Vec<RegionBinder<RegionOutlives>>> + Visit<'s, Vec<RegionBinder<TypeOutlives>>> + Visit<'s, Vec<RegionBinder<TraitTypeConstraint>>>,

fn drive_inner(&'s self, visitor: &mut V) -> ControlFlow<V::Break>

Call v.visit() on the immediate contents of self.

impl<'s, V> DriveMut<'s, V> for GenericParams

where V: Visitor + VisitMut<'s, Vector<RegionId, RegionVar>> + VisitMut<'s, Vector<TypeVarId, TypeVar>> + VisitMut<'s, Vector<ConstGenericVarId, ConstGenericVar>> + VisitMut<'s, Vector<TraitClauseId, TraitClause>> + VisitMut<'s, Vec<RegionBinder<RegionOutlives>>> + VisitMut<'s, Vec<RegionBinder<TypeOutlives>>> + VisitMut<'s, Vec<RegionBinder<TraitTypeConstraint>>>,

fn drive_inner_mut(&'s mut self, visitor: &mut V) -> ControlFlow<V::Break>

Call v.visit() on the immediate contents of self.

impl Hash for GenericParams

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 Index<ConstGenericVarId> for GenericParams

type Output = ConstGenericVar

The returned type after indexing.

fn index(&self, index: ConstGenericVarId) -> &Self::Output

Performs the indexing (container[index]) operation.

impl Index<RegionId> for GenericParams

type Output = RegionVar

The returned type after indexing.

fn index(&self, index: RegionId) -> &Self::Output

Performs the indexing (container[index]) operation.

impl Index<TraitClauseId> for GenericParams

type Output = TraitClause

The returned type after indexing.

fn index(&self, index: TraitClauseId) -> &Self::Output

Performs the indexing (container[index]) operation.

impl Index<TypeVarId> for GenericParams

type Output = TypeVar

The returned type after indexing.

fn index(&self, index: TypeVarId) -> &Self::Output

Performs the indexing (container[index]) operation.

impl IndexMut<ConstGenericVarId> for GenericParams

fn index_mut(&mut self, index: ConstGenericVarId) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl IndexMut<RegionId> for GenericParams

fn index_mut(&mut self, index: RegionId) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl IndexMut<TraitClauseId> for GenericParams

fn index_mut(&mut self, index: TraitClauseId) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl IndexMut<TypeVarId> for GenericParams

fn index_mut(&mut self, index: TypeVarId) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl PartialEq for GenericParams

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

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 GenericParams

impl StructuralPartialEq for GenericParams