Struct ConstArg

#[repr(C)]
pub struct ConstArg<'hir, Unambig = ()> {
    pub hir_id: HirId,
    pub kind: ConstArgKind<'hir, Unambig>,
}

A constant that enters the type system, used for arguments to const generics (e.g. array lengths).

These are distinct from AnonConst as anon consts in the type system are not allowed to use any generic parameters, therefore we must represent N differently. Additionally future designs for supporting generic parameters in const arguments will likely not use an anon const based design.

So, ConstArg (specifically, ConstArgKind) distinguishes between const args that are just paths (currently just bare const params) versus const args that are literals or have arbitrary computations (e.g., { 1 + 3 }).

The Unambig generic parameter represents whether the position this const is from is unambiguously a const or ambiguous as to whether it is a type or a const. When in an ambiguous context the parameter is instantiated with an uninhabited type making the ConstArgKind::Infer variant unusable and GenericArg::Infer is used instead.

Fields

hir_id: HirId

kind: ConstArgKind<'hir, Unambig>

Implementations

impl<'hir> ConstArg<'hir, AmbigArg>

pub fn as_unambig_ct(&self) -> &ConstArg<'hir>

Converts a ConstArg in an ambiguous position to one in an unambiguous position.

Functions accepting an unambiguous consts may expect the ConstArgKind::Infer variant to be used. Care should be taken to separately handle infer consts when calling this function as it cannot be handled by downstream code making use of the returned const.

In practice this may mean overriding the Visitor::visit_infer method on hir visitors, or specifically matching on GenericArg::Infer when handling generic arguments.

impl<'hir> ConstArg<'hir>

pub fn try_as_ambig_ct(&self) -> Option<&ConstArg<'hir, AmbigArg>>

Converts a ConstArg in an unambigous position to one in an ambiguous position. This is fallible as the ConstArgKind::Infer variant is not present in ambiguous positions.

Functions accepting ambiguous consts will not handle the ConstArgKind::Infer variant, if infer consts are relevant to you then care should be taken to handle them separately.

impl<'hir, Unambig> ConstArg<'hir, Unambig>

pub fn anon_const_hir_id(&self) -> Option<HirId>

pub fn span(&self) -> Span

Trait Implementations

impl<'hir, Unambig: Clone> Clone for ConstArg<'hir, Unambig>

fn clone(&self) -> ConstArg<'hir, Unambig>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'hir, Unambig: Debug> Debug for ConstArg<'hir, Unambig>

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

Formats the value using the given formatter.

impl<'hir> From<&'hir ConstArg<'hir>> for Term<'hir>

fn from(c: &'hir ConstArg<'hir>) -> Self

Converts to this type from the input type.

impl<'hir, Unambig, __CTX> HashStable<__CTX> for ConstArg<'hir, Unambig>

where __CTX: HashStableContext, Unambig: HashStable<__CTX>,

fn hash_stable(&self, __hcx: &mut __CTX, __hasher: &mut StableHasher)

impl<'hir, Unambig: Copy> Copy for ConstArg<'hir, Unambig>

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.