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", so this trait is not object safe.

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 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 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 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