Enum Stmt 

pub enum Stmt {
    FunctionDef(StmtFunctionDef),
    ClassDef(StmtClassDef),
    Return(StmtReturn),
    Delete(StmtDelete),
    TypeAlias(StmtTypeAlias),
    Assign(StmtAssign),
    AugAssign(StmtAugAssign),
    AnnAssign(StmtAnnAssign),
    For(StmtFor),
    While(StmtWhile),
    If(StmtIf),
    With(StmtWith),
    Match(StmtMatch),
    Raise(StmtRaise),
    Try(StmtTry),
    Assert(StmtAssert),
    Import(StmtImport),
    ImportFrom(StmtImportFrom),
    Global(StmtGlobal),
    Nonlocal(StmtNonlocal),
    Expr(StmtExpr),
    Pass(StmtPass),
    Break(StmtBreak),
    Continue(StmtContinue),
    IpyEscapeCommand(StmtIpyEscapeCommand),
}

See also stmt

Variants

FunctionDef(StmtFunctionDef)

ClassDef(StmtClassDef)

Return(StmtReturn)

Delete(StmtDelete)

TypeAlias(StmtTypeAlias)

Assign(StmtAssign)

AugAssign(StmtAugAssign)

AnnAssign(StmtAnnAssign)

For(StmtFor)

While(StmtWhile)

If(StmtIf)

With(StmtWith)

Match(StmtMatch)

Raise(StmtRaise)

Try(StmtTry)

Assert(StmtAssert)

Import(StmtImport)

ImportFrom(StmtImportFrom)

Global(StmtGlobal)

Nonlocal(StmtNonlocal)

Expr(StmtExpr)

Pass(StmtPass)

Break(StmtBreak)

Continue(StmtContinue)

IpyEscapeCommand(StmtIpyEscapeCommand)

Implementations

impl Stmt

pub const fn is_function_def_stmt(&self) -> bool

pub fn function_def_stmt(self) -> Option<StmtFunctionDef>

pub fn expect_function_def_stmt(self) -> StmtFunctionDef

pub fn as_function_def_stmt_mut(&mut self) -> Option<&mut StmtFunctionDef>

pub fn as_function_def_stmt(&self) -> Option<&StmtFunctionDef>

pub const fn is_class_def_stmt(&self) -> bool

pub fn class_def_stmt(self) -> Option<StmtClassDef>

pub fn expect_class_def_stmt(self) -> StmtClassDef

pub fn as_class_def_stmt_mut(&mut self) -> Option<&mut StmtClassDef>

pub fn as_class_def_stmt(&self) -> Option<&StmtClassDef>

pub const fn is_return_stmt(&self) -> bool

pub fn return_stmt(self) -> Option<StmtReturn>

pub fn expect_return_stmt(self) -> StmtReturn

pub fn as_return_stmt_mut(&mut self) -> Option<&mut StmtReturn>

pub fn as_return_stmt(&self) -> Option<&StmtReturn>

pub const fn is_delete_stmt(&self) -> bool

pub fn delete_stmt(self) -> Option<StmtDelete>

pub fn expect_delete_stmt(self) -> StmtDelete

pub fn as_delete_stmt_mut(&mut self) -> Option<&mut StmtDelete>

pub fn as_delete_stmt(&self) -> Option<&StmtDelete>

pub const fn is_type_alias_stmt(&self) -> bool

pub fn type_alias_stmt(self) -> Option<StmtTypeAlias>

pub fn expect_type_alias_stmt(self) -> StmtTypeAlias

pub fn as_type_alias_stmt_mut(&mut self) -> Option<&mut StmtTypeAlias>

pub fn as_type_alias_stmt(&self) -> Option<&StmtTypeAlias>

pub const fn is_assign_stmt(&self) -> bool

pub fn assign_stmt(self) -> Option<StmtAssign>

pub fn expect_assign_stmt(self) -> StmtAssign

pub fn as_assign_stmt_mut(&mut self) -> Option<&mut StmtAssign>

pub fn as_assign_stmt(&self) -> Option<&StmtAssign>

pub const fn is_aug_assign_stmt(&self) -> bool

pub fn aug_assign_stmt(self) -> Option<StmtAugAssign>

pub fn expect_aug_assign_stmt(self) -> StmtAugAssign

pub fn as_aug_assign_stmt_mut(&mut self) -> Option<&mut StmtAugAssign>

pub fn as_aug_assign_stmt(&self) -> Option<&StmtAugAssign>

pub const fn is_ann_assign_stmt(&self) -> bool

pub fn ann_assign_stmt(self) -> Option<StmtAnnAssign>

pub fn expect_ann_assign_stmt(self) -> StmtAnnAssign

pub fn as_ann_assign_stmt_mut(&mut self) -> Option<&mut StmtAnnAssign>

pub fn as_ann_assign_stmt(&self) -> Option<&StmtAnnAssign>

pub const fn is_for_stmt(&self) -> bool

pub fn for_stmt(self) -> Option<StmtFor>

pub fn expect_for_stmt(self) -> StmtFor

pub fn as_for_stmt_mut(&mut self) -> Option<&mut StmtFor>

pub fn as_for_stmt(&self) -> Option<&StmtFor>

pub const fn is_while_stmt(&self) -> bool

pub fn while_stmt(self) -> Option<StmtWhile>

pub fn expect_while_stmt(self) -> StmtWhile

pub fn as_while_stmt_mut(&mut self) -> Option<&mut StmtWhile>

pub fn as_while_stmt(&self) -> Option<&StmtWhile>

pub const fn is_if_stmt(&self) -> bool

pub fn if_stmt(self) -> Option<StmtIf>

pub fn expect_if_stmt(self) -> StmtIf

pub fn as_if_stmt_mut(&mut self) -> Option<&mut StmtIf>

pub fn as_if_stmt(&self) -> Option<&StmtIf>

pub const fn is_with_stmt(&self) -> bool

pub fn with_stmt(self) -> Option<StmtWith>

pub fn expect_with_stmt(self) -> StmtWith

pub fn as_with_stmt_mut(&mut self) -> Option<&mut StmtWith>

pub fn as_with_stmt(&self) -> Option<&StmtWith>

pub const fn is_match_stmt(&self) -> bool

pub fn match_stmt(self) -> Option<StmtMatch>

pub fn expect_match_stmt(self) -> StmtMatch

pub fn as_match_stmt_mut(&mut self) -> Option<&mut StmtMatch>

pub fn as_match_stmt(&self) -> Option<&StmtMatch>

pub const fn is_raise_stmt(&self) -> bool

pub fn raise_stmt(self) -> Option<StmtRaise>

pub fn expect_raise_stmt(self) -> StmtRaise

pub fn as_raise_stmt_mut(&mut self) -> Option<&mut StmtRaise>

pub fn as_raise_stmt(&self) -> Option<&StmtRaise>

pub const fn is_try_stmt(&self) -> bool

pub fn try_stmt(self) -> Option<StmtTry>

pub fn expect_try_stmt(self) -> StmtTry

pub fn as_try_stmt_mut(&mut self) -> Option<&mut StmtTry>

pub fn as_try_stmt(&self) -> Option<&StmtTry>

pub const fn is_assert_stmt(&self) -> bool

pub fn assert_stmt(self) -> Option<StmtAssert>

pub fn expect_assert_stmt(self) -> StmtAssert

pub fn as_assert_stmt_mut(&mut self) -> Option<&mut StmtAssert>

pub fn as_assert_stmt(&self) -> Option<&StmtAssert>

pub const fn is_import_stmt(&self) -> bool

pub fn import_stmt(self) -> Option<StmtImport>

pub fn expect_import_stmt(self) -> StmtImport

pub fn as_import_stmt_mut(&mut self) -> Option<&mut StmtImport>

pub fn as_import_stmt(&self) -> Option<&StmtImport>

pub const fn is_import_from_stmt(&self) -> bool

pub fn import_from_stmt(self) -> Option<StmtImportFrom>

pub fn expect_import_from_stmt(self) -> StmtImportFrom

pub fn as_import_from_stmt_mut(&mut self) -> Option<&mut StmtImportFrom>

pub fn as_import_from_stmt(&self) -> Option<&StmtImportFrom>

pub const fn is_global_stmt(&self) -> bool

pub fn global_stmt(self) -> Option<StmtGlobal>

pub fn expect_global_stmt(self) -> StmtGlobal

pub fn as_global_stmt_mut(&mut self) -> Option<&mut StmtGlobal>

pub fn as_global_stmt(&self) -> Option<&StmtGlobal>

pub const fn is_nonlocal_stmt(&self) -> bool

pub fn nonlocal_stmt(self) -> Option<StmtNonlocal>

pub fn expect_nonlocal_stmt(self) -> StmtNonlocal

pub fn as_nonlocal_stmt_mut(&mut self) -> Option<&mut StmtNonlocal>

pub fn as_nonlocal_stmt(&self) -> Option<&StmtNonlocal>

pub const fn is_expr_stmt(&self) -> bool

pub fn expr_stmt(self) -> Option<StmtExpr>

pub fn expect_expr_stmt(self) -> StmtExpr

pub fn as_expr_stmt_mut(&mut self) -> Option<&mut StmtExpr>

pub fn as_expr_stmt(&self) -> Option<&StmtExpr>

pub const fn is_pass_stmt(&self) -> bool

pub fn pass_stmt(self) -> Option<StmtPass>

pub fn expect_pass_stmt(self) -> StmtPass

pub fn as_pass_stmt_mut(&mut self) -> Option<&mut StmtPass>

pub fn as_pass_stmt(&self) -> Option<&StmtPass>

pub const fn is_break_stmt(&self) -> bool

pub fn break_stmt(self) -> Option<StmtBreak>

pub fn expect_break_stmt(self) -> StmtBreak

pub fn as_break_stmt_mut(&mut self) -> Option<&mut StmtBreak>

pub fn as_break_stmt(&self) -> Option<&StmtBreak>

pub const fn is_continue_stmt(&self) -> bool

pub fn continue_stmt(self) -> Option<StmtContinue>

pub fn expect_continue_stmt(self) -> StmtContinue

pub fn as_continue_stmt_mut(&mut self) -> Option<&mut StmtContinue>

pub fn as_continue_stmt(&self) -> Option<&StmtContinue>

pub const fn is_ipy_escape_command_stmt(&self) -> bool

pub fn ipy_escape_command_stmt(self) -> Option<StmtIpyEscapeCommand>

pub fn expect_ipy_escape_command_stmt(self) -> StmtIpyEscapeCommand

pub fn as_ipy_escape_command_stmt_mut( &mut self, ) -> Option<&mut StmtIpyEscapeCommand>

pub fn as_ipy_escape_command_stmt(&self) -> Option<&StmtIpyEscapeCommand>

Trait Implementations

impl Clone for Stmt

fn clone(&self) -> Stmt

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Stmt

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

Formats the value using the given formatter.

impl<'a> From<&'a Stmt> for AnyNodeRef<'a>

fn from(node: &'a Stmt) -> AnyNodeRef<'a>

Converts to this type from the input type.

impl<'a> From<&'a Stmt> for AnyRootNodeRef<'a>

fn from(node: &'a Stmt) -> AnyRootNodeRef<'a>

Converts to this type from the input type.

impl<'a> From<&'a Stmt> for ComparableStmt<'a>

fn from(stmt: &'a Stmt) -> Self

Converts to this type from the input type.

impl<'a> From<&'a Stmt> for StmtRef<'a>

fn from(node: &'a Stmt) -> Self

Converts to this type from the input type.

impl From<StmtAnnAssign> for Stmt

fn from(node: StmtAnnAssign) -> Self

Converts to this type from the input type.

impl From<StmtAssert> for Stmt

fn from(node: StmtAssert) -> Self

Converts to this type from the input type.

impl From<StmtAssign> for Stmt

fn from(node: StmtAssign) -> Self

Converts to this type from the input type.

impl From<StmtAugAssign> for Stmt

fn from(node: StmtAugAssign) -> Self

Converts to this type from the input type.

impl From<StmtBreak> for Stmt

fn from(node: StmtBreak) -> Self

Converts to this type from the input type.

impl From<StmtClassDef> for Stmt

fn from(node: StmtClassDef) -> Self

Converts to this type from the input type.

impl From<StmtContinue> for Stmt

fn from(node: StmtContinue) -> Self

Converts to this type from the input type.

impl From<StmtDelete> for Stmt

fn from(node: StmtDelete) -> Self

Converts to this type from the input type.

impl From<StmtExpr> for Stmt

fn from(node: StmtExpr) -> Self

Converts to this type from the input type.

impl From<StmtFor> for Stmt

fn from(node: StmtFor) -> Self

Converts to this type from the input type.

impl From<StmtFunctionDef> for Stmt

fn from(node: StmtFunctionDef) -> Self

Converts to this type from the input type.

impl From<StmtGlobal> for Stmt

fn from(node: StmtGlobal) -> Self

Converts to this type from the input type.

impl From<StmtIf> for Stmt

fn from(node: StmtIf) -> Self

Converts to this type from the input type.

impl From<StmtImport> for Stmt

fn from(node: StmtImport) -> Self

Converts to this type from the input type.

impl From<StmtImportFrom> for Stmt

fn from(node: StmtImportFrom) -> Self

Converts to this type from the input type.

impl From<StmtIpyEscapeCommand> for Stmt

fn from(node: StmtIpyEscapeCommand) -> Self

Converts to this type from the input type.

impl From<StmtMatch> for Stmt

fn from(node: StmtMatch) -> Self

Converts to this type from the input type.

impl From<StmtNonlocal> for Stmt

fn from(node: StmtNonlocal) -> Self

Converts to this type from the input type.

impl From<StmtPass> for Stmt

fn from(node: StmtPass) -> Self

Converts to this type from the input type.

impl From<StmtRaise> for Stmt

fn from(node: StmtRaise) -> Self

Converts to this type from the input type.

impl From<StmtReturn> for Stmt

fn from(node: StmtReturn) -> Self

Converts to this type from the input type.

impl From<StmtTry> for Stmt

fn from(node: StmtTry) -> Self

Converts to this type from the input type.

impl From<StmtTypeAlias> for Stmt

fn from(node: StmtTypeAlias) -> Self

Converts to this type from the input type.

impl From<StmtWhile> for Stmt

fn from(node: StmtWhile) -> Self

Converts to this type from the input type.

impl From<StmtWith> for Stmt

fn from(node: StmtWith) -> Self

Converts to this type from the input type.

impl HasNodeIndex for Stmt

fn node_index(&self) -> &AtomicNodeIndex

Returns the AtomicNodeIndex for this node.

impl Identifier for Stmt

fn identifier(&self) -> TextRange

Return the TextRange of the identifier in the given statement.

For example, return the range of f in:

def f():
    ...

impl PartialEq for Stmt

fn eq(&self, other: &Stmt) -> 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 Ranged for Stmt

fn range(&self) -> TextRange

The range of this item in the source text.

fn start(&self) -> TextSize

The start offset of this item in the source text.

fn end(&self) -> TextSize

The end offset of this item in the source text.

impl<'a> TryFrom<AnyRootNodeRef<'a>> for &'a Stmt

type Error = ()

The type returned in the event of a conversion error.

fn try_from(node: AnyRootNodeRef<'a>) -> Result<&'a Stmt, ()>

Performs the conversion.

impl StructuralPartialEq for Stmt