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 len(&self) -> usize

pub fn identity_args(&self) -> 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 split(&self, info: &ParamsInfo) -> (Self, Self)

Split these params in two, according to the provided ParamsInfo.

impl GenericParams

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

where C: AstFormatter,

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

where C: AstFormatter,

pub fn fmt_where_clauses( tab: &str, num_parent_clauses: usize, clauses: Vec<String>, ) -> String

[num_parent_clauses]: we store in the definitions all the clauses they have access to, which includes the clauses inherited from the parent. This can be confusing: we insert a delimiter between the inherited clauses and the local clauses.

Trait Implementations

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 Drive for GenericParams

fn drive<V: Visitor>(&self, visitor: &mut V)

impl DriveMut for GenericParams

fn drive_mut<V: VisitorMut>(&mut self, visitor: &mut V)

impl<C: AstFormatter> FmtWithCtx<C> for GenericParams

fn fmt_with_ctx(&self, ctx: &C) -> String

fn fmt_with_ctx_and_indent(&self, _tab: &str, _ctx: &C) -> String

fn with_ctx<'a>(&'a self, ctx: &'a C) -> impl Display + 'a

Returns a struct that implements Display. This allows the following:

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