Struct ParamsInfo

pub struct ParamsInfo {
    pub num_region_params: usize,
    pub num_type_params: usize,
    pub num_const_generic_params: usize,
    pub num_trait_clauses: usize,
    pub num_regions_outlive: usize,
    pub num_types_outlive: usize,
    pub num_trait_type_constraints: usize,
}

We use this to store information about the parameters in parent blocks. This is necessary because in the definitions we store all the generics, including those coming from the outer impl block.

For instance:

impl Foo<T> {
        ^^^
      outer block generics
  fn bar<U>(...)  { ... }
        ^^^
      generics local to the function bar
}

In bar we store the generics: [T, U].

We however sometimes need to make a distinction between those two kinds of generics, in particular when manipulating traits. For instance:

impl<T> Foo for Bar<T> {
  fn baz<U>(...)  { ... }
}

fn test(...) {
   x.baz(...); // Here, we refer to the call as:
               // > Foo<T>::baz<U>(...)
               // If baz hadn't been a method implementation of a trait,
               // we would have refered to it as:
               // > baz<T, U>(...)
               // The reason is that with traits, we refer to the whole
               // trait implementation (as if it were a structure), then
               // pick a specific method inside (as if projecting a field
               // from a structure).
}

Remark: Rust only allows refering to the generics of the immediately outer block. For this reason, when we need to store the information about the generics of the outer block(s), we need to do it only for one level (this definitely makes things simpler).

Fields

num_region_params: usize

num_type_params: usize

num_const_generic_params: usize

num_trait_clauses: usize

num_regions_outlive: usize

num_types_outlive: usize

num_trait_type_constraints: usize

Trait Implementations

impl Clone for ParamsInfo

fn clone(&self) -> ParamsInfo

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ParamsInfo

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ParamsInfo

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Drive for ParamsInfo

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

impl DriveMut for ParamsInfo

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

impl PartialEq for ParamsInfo

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

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 ParamsInfo

impl StructuralPartialEq for ParamsInfo