Trait sway_parse::Parse

pub trait Parse {
    fn parse(parser: &mut Parser<'_, '_>) -> Result<Self, ErrorEmitted>
    where
        Self: Sized;
}

Required Methods

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

Implementations on Foreign Types

impl Parse for DocComment

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

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

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

impl Parse for AttributeDecl

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

impl Parse for Attribute

fn parse(parser: &mut Parser<'_, '_>) -> Result<Self, 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 Parse for DependencyPath

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

impl Parse for Dependency

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

impl Parse for AsmBlock

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

impl Parse for AsmRegisterDeclaration

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

impl Parse for AsmImmediate

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

impl Parse for IfExpr

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

impl Parse for IfCondition

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

impl Parse for Expr

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

impl Parse for StatementLet

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

impl Parse for ExprStructField

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

impl Parse for MatchBranch

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

impl Parse for MatchBranchKind

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

impl Parse for GenericParams

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

impl Parse for GenericArgs

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

impl Parse for ItemAbi

fn parse(parser: &mut Parser<'_, '_>) -> Result<ItemAbi, 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 StorageField

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

impl Parse for ItemStorage

fn parse(parser: &mut Parser<'_, '_>) -> Result<ItemStorage, 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 UseTree

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

impl Parse for ItemUse

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

impl Parse for ItemKind

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

impl Parse for TypeField

fn parse(parser: &mut Parser<'_, '_>) -> Result<TypeField, 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 ScriptToken

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

impl Parse for ContractToken

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

impl Parse for PredicateToken

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

impl Parse for LibraryToken

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

impl Parse for DepToken

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

impl Parse for PubToken

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

impl Parse for UseToken

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

impl Parse for AsToken

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

impl Parse for StructToken

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

impl Parse for EnumToken

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

impl Parse for SelfToken

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

impl Parse for FnToken

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

impl Parse for TraitToken

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

impl Parse for ImplToken

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

impl Parse for ForToken

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

impl Parse for AbiToken

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

impl Parse for ConstToken

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 AsmToken

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

impl Parse for ReturnToken

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

impl Parse for IfToken

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

impl Parse for ElseToken

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

impl Parse for MatchToken

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

impl Parse for MutToken

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

impl Parse for LetToken

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

impl Parse for WhileToken

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

impl Parse for WhereToken

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

impl Parse for RefToken

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

impl Parse for DerefToken

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

impl Parse for TrueToken

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

impl Parse for FalseToken

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

impl Parse for BreakToken

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

impl Parse for ContinueToken

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

impl Parse for SemicolonToken

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

impl Parse for ForwardSlashToken

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

impl Parse for DoubleColonToken

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

impl Parse for StarToken

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

impl Parse for CommaToken

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

impl Parse for ColonToken

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

impl Parse for RightArrowToken

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

impl Parse for LessThanToken

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

impl Parse for GreaterThanToken

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

impl Parse for OpenAngleBracketToken

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

impl Parse for CloseAngleBracketToken

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

impl Parse for TildeToken

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

impl Parse for EqToken

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

impl Parse for AddEqToken

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

impl Parse for SubEqToken

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

impl Parse for StarEqToken

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

impl Parse for DivEqToken

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

impl Parse for ShlEqToken

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

impl Parse for ShrEqToken

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

impl Parse for FatRightArrowToken

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

impl Parse for DotToken

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

impl Parse for DoubleDotToken

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

impl Parse for BangToken

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

impl Parse for PercentToken

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

impl Parse for AddToken

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

impl Parse for SubToken

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

impl Parse for ShrToken

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

impl Parse for ShlToken

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

impl Parse for AmpersandToken

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

impl Parse for CaretToken

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

impl Parse for PipeToken

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

impl Parse for DoubleEqToken

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

impl Parse for BangEqToken

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

impl Parse for GreaterThanEqToken

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

impl Parse for LessThanEqToken

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

impl Parse for DoubleAmpersandToken

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

impl Parse for DoublePipeToken

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

impl Parse for UnderscoreToken

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

impl Parse for HashToken

fn parse(parser: &mut Parser<'_, '_>) -> Result<Self, 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<T> Parse for Box<T> where
    T: Parse, 

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

impl Parse for ()

fn parse(parser: &mut Parser<'_, '_>) -> Result<(), 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 Parse for Ident

fn parse(parser: &mut Parser<'_, '_>) -> Result<Ident, 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 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 WhereClause

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

Implementors