Enum FieldPathElem 

pub enum FieldPathElem<'ast> {
    Ident(LocIdent),
    Expr(Ast<'ast>),
}

Element of a record field path in a record field definition. For example, in { a."%{"hello-" ++ "world"}".c = true }, the path a."%{b}".c is composed of three elements: an identifier a, an expression "hello" ++ "world", and another identifier c.

Variants

Ident(LocIdent)

A statically known identifier.

Expr(Ast<'ast>)

A dynamic field name written as a quoted expression, e.g. "%{protocol}" = .. . Normally, the expression must be a crate::ast::Node::StringChunks, so we could store the chunks directly which would be more precise. However, it’s useful to keep a general crate::ast::Ast to store errors when part of the field path failed to parse correctly.

Implementations

impl<'ast> FieldPathElem<'ast>

pub fn expr(expr: Ast<'ast>) -> Self

Build a field path element from an expression. Automatically convert an expression that is actually a static identifier to Self::Ident.

pub fn pos(&self) -> TermPos

Returns the position of the field path element.

pub fn single_ident_path( alloc: &'ast AstAlloc, ident: LocIdent, ) -> &'ast [FieldPathElem<'ast>]

Crate a path composed of a single static identifier.

pub fn single_expr_path( alloc: &'ast AstAlloc, expr: Ast<'ast>, ) -> &'ast [FieldPathElem<'ast>]

Create a path composed of a single dynamic expression.

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

Try to interpret this element as a static identifier. Returns None if the element is an expression with interpolation inside. Dual of Self::try_as_dyn_expr.

We assume that the parser has already normalized expressions that are actually static identifiers. So this method is a simple selector over Self::Ident.

pub fn try_as_dyn_expr(&self) -> Option<&Ast<'ast>>

Tries to interpret this element as a dynamic identifier. Returns None if the element is a static identifier (that is, if Self::try_as_ident returns Some(_)).

Trait Implementations

impl<'ast> Clone for FieldPathElem<'ast>

fn clone(&self) -> FieldPathElem<'ast>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CloneTo for FieldPathElem<'_>

type Data<'ast> = FieldPathElem<'ast>

This is always Self, be we need associated types to make Rust understand that Self is always parametric over the 'ast lifetime. We’re using GATs to emulate higher-kinded types.

fn clone_to<'to>(data: Self::Data<'_>, dest: &'to AstAlloc) -> Self::Data<'to>

Clones owned data from the current allocator to dest.

impl<'ast> Debug for FieldPathElem<'ast>

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

Formats the value using the given formatter.

impl<'ast> PartialEq for FieldPathElem<'ast>

fn eq(&self, other: &FieldPathElem<'ast>) -> 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<'a> Pretty<'a, Allocator> for &FieldPathElem<'_>

fn pretty(self, allocator: &'a Allocator) -> DocBuilder<'a, Allocator>

Converts self into a document

impl Allocable for FieldPathElem<'_>

impl<'ast> Eq for FieldPathElem<'ast>

impl<'ast> StructuralPartialEq for FieldPathElem<'ast>