Enum witx::parser::TypedefSyntax

pub enum TypedefSyntax<'a> {
    Enum(EnumSyntax<'a>),
    Tuple(TupleSyntax<'a>),
    Expected(ExpectedSyntax<'a>),
    Flags(FlagsSyntax<'a>),
    Record(RecordSyntax<'a>),
    Union(UnionSyntax<'a>),
    Variant(VariantSyntax<'a>),
    Handle(HandleSyntax),
    List(Box<TypedefSyntax<'a>>),
    Pointer(Box<TypedefSyntax<'a>>),
    ConstPointer(Box<TypedefSyntax<'a>>),
    Builtin(BuiltinType),
    Ident(Id<'a>),
    String,
    Bool,
}

Variants

Enum(EnumSyntax<'a>)

Tuple Fields of Enum

0: EnumSyntax<'a>

Tuple(TupleSyntax<'a>)

Tuple Fields of Tuple

0: TupleSyntax<'a>

Expected(ExpectedSyntax<'a>)

Tuple Fields of Expected

0: ExpectedSyntax<'a>

Flags(FlagsSyntax<'a>)

Tuple Fields of Flags

0: FlagsSyntax<'a>

Record(RecordSyntax<'a>)

Tuple Fields of Record

0: RecordSyntax<'a>

Union(UnionSyntax<'a>)

Tuple Fields of Union

0: UnionSyntax<'a>

Variant(VariantSyntax<'a>)

Tuple Fields of Variant

0: VariantSyntax<'a>

Handle(HandleSyntax)

Tuple Fields of Handle

0: HandleSyntax

List(Box<TypedefSyntax<'a>>)

Tuple Fields of List

0: Box<TypedefSyntax<'a>>

Pointer(Box<TypedefSyntax<'a>>)

Tuple Fields of Pointer

0: Box<TypedefSyntax<'a>>

ConstPointer(Box<TypedefSyntax<'a>>)

Tuple Fields of ConstPointer

0: Box<TypedefSyntax<'a>>

Builtin(BuiltinType)

Tuple Fields of Builtin

0: BuiltinType

Ident(Id<'a>)

Tuple Fields of Ident

0: Id<'a>

String

Bool

Trait Implementations

impl<'a> Clone for TypedefSyntax<'a>

fn clone(&self) -> TypedefSyntax<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for TypedefSyntax<'a>

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

Formats the value using the given formatter.

impl<'a> Parse<'a> for TypedefSyntax<'a>

fn parse(parser: Parser<'a>) -> Result<Self>

Attempts to parse Self from parser, returning an error if it could not be parsed.

impl<'a> PartialEq<TypedefSyntax<'a>> for TypedefSyntax<'a>

fn eq(&self, other: &TypedefSyntax<'a>) -> bool

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

fn ne(&self, other: &TypedefSyntax<'a>) -> bool

This method tests for !=.

impl<'a> Eq for TypedefSyntax<'a>

impl<'a> StructuralEq for TypedefSyntax<'a>

impl<'a> StructuralPartialEq for TypedefSyntax<'a>