Enum rune::ast::Visibility

pub enum Visibility {
    Inherited,
    Public(Pub),
    Crate(VisibilityRestrict<Crate>),
    Super(VisibilityRestrict<Super>),
    SelfValue(VisibilityRestrict<SelfValue>),
    In(VisibilityRestrict<VisibilityIn>),
}

Visibility level restricted to some path: pub(self) or pub(super) or pub(crate) or pub(in some::module).

Variants

Inherited

An inherited visibility level, this usually means private.

Public(Pub)

An unrestricted public visibility level: pub.

Crate(VisibilityRestrict<Crate>)

Crate visibility pub(crate).

Super(VisibilityRestrict<Super>)

Super visibility pub(super).

SelfValue(VisibilityRestrict<SelfValue>)

Self visibility pub(self).

In(VisibilityRestrict<VisibilityIn>)

In visibility pub(in path).

Implementations

impl Visibility

pub const fn is_inherited(&self) -> bool

Return true if it is the Inherited variant

pub const fn is_public(&self) -> bool

Return true if the module is public.

Trait Implementations

impl Clone for Visibility

fn clone(&self) -> Visibility

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Visibility

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

Formats the value using the given formatter.

impl Default for Visibility

fn default() -> Self

Returns the “default value” for a type.

impl Eq for Visibility

impl OptionSpanned for Visibility

fn option_span(&self) -> Option<Span>

Get the optional span of the type.

impl Parse for Visibility

Parsing Visibility specifiers

Examples

use rune::{testing, ast};

assert!(matches!{
    testing::roundtrip::<ast::Visibility>("pub"),
    ast::Visibility::Public(_)
});

assert!(matches!{
    testing::roundtrip::<ast::Visibility>("pub (in a::b::c)"),
    ast::Visibility::In(_)
});

assert!(matches!{
    testing::roundtrip::<ast::Visibility>("pub(in crate::x::y::z)"),
    ast::Visibility::In(_)
});

assert!(matches!{
    testing::roundtrip::<ast::Visibility>("pub(super)"),
    ast::Visibility::Super(_)
});

assert!(matches!{
    testing::roundtrip::<ast::Visibility>("pub(crate)"),
    ast::Visibility::Crate(_)
});

assert!(matches!{
    testing::roundtrip::<ast::Visibility>("pub(self)"),
    ast::Visibility::SelfValue(_)
});

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

Parse the current item from the parser.

impl PartialEq<Visibility> for Visibility

fn eq(&self, other: &Visibility) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Visibility) -> bool

This method tests for !=.

impl StructuralEq for Visibility

impl StructuralPartialEq for Visibility

impl ToTokens for Visibility

fn to_tokens(&self, context: &MacroContext, stream: &mut TokenStream)

Turn the current item into tokens.