Struct GlobalDecl 

pub struct GlobalDecl {
    pub def_id: GlobalDeclId,
    pub item_meta: ItemMeta,
    pub generics: GenericParams,
    pub ty: Ty,
    pub size: Size,
    pub align: Size,
    pub ptr_metadata: Operand,
    pub src: GlobalSource,
    pub global_kind: GlobalKind,
    pub value: ConstantExpr,
}

A global variable definition (constant or static).

Fields

def_id: GlobalDeclId

item_meta: ItemMeta

The meta data associated with the declaration.

generics: GenericParams

Remark: constants can actually have generic parameters.

struct V<const N: usize, T> {
    x: [T; N],
}

impl<const N: usize, T> V<N, T> {
    const LEN: usize = N; // This has generics <N, T>
}

fn use_v<const N: usize, T>(v: V<N, T>) {
    let l = V::<N, T>::LEN; // We need to provided a substitution here
}

ty: Ty

size: Size

The size in bytes of the global’s allocation.

align: Size

The alignment in bytes of the global’s allocation.

ptr_metadata: Operand

The pointer metadata for references to this global (needed for unsized globals).

src: GlobalSource

The context of the global: distinguishes normal items from trait-associated items and vtable instances.

global_kind: GlobalKind

The kind of global (static or const).

value: ConstantExpr

The value of this constant/static. By default this is a ConstantExprKind::Call to the initializer function that computes the value (the function uses the same generic parameters as the global).

Implementations

impl GlobalDecl

pub fn init_fun_id(&self) -> Option<FunDeclId>

If this global’s value is a call to its initializer function, returns the initializer’s id.

pub fn is_unsafe_to_access(&self, _krate: &TranslatedCrate) -> bool

Whether this global is unsafe to access, because it is a mutable or unsafe external static (safety.unsafe-static).

pub fn is_unsafe_to_declare(&self, _krate: &TranslatedCrate) -> bool

Whether this global is unsafe to declare.

Trait Implementations

impl AstVisitable for GlobalDecl

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 drive_two<V: ZipAst>(&self, other: &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))

where Self: Sized,

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))

where Self: Sized,

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

impl Clone for GlobalDecl

fn clone(&self) -> GlobalDecl

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GlobalDecl

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

Formats the value using the given formatter.

impl<'de, __State: ?Sized> DeserializeState<'de, __State> for GlobalDecl

where GlobalDeclId: DeserializeState<'de, __State>, ItemMeta: DeserializeState<'de, __State>, GenericParams: DeserializeState<'de, __State>, Ty: DeserializeState<'de, __State>, Size: DeserializeState<'de, __State>, Operand: DeserializeState<'de, __State>, GlobalSource: DeserializeState<'de, __State>, GlobalKind: DeserializeState<'de, __State>, ConstantExpr: DeserializeState<'de, __State>,

fn deserialize_state<__D>( __state: &__State, __deserializer: __D, ) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

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

where V: Visitor + Visit<'s, GlobalDeclId> + Visit<'s, ItemMeta> + Visit<'s, GenericParams> + Visit<'s, Ty> + Visit<'s, Size> + Visit<'s, Operand> + Visit<'s, GlobalSource> + Visit<'s, GlobalKind> + Visit<'s, ConstantExpr>,

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 GlobalDecl

where V: Visitor + VisitMut<'s, GlobalDeclId> + VisitMut<'s, ItemMeta> + VisitMut<'s, GenericParams> + VisitMut<'s, Ty> + VisitMut<'s, Size> + VisitMut<'s, Operand> + VisitMut<'s, GlobalSource> + VisitMut<'s, GlobalKind> + VisitMut<'s, ConstantExpr>,

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

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

impl<'s, V> DriveTwo<'s, V> for GlobalDecl

where V: Visitor<Break: Default> + VisitTwo<'s, GlobalDeclId> + VisitTwo<'s, ItemMeta> + VisitTwo<'s, GenericParams> + VisitTwo<'s, Ty> + VisitTwo<'s, Size> + VisitTwo<'s, Operand> + VisitTwo<'s, GlobalSource> + VisitTwo<'s, GlobalKind> + VisitTwo<'s, ConstantExpr>,

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

Call v.visit() on the immediate contents of self and other, if they correspond. If the values don’t match up, this returns Break(Default::default()).

impl<C> FmtWithCtx<C> for GlobalDecl

where C: AstFormatter,

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

fn with_ctx<'a>(&'a self, ctx: &'a C) -> WithCtx<'a, C, Self>

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

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

impl<__State: ?Sized> SerializeState<__State> for GlobalDecl

where GlobalDeclId: SerializeState<__State>, ItemMeta: SerializeState<__State>, GenericParams: SerializeState<__State>, Ty: SerializeState<__State>, Size: SerializeState<__State>, Operand: SerializeState<__State>, GlobalSource: SerializeState<__State>, GlobalKind: SerializeState<__State>, ConstantExpr: SerializeState<__State>,

fn serialize_state<__S>( &self, __state: &__State, __serializer: __S, ) -> Result<__S::Ok, __S::Error>

where __S: Serializer,