Trait Parse 

pub trait Parse {
    const FALLBACK_ERROR: ParseErrorKind = ParseErrorKind::InvalidItem;

    // Required method
    fn parse(parser: &mut Parser<'_, '_>) -> Result<Self, ErrorEmitted>
       where Self: Sized;

    // Provided method
    fn error(_spans: Box<[Span]>, _error: ErrorEmitted) -> Option<Self>
       where Self: Sized { ... }
}

Provided Associated Constants

const FALLBACK_ERROR: ParseErrorKind = ParseErrorKind::InvalidItem

Required Methods

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

where Self: Sized,

Provided Methods

fn error(_spans: Box<[Span]>, _error: ErrorEmitted) -> Option<Self>

where Self: Sized,

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl Parse for AttributeHashKind

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

impl Parse for Expr

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

impl Parse for IfCondition

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

impl Parse for MatchBranchKind

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

impl Parse for GenericParam

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

where Self: Sized,

impl Parse for ItemKind

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

fn error(spans: Box<[Span]>, error: ErrorEmitted) -> Option<Self>

where Self: Sized,

impl Parse for ItemImplItem

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

impl Parse for ItemTraitItem

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

fn error(spans: Box<[Span]>, error: ErrorEmitted) -> Option<Self>

where Self: Sized,

impl Parse for UseTree

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

impl Parse for Literal

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

impl Parse for ModuleKind

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

impl Parse for Pattern

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

impl Parse for PatternStructField

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

impl Parse for Ty

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

impl Parse for ()

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

impl Parse for Vec<AttributeDecl>

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

impl Parse for Attribute

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

impl Parse for AttributeArg

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

impl Parse for AttributeDecl

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

impl Parse for AsmBlock

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

impl Parse for AsmImmediate

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

impl Parse for AsmRegisterDeclaration

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

impl Parse for ExprStructField

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

impl Parse for IfExpr

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

impl Parse for MatchBranch

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

impl Parse for GenericArgs

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

impl Parse for GenericParams

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

impl Parse for ItemAbi

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

impl Parse for ConfigurableField

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

impl Parse for ItemConfigurable

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

impl Parse for ItemConst

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

impl Parse for ItemEnum

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

impl Parse for ItemFn

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

impl Parse for ItemImpl

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

impl Parse for ItemStorage

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

impl Parse for StorageEntry

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

impl Parse for StorageField

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

impl Parse for ItemStruct

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

impl Parse for ItemTrait

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

impl Parse for Traits

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

impl Parse for ItemTypeAlias

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

impl Parse for ItemUse

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

impl Parse for FnArg

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

impl Parse for FnSignature

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

impl Parse for TraitType

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

impl Parse for TypeField

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

impl Parse for AbiToken

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

impl Parse for AddEqToken

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

impl Parse for AddToken

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

impl Parse for AmpersandToken

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

impl Parse for AsToken

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

impl Parse for AsmToken

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

impl Parse for BangEqToken

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

impl Parse for BangToken

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

impl Parse for BreakToken

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

impl Parse for CaretToken

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

impl Parse for ClassToken

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

impl Parse for CloseAngleBracketToken

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

impl Parse for ColonToken

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

impl Parse for CommaToken

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

impl Parse for ConfigurableToken

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

impl Parse for ConstToken

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

impl Parse for ContinueToken

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

impl Parse for ContractToken

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

impl Parse for DivEqToken

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

impl Parse for DotToken

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

impl Parse for DoubleAmpersandToken

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

impl Parse for DoubleColonToken

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

impl Parse for DoubleDotToken

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

impl Parse for DoubleEqToken

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

impl Parse for DoublePipeToken

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

impl Parse for DoubleStarToken

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

impl Parse for ElseToken

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

impl Parse for EnumToken

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

impl Parse for EqToken

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

impl Parse for FalseToken

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

impl Parse for FatRightArrowToken

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

impl Parse for FnToken

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

impl Parse for ForToken

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

impl Parse for ForwardSlashToken

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

impl Parse for GreaterThanEqToken

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

impl Parse for GreaterThanToken

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

impl Parse for HashBangToken

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

impl Parse for HashToken

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

impl Parse for IfToken

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

impl Parse for ImplToken

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

impl Parse for InToken

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

impl Parse for LessThanEqToken

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

impl Parse for LessThanToken

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

impl Parse for LetToken

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

impl Parse for LibraryToken

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

impl Parse for MatchToken

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

impl Parse for ModToken

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

impl Parse for MutToken

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

impl Parse for OpenAngleBracketToken

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

impl Parse for PanicToken

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

impl Parse for PercentToken

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

impl Parse for PipeToken

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

impl Parse for PredicateToken

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

impl Parse for PtrToken

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

impl Parse for PubToken

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

impl Parse for RefToken

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

impl Parse for ReturnToken

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

impl Parse for RightArrowToken

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

impl Parse for ScriptToken

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

impl Parse for SelfToken

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

impl Parse for SemicolonToken

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

impl Parse for ShlEqToken

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

impl Parse for ShlToken

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

impl Parse for ShrEqToken

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

impl Parse for ShrToken

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

impl Parse for SliceToken

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

impl Parse for StarEqToken

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

impl Parse for StarToken

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

impl Parse for StorageToken

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

impl Parse for StrToken

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

impl Parse for StructToken

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

impl Parse for SubEqToken

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

impl Parse for SubToken

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

impl Parse for TraitToken

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

impl Parse for TrueToken

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

impl Parse for TypeToken

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

impl Parse for UnderscoreToken

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

impl Parse for UseToken

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

impl Parse for WhereToken

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

impl Parse for WhileToken

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

impl Parse for PathExpr

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

impl Parse for PathExprSegment

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

impl Parse for PathType

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

impl Parse for PathTypeSegment

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

impl Parse for QualifiedPathRoot

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

impl Parse for StatementLet

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

impl Parse for Submodule

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

impl Parse for DocComment

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

impl Parse for WhereClause

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

impl Parse for Ident

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

impl<T0> Parse for (T0,)

where T0: Parse,

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

impl<T0, T1> Parse for (T0, T1)

where T0: Parse, T1: Parse,

fn parse(parser: &mut Parser<'_, '_>) -> Result<(T0, T1), ErrorEmitted>

impl<T0, T1, T2> Parse for (T0, T1, T2)

where T0: Parse, T1: Parse, T2: Parse,

fn parse(parser: &mut Parser<'_, '_>) -> Result<(T0, T1, T2), ErrorEmitted>

impl<T0, T1, T2, T3> Parse for (T0, T1, T2, T3)

where T0: Parse, T1: Parse, T2: Parse, T3: Parse,

fn parse(parser: &mut Parser<'_, '_>) -> Result<(T0, T1, T2, T3), ErrorEmitted>

impl<T0, T1, T2, T3, T4> Parse for (T0, T1, T2, T3, T4)

where T0: Parse, T1: Parse, T2: Parse, T3: Parse, T4: Parse,

fn parse( parser: &mut Parser<'_, '_>, ) -> Result<(T0, T1, T2, T3, T4), ErrorEmitted>

impl<T0, T1, T2, T3, T4, T5> Parse for (T0, T1, T2, T3, T4, T5)

where T0: Parse, T1: Parse, T2: Parse, T3: Parse, T4: Parse, T5: Parse,

fn parse( parser: &mut Parser<'_, '_>, ) -> Result<(T0, T1, T2, T3, T4, T5), ErrorEmitted>

impl<T0, T1, T2, T3, T4, T5, T6> Parse for (T0, T1, T2, T3, T4, T5, T6)

where T0: Parse, T1: Parse, T2: Parse, T3: Parse, T4: Parse, T5: Parse, T6: Parse,

fn parse( parser: &mut Parser<'_, '_>, ) -> Result<(T0, T1, T2, T3, T4, T5, T6), ErrorEmitted>

impl<T0, T1, T2, T3, T4, T5, T6, T7> Parse for (T0, T1, T2, T3, T4, T5, T6, T7)

where T0: Parse, T1: Parse, T2: Parse, T3: Parse, T4: Parse, T5: Parse, T6: Parse, T7: Parse,

fn parse( parser: &mut Parser<'_, '_>, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7), ErrorEmitted>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Parse for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

where T0: Parse, T1: Parse, T2: Parse, T3: Parse, T4: Parse, T5: Parse, T6: Parse, T7: Parse, T8: Parse,

fn parse( parser: &mut Parser<'_, '_>, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8), ErrorEmitted>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Parse for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

where T0: Parse, T1: Parse, T2: Parse, T3: Parse, T4: Parse, T5: Parse, T6: Parse, T7: Parse, T8: Parse, T9: Parse,

fn parse( parser: &mut Parser<'_, '_>, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), ErrorEmitted>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Parse for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

where T0: Parse, T1: Parse, T2: Parse, T3: Parse, T4: Parse, T5: Parse, T6: Parse, T7: Parse, T8: Parse, T9: Parse, T10: Parse,

fn parse( parser: &mut Parser<'_, '_>, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), ErrorEmitted>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Parse for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

where T0: Parse, T1: Parse, T2: Parse, T3: Parse, T4: Parse, T5: Parse, T6: Parse, T7: Parse, T8: Parse, T9: Parse, T10: Parse, T11: Parse,

fn parse( parser: &mut Parser<'_, '_>, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), ErrorEmitted>

impl<T> Parse for Box<T>

where T: Parse,

fn parse(parser: &mut Parser<'_, '_>) -> Result<Box<T>, ErrorEmitted>

impl<T> Parse for Braces<T>

where T: ParseToEnd,

fn parse(parser: &mut Parser<'_, '_>) -> Result<Braces<T>, ErrorEmitted>

impl<T> Parse for Parens<T>

where T: ParseToEnd,

fn parse(parser: &mut Parser<'_, '_>) -> Result<Parens<T>, ErrorEmitted>

impl<T> Parse for SquareBrackets<T>

where T: ParseToEnd,

fn parse(parser: &mut Parser<'_, '_>) -> Result<SquareBrackets<T>, ErrorEmitted>

impl<T: Parse> Parse for Annotated<T>

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

fn error(spans: Box<[Span]>, error: ErrorEmitted) -> Option<Self>

where Self: Sized,

Implementors