## RibKind

# Enum RibKind

Source

    pub(crate) enum RibKind<'ra> {
        Normal,
        Block(Option<Module<'ra>>),
        AssocItem,
        FnOrCoroutine,
        Item(HasGenericParams, DefKind),
        ConstantItem(ConstantHasGenerics, Option<(Ident, ConstantItemKind)>),
        Module(Module<'ra>),
        MacroDefinition(DefId),
        ForwardGenericParamBan(ForwardGenericParamBanReason),
        ConstParamTy,
        InlineAsmSym,
    }

Expand description

The rib kind restricts certain accesses, e.g. to a `Res::Local` of an outer item.

## Variants§

§

### Normal

No restriction needs to be applied.

§

### Block(Option<Module<'ra>>)

We passed through an `ast::Block`. Behaves like `Normal`, but also partially like `Module` if the block contains items. `Block(None)` must be always processed in the same way as `Block(Some(module))` with empty `module`. The module can be `None` only because creation of some definitely empty modules is skipped as an optimization.

§

### AssocItem

We passed through an impl or trait and are now in one of its methods or associated types. Allow references to ty params that impl or trait binds. Disallow any other upvars (including other ty params that are upvars).

§

### FnOrCoroutine

We passed through a function, closure or coroutine signature. Disallow labels.

§

### Item(HasGenericParams, DefKind)

We passed through an item scope. Disallow upvars.

§

### ConstantItem(ConstantHasGenerics, Option<(Ident, ConstantItemKind)>)

We’re in a constant item. Can’t refer to dynamic stuff.

The item may reference generic parameters in trivial constant expressions. All other constants aren’t allowed to use generic params at all.

§

### Module(Module<'ra>)

We passed through a module item.

§

### MacroDefinition(DefId)

We passed through a `macro_rules!` statement

§

### ForwardGenericParamBan(ForwardGenericParamBanReason)

All bindings in this rib are generic parameters that can’t be used from the default of a generic parameter because they’re not declared before said generic parameter. Also see the `visit_generics` override.

§

### ConstParamTy

We are inside of the type of a const parameter. Can’t refer to any parameters.

§

### InlineAsmSym

We are inside a `sym` inline assembly operand. Can only refer to globals.

## Implementations§

Source§

### impl RibKind<'_>

Source

#### pub(crate) fn contains_params(&self) -> bool

Whether this rib kind contains generic parameters, as opposed to local variables.

Source

#### fn is_label_barrier(self) -> bool

This rib forbids referring to labels defined in upwards ribs.

## Trait Implementations§

Source§

### impl<'ra> Clone for RibKind<'ra>

Source§

#### fn clone(&self) -> RibKind<'ra>

Returns a duplicate of the value. Read more
1.0.0§

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

Performs copy-assignment from `source`. Read more
Source§

### impl<'ra> Debug for RibKind<'ra>

Source§

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

Formats the value using the given formatter. Read more
Source§

### impl<'ra> Copy for RibKind<'ra>

## Auto Trait Implementations§

§

### impl<'ra> !DynSend for RibKind<'ra>

§

### impl<'ra> !DynSync for RibKind<'ra>

§

### impl<'ra> Freeze for RibKind<'ra>

§

### impl<'ra> !RefUnwindSafe for RibKind<'ra>

§

### impl<'ra> !Send for RibKind<'ra>

§

### impl<'ra> !Sync for RibKind<'ra>

§

### impl<'ra> Unpin for RibKind<'ra>

§

### impl<'ra> !UnwindSafe for RibKind<'ra>

## Blanket Implementations§

§

### impl<T> Aligned for T

§

#### const ALIGN: Alignment

Alignment of `Self`.
§

### impl<T> Any for T
where T: 'static + ?Sized,

§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
§

### impl<'tcx, T> ArenaAllocatable<'tcx, IsCopy> for T
where T: Copy,

§

#### fn allocate_on(self, arena: &'tcx Arena<'tcx>) -> &'tcx mut T

§

#### fn allocate_from_iter( arena: &'tcx Arena<'tcx>, iter: impl IntoIterator<Item = T>, ) -> &'tcx mut [T]

§

### impl<'tcx, T> ArenaAllocatable<'tcx, IsCopy> for T
where T: Copy,

§

#### fn allocate_on(self, arena: &'tcx Arena<'tcx>) -> &'tcx mut T

§

#### fn allocate_from_iter( arena: &'tcx Arena<'tcx>, iter: impl IntoIterator<Item = T>, ) -> &'tcx mut [T]

§

### impl<T> Borrow<T> for T
where T: ?Sized,

§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
§

### impl<T> BorrowMut<T> for T
where T: ?Sized,

§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

### impl<T> CloneToUninit for T
where T: Clone,

§

#### unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (`clone_to_uninit`)
Performs copy-assignment from `self` to `dest`. Read more
§

### impl<T, R> CollectAndApply<T, R> for T

§

#### fn collect_and_apply<I, F>(iter: I, f: F) -> R
where I: Iterator<Item = T>, F: FnOnce(&[T]) -> R,

Equivalent to `f(&iter.collect::<Vec<_>>())`.

§

#### type Output = R

§

### impl<T> DynClone for T
where T: Clone,

§

#### fn __clone_box(&self, _: Private) -> *mut ()

§

### impl<T> From<T> for T

§

#### fn from(t: T) -> T

Returns the argument unchanged.

§

### impl<T> Instrument for T

§

#### fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided `Span`, returning an `Instrumented` wrapper. Read more
§

#### fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current `Span`, returning an `Instrumented` wrapper. Read more
§

### impl<T, U> Into<U> for T
where U: From<T>,

§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

§

### impl<T> IntoEither for T

§

#### fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts `self` into a `Left` variant of `Either<Self, Self>` if `into_left` is `true`. Converts `self` into a `Right` variant of `Either<Self, Self>` otherwise. Read more
§

#### fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts `self` into a `Left` variant of `Either<Self, Self>` if `into_left(&self)` returns `true`. Converts `self` into a `Right` variant of `Either<Self, Self>` otherwise. Read more
§

### impl<P> IntoQueryParam<P> for P

§

#### fn into_query_param(self) -> P

§

### impl<T> MaybeResult<T> for T

§

#### type Error = !

§

#### fn from(_: Result<T, <T as MaybeResult<T>>::Error>) -> T

§

#### fn to_result(self) -> Result<T, <T as MaybeResult<T>>::Error>

§

### impl<T> Pointable for T

§

#### const ALIGN: usize

The alignment of pointer.
§

#### type Init = T

The type for initializers.
§

#### unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

#### unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

#### unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

#### unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
§

### impl<T> Same for T

§

#### type Output = T

Should always be `Self`
§

### impl<T> ToOwned for T
where T: Clone,

§

#### type Owned = T

The resulting type after obtaining ownership.
§

#### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
§

#### fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
§

### impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

#### type Error = Infallible

The type returned in the event of a conversion error.
§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
§

### impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

### impl<I, T, U> Upcast<I, U> for T
where U: UpcastFrom<I, T>,

§

#### fn upcast(self, interner: I) -> U

§

### impl<I, T> UpcastFrom<I, T> for T

§

#### fn upcast_from(from: T, _tcx: I) -> T

§

### impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

#### fn vzip(self) -> V

§

### impl<Tcx, T> Value<Tcx> for T
where Tcx: DepContext,

§

#### default fn from_cycle_error( tcx: Tcx, cycle_error: &CycleError, _guar: ErrorGuaranteed, ) -> T

§

### impl<T> WithSubscriber for T

§

#### fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more
§

#### fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more
§

### impl<T> ErasedDestructor for T
where T: 'static,

## Layout§

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain `repr(...)` attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 24 bytes

Size for each variant:

- `Normal`: 0 bytes
- `Block`: 15 bytes
- `AssocItem`: 0 bytes
- `FnOrCoroutine`: 0 bytes
- `Item`: 15 bytes
- `ConstantItem`: 19 bytes
- `Module`: 15 bytes
- `MacroDefinition`: 11 bytes
- `ForwardGenericParamBan`: 1 byte
- `ConstParamTy`: 0 bytes
- `InlineAsmSym`: 0 bytes