Enum Annotation 

pub enum Annotation<M> {
    Injection(M),
    NoPrettyPrint(M),
    SingleString(M),
    NoLayout(M),
    Hidden(M),
    Error(M, String<M>),
    PartOf(M, Identifier<M>),
}

Variants

Injection(M)

Mark a constructor as being a mapping from sort x to sort x. An example is a parenthesis rule:

expr:
paren = "(" expr ")"

In that case you don’t want a variant in the expr rule that’s called “paren”. Instead, by adding the injection annotation you tell the parser that this rule is purely to create a new priority level, but to use the inner expr as the result of the parse. Thus there will be no rule called “paren”.

NoPrettyPrint(M)

disable pretty printing. Doesn’t work well anyway so don’t bother with this annotation

SingleString(M)

mark a rule to appear as just a string in the AST. Whatever structure is found within, throw it away and just store whatever was parsed.

Note that any AST node has the .as_str() method to request this string representation of the node. For single-string rules this is simply the default.

NoLayout(M)

don’t accept any layout characters while parsing this rule

Hidden(M)

Annotation for sorts. This sort will not appear in any of the constructors it’s used in. useful for for example the [newline] rule in this file.

Error(M, String<M>)

if this rule manages to parse, display an error with the associated message This annotation can be placed on constructors (these constructors then won’t actually exist in the AST, if the constructor is chosen an error is emitted), or on sorts. On a sort the annotation has a slightly different effect. If none of the variants in the sort managed to parse then alongside an “expected …”, that message will be displayed as well. If this sort was the only possibility at a certain point, only the message will be displayed.

PartOf(M, Identifier<M>)

Makes constructors of this rule generate as part of another rule. This has one major requirement. If a is part-of b then b must have a rule like a=a; (also written as just a;) to allow any a to appear in b

Injections on rule a become injections into rule b too.

Trait Implementations

impl<M: AstInfo> AstNode<M> for Annotation<M>

fn ast_info(&self) -> &M

fn constructor(&self) -> &'static str

fn sort(&self) -> &'static str

fn as_str<'a>(&'a self) -> &'a str

where M: SpannedAstInfo + 'a,

fn traverse<F>(&self, _f: F)

where Self: Sized, F: FnMut(&dyn AstNode<M>),

impl<M: Debug> Debug for Annotation<M>

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

Formats the value using the given formatter.

impl<'de, M> Deserialize<'de> for Annotation<M>

where M: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<M: AstInfo> FromPairs<M> for Annotation<M>

fn from_pairs<G: GenerateAstInfo<Result = M>>( pair: &ParsePairSort<'_>, generator: &mut G, ) -> Self

impl<M: PartialEq> PartialEq for Annotation<M>

fn eq(&self, other: &Annotation<M>) -> 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<M> Serialize for Annotation<M>

where M: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<M> StructuralPartialEq for Annotation<M>