Struct rune::ast::Path

pub struct Path {
    pub id: Option<Id>,
    pub global: Option<ColonColon>,
    pub first: PathSegment,
    pub rest: Vec<(ColonColon, PathSegment)>,
    pub trailing: Option<ColonColon>,
}

A path, where each element is separated by a ::.

Examples

use rune::{testing, ast};

testing::roundtrip::<ast::Path>("foo::bar");
testing::roundtrip::<ast::Path>("Self::bar");
testing::roundtrip::<ast::Path>("self::bar");
testing::roundtrip::<ast::Path>("crate::bar");
testing::roundtrip::<ast::Path>("super::bar");
testing::roundtrip::<ast::Path>("HashMap::<Foo, Bar>");
testing::roundtrip::<ast::Path>("super::HashMap::<Foo, Bar>");

Fields

id: Option<Id>

Opaque id associated with path.

global: Option<ColonColon>

The optional leading colon :: indicating global scope.

first: PathSegment

The first component in the path.

rest: Vec<(ColonColon, PathSegment)>

The rest of the components in the path.

trailing: Option<ColonColon>

Trailing scope.

Implementations

impl Path

pub fn as_kind(&self) -> Option<PathKind>

Identify the kind of the path.

pub fn try_as_ident(&self) -> Option<&Ident>

Borrow as an identifier used for field access calls.

This is only allowed if there are no other path components and the path segment is not Crate or Super.

pub fn try_as_ident_mut(&mut self) -> Option<&mut Ident>

Borrow as an identifier used for field access calls.

This is only allowed if there are no other path components and the path segment is not Crate or Super.

pub fn as_components(&self) -> impl Iterator<Item = &PathSegment> + '_

Iterate over all components in path.

Trait Implementations

impl Clone for Path

fn clone(&self) -> Path

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Path

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

Formats the value using the given formatter.

impl Eq for Path

impl Parse for Path

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

Parse the current item from the parser.

impl PartialEq<Path> for Path

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

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

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

This method tests for !=.

impl Peek for Path

fn peek(p: &mut Peeker<'_>) -> bool

Peek the parser for the given token.

impl<'a> Resolve<'a> for Path

Resolve implementation for path which “stringifies” it.

type Output = Box<str>

The output type being resolved into.

fn resolve(
    &self,
    storage: &Storage,
    source: &'a Source
) -> Result<Self::Output, ResolveError>

Resolve the value from parsed AST.

impl ResolveOwned for Path

type Owned = Box<str>

The output type being resolved into.

fn resolve_owned(
    &self,
    storage: &Storage,
    source: &Source
) -> Result<Self::Owned, ResolveError>

Resolve into an owned value.

impl Spanned for Path

fn span(&self) -> Span

Get the span of the type.

impl StructuralEq for Path

impl StructuralPartialEq for Path

impl ToTokens for Path

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

Turn the current item into tokens.