Struct hax_frontend_exporter::ParamsInfo

pub struct ParamsInfo {
    pub num_generic_params: usize,
    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 when querying the generics of a definition, rustc gives us all the generics used in this definition, 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
}

TyCtxt.generics_of(bar) gives us: [T, U].

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

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

fn test(...) {
   // Here:
   x.baz(...);
   // We should refer to this 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). Additional remark: it is not possible to directly write an impl block or a trait definition inside an impl/trait block. However it is possible to define an impl/trait inside a function, which can itself be inside a block, leading to nested impl blocks.

Fields

num_generic_params: usize

The total number of generic parameters (regions + types + consts). We do not consider the trait clauses as generic parameters.

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<'__de> BorrowDecode<'__de> for ParamsInfo

fn borrow_decode<__D: BorrowDecoder<'__de>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given BorrowDecode.

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 Decode for ParamsInfo

fn decode<__D: Decoder>(decoder: &mut __D) -> Result<Self, DecodeError>

Attempt to decode this type with the given Decode.

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 Encode for ParamsInfo

fn encode<__E: Encoder>(&self, encoder: &mut __E) -> Result<(), EncodeError>

Encode a given type.

impl JsonSchema for ParamsInfo

fn schema_name() -> String

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(gen: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

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.