Type Alias Value

pub type Value<'tcx> = Visibility<DefId>;

Aliased Type

enum Value<'tcx> {
    Public,
    Restricted(DefId),
}

Variants

Public

Visible everywhere (including in other crates).

Restricted(DefId)

Visible only in the given crate-local module.

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: 8 bytes

Size for each variant:

• Public: 0 bytes
• Restricted: 8 bytes

Implementations

impl Visibility<DefId>

pub fn expect_local(self) -> Visibility

pub fn is_visible_locally(self) -> bool

Returns true if this item is visible anywhere in the local crate.

impl<Id> Visibility<Id>

pub fn is_public(self) -> bool

pub fn map_id<OutId>(self, f: impl FnOnce(Id) -> OutId) -> Visibility<OutId>

impl<Id: Into<DefId>> Visibility<Id>

pub fn to_def_id(self) -> Visibility<DefId>

pub fn is_accessible_from( self, module: impl Into<DefId>, tcx: TyCtxt<'_>, ) -> bool

Returns true if an item with this visibility is accessible from the given module.

pub fn is_at_least( self, vis: Visibility<impl Into<DefId>>, tcx: TyCtxt<'_>, ) -> bool

Returns true if this visibility is at least as accessible as the given visibility

Trait Implementations

impl<Id: Clone> Clone for Visibility<Id>

fn clone(&self) -> Visibility<Id>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Id: Debug> Debug for Visibility<Id>

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

Formats the value using the given formatter.

impl<Id, __D: SpanDecoder> Decodable<__D> for Visibility<Id>

where Id: Decodable<__D>,

fn decode(__decoder: &mut __D) -> Self

impl<Id, __E: SpanEncoder> Encodable<__E> for Visibility<Id>

where Id: Encodable<__E>,

fn encode(&self, __encoder: &mut __E)

impl EraseType for Visibility<DefId>

type Result = [u8; 8]

impl<Id: Hash> Hash for Visibility<Id>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'__ctx, Id> HashStable<StableHashingContext<'__ctx>> for Visibility<Id>

where Id: HashStable<StableHashingContext<'__ctx>>,

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher, )

impl<Id: PartialEq> PartialEq for Visibility<Id>

fn eq(&self, other: &Visibility<Id>) -> 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<Id: Copy> Copy for Visibility<Id>

impl<Id: Eq> Eq for Visibility<Id>

impl<Id> StructuralPartialEq for Visibility<Id>