RustPython-Parser/ast/src/gen/generic.rs

// File automatically generated by ast/asdl_rs.py.

use crate::text_size::TextRange;
#[derive(Clone, Debug, PartialEq)]
pub struct ModModule<R = TextRange> {
    pub body: Vec<Stmt<R>>,
    pub type_ignores: Vec<TypeIgnore<R>>,
    #[cfg(feature = "all-nodes-with-ranges")]
    pub range: R,
    #[cfg(not(feature = "all-nodes-with-ranges"))]
    pub range: crate::EmptyRange<R>,
}

impl<R> From<ModModule<R>> for Mod<R> {
    fn from(payload: ModModule<R>) -> Self {
        Mod::Module(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct ModInteractive<R = TextRange> {
    pub body: Vec<Stmt<R>>,
    #[cfg(feature = "all-nodes-with-ranges")]
    pub range: R,
    #[cfg(not(feature = "all-nodes-with-ranges"))]
    pub range: crate::EmptyRange<R>,
}

impl<R> From<ModInteractive<R>> for Mod<R> {
    fn from(payload: ModInteractive<R>) -> Self {
        Mod::Interactive(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct ModExpression<R = TextRange> {
    pub body: Box<Expr<R>>,
    #[cfg(feature = "all-nodes-with-ranges")]
    pub range: R,
    #[cfg(not(feature = "all-nodes-with-ranges"))]
    pub range: crate::EmptyRange<R>,
}

impl<R> From<ModExpression<R>> for Mod<R> {
    fn from(payload: ModExpression<R>) -> Self {
        Mod::Expression(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct ModFunctionType<R = TextRange> {
    pub argtypes: Vec<Expr<R>>,
    pub returns: Box<Expr<R>>,
    #[cfg(feature = "all-nodes-with-ranges")]
    pub range: R,
    #[cfg(not(feature = "all-nodes-with-ranges"))]
    pub range: crate::EmptyRange<R>,
}

impl<R> From<ModFunctionType<R>> for Mod<R> {
    fn from(payload: ModFunctionType<R>) -> Self {
        Mod::FunctionType(payload)
    }
}

#[derive(Clone, Debug, PartialEq, is_macro::Is)]
pub enum Mod<R = TextRange> {
    Module(ModModule<R>),
    Interactive(ModInteractive<R>),
    Expression(ModExpression<R>),
    FunctionType(ModFunctionType<R>),
}

#[derive(Clone, Debug, PartialEq)]
pub struct StmtFunctionDef<R = TextRange> {
    pub name: Identifier,
    pub args: Box<Arguments<R>>,
    pub body: Vec<Stmt<R>>,
    pub decorator_list: Vec<Expr<R>>,
    pub returns: Option<Box<Expr<R>>>,
    pub type_comment: Option<String>,
    pub range: R,
}

impl<R> From<StmtFunctionDef<R>> for Stmt<R> {
    fn from(payload: StmtFunctionDef<R>) -> Self {
        Stmt::FunctionDef(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct StmtAsyncFunctionDef<R = TextRange> {
    pub name: Identifier,
    pub args: Box<Arguments<R>>,
    pub body: Vec<Stmt<R>>,
    pub decorator_list: Vec<Expr<R>>,
    pub returns: Option<Box<Expr<R>>>,
    pub type_comment: Option<String>,
    pub range: R,
}

impl<R> From<StmtAsyncFunctionDef<R>> for Stmt<R> {
    fn from(payload: StmtAsyncFunctionDef<R>) -> Self {
        Stmt::AsyncFunctionDef(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct StmtClassDef<R = TextRange> {
    pub name: Identifier,
    pub bases: Vec<Expr<R>>,
    pub keywords: Vec<Keyword<R>>,
    pub body: Vec<Stmt<R>>,
    pub decorator_list: Vec<Expr<R>>,
    pub range: R,
}

impl<R> From<StmtClassDef<R>> for Stmt<R> {
    fn from(payload: StmtClassDef<R>) -> Self {
        Stmt::ClassDef(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct StmtReturn<R = TextRange> {
    pub value: Option<Box<Expr<R>>>,
    pub range: R,
}

impl<R> From<StmtReturn<R>> for Stmt<R> {
    fn from(payload: StmtReturn<R>) -> Self {
        Stmt::Return(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct StmtDelete<R = TextRange> {
    pub targets: Vec<Expr<R>>,
    pub range: R,
}

impl<R> From<StmtDelete<R>> for Stmt<R> {
    fn from(payload: StmtDelete<R>) -> Self {
        Stmt::Delete(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct StmtAssign<R = TextRange> {
    pub targets: Vec<Expr<R>>,
    pub value: Box<Expr<R>>,
    pub type_comment: Option<String>,
    pub range: R,
}

impl<R> From<StmtAssign<R>> for Stmt<R> {
    fn from(payload: StmtAssign<R>) -> Self {
        Stmt::Assign(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct StmtAugAssign<R = TextRange> {
    pub target: Box<Expr<R>>,
    pub op: Operator,
    pub value: Box<Expr<R>>,
    pub range: R,
}

impl<R> From<StmtAugAssign<R>> for Stmt<R> {
    fn from(payload: StmtAugAssign<R>) -> Self {
        Stmt::AugAssign(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct StmtAnnAssign<R = TextRange> {
    pub target: Box<Expr<R>>,
    pub annotation: Box<Expr<R>>,
    pub value: Option<Box<Expr<R>>>,
    pub simple: bool,
    pub range: R,
}

impl<R> From<StmtAnnAssign<R>> for Stmt<R> {
    fn from(payload: StmtAnnAssign<R>) -> Self {
        Stmt::AnnAssign(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct StmtFor<R = TextRange> {
    pub target: Box<Expr<R>>,
    pub iter: Box<Expr<R>>,
    pub body: Vec<Stmt<R>>,
    pub orelse: Vec<Stmt<R>>,
    pub type_comment: Option<String>,
    pub range: R,
}

impl<R> From<StmtFor<R>> for Stmt<R> {
    fn from(payload: StmtFor<R>) -> Self {
        Stmt::For(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct StmtAsyncFor<R = TextRange> {
    pub target: Box<Expr<R>>,
    pub iter: Box<Expr<R>>,
    pub body: Vec<Stmt<R>>,
    pub orelse: Vec<Stmt<R>>,
    pub type_comment: Option<String>,
    pub range: R,
}

impl<R> From<StmtAsyncFor<R>> for Stmt<R> {
    fn from(payload: StmtAsyncFor<R>) -> Self {
        Stmt::AsyncFor(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct StmtWhile<R = TextRange> {
    pub test: Box<Expr<R>>,
    pub body: Vec<Stmt<R>>,
    pub orelse: Vec<Stmt<R>>,
    pub range: R,
}

impl<R> From<StmtWhile<R>> for Stmt<R> {
    fn from(payload: StmtWhile<R>) -> Self {
        Stmt::While(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct StmtIf<R = TextRange> {
    pub test: Box<Expr<R>>,
    pub body: Vec<Stmt<R>>,
    pub orelse: Vec<Stmt<R>>,
    pub range: R,
}

impl<R> From<StmtIf<R>> for Stmt<R> {
    fn from(payload: StmtIf<R>) -> Self {
        Stmt::If(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct StmtWith<R = TextRange> {
    pub items: Vec<Withitem<R>>,
    pub body: Vec<Stmt<R>>,
    pub type_comment: Option<String>,
    pub range: R,
}

impl<R> From<StmtWith<R>> for Stmt<R> {
    fn from(payload: StmtWith<R>) -> Self {
        Stmt::With(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct StmtAsyncWith<R = TextRange> {
    pub items: Vec<Withitem<R>>,
    pub body: Vec<Stmt<R>>,
    pub type_comment: Option<String>,
    pub range: R,
}

impl<R> From<StmtAsyncWith<R>> for Stmt<R> {
    fn from(payload: StmtAsyncWith<R>) -> Self {
        Stmt::AsyncWith(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct StmtMatch<R = TextRange> {
    pub subject: Box<Expr<R>>,
    pub cases: Vec<MatchCase<R>>,
    pub range: R,
}

impl<R> From<StmtMatch<R>> for Stmt<R> {
    fn from(payload: StmtMatch<R>) -> Self {
        Stmt::Match(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct StmtRaise<R = TextRange> {
    pub exc: Option<Box<Expr<R>>>,
    pub cause: Option<Box<Expr<R>>>,
    pub range: R,
}

impl<R> From<StmtRaise<R>> for Stmt<R> {
    fn from(payload: StmtRaise<R>) -> Self {
        Stmt::Raise(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct StmtTry<R = TextRange> {
    pub body: Vec<Stmt<R>>,
    pub handlers: Vec<Excepthandler<R>>,
    pub orelse: Vec<Stmt<R>>,
    pub finalbody: Vec<Stmt<R>>,
    pub range: R,
}

impl<R> From<StmtTry<R>> for Stmt<R> {
    fn from(payload: StmtTry<R>) -> Self {
        Stmt::Try(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct StmtTryStar<R = TextRange> {
    pub body: Vec<Stmt<R>>,
    pub handlers: Vec<Excepthandler<R>>,
    pub orelse: Vec<Stmt<R>>,
    pub finalbody: Vec<Stmt<R>>,
    pub range: R,
}

impl<R> From<StmtTryStar<R>> for Stmt<R> {
    fn from(payload: StmtTryStar<R>) -> Self {
        Stmt::TryStar(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct StmtAssert<R = TextRange> {
    pub test: Box<Expr<R>>,
    pub msg: Option<Box<Expr<R>>>,
    pub range: R,
}

impl<R> From<StmtAssert<R>> for Stmt<R> {
    fn from(payload: StmtAssert<R>) -> Self {
        Stmt::Assert(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct StmtImport<R = TextRange> {
    pub names: Vec<Alias<R>>,
    pub range: R,
}

impl<R> From<StmtImport<R>> for Stmt<R> {
    fn from(payload: StmtImport<R>) -> Self {
        Stmt::Import(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct StmtImportFrom<R = TextRange> {
    pub module: Option<Identifier>,
    pub names: Vec<Alias<R>>,
    pub level: Option<Int>,
    pub range: R,
}

impl<R> From<StmtImportFrom<R>> for Stmt<R> {
    fn from(payload: StmtImportFrom<R>) -> Self {
        Stmt::ImportFrom(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct StmtGlobal<R = TextRange> {
    pub names: Vec<Identifier>,
    pub range: R,
}

impl<R> From<StmtGlobal<R>> for Stmt<R> {
    fn from(payload: StmtGlobal<R>) -> Self {
        Stmt::Global(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct StmtNonlocal<R = TextRange> {
    pub names: Vec<Identifier>,
    pub range: R,
}

impl<R> From<StmtNonlocal<R>> for Stmt<R> {
    fn from(payload: StmtNonlocal<R>) -> Self {
        Stmt::Nonlocal(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct StmtExpr<R = TextRange> {
    pub value: Box<Expr<R>>,
    pub range: R,
}

impl<R> From<StmtExpr<R>> for Stmt<R> {
    fn from(payload: StmtExpr<R>) -> Self {
        Stmt::Expr(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct StmtPass<R = TextRange> {
    pub range: R,
}

impl<R> From<StmtPass<R>> for Stmt<R> {
    fn from(payload: StmtPass<R>) -> Self {
        Stmt::Pass(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct StmtBreak<R = TextRange> {
    pub range: R,
}

impl<R> From<StmtBreak<R>> for Stmt<R> {
    fn from(payload: StmtBreak<R>) -> Self {
        Stmt::Break(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct StmtContinue<R = TextRange> {
    pub range: R,
}

impl<R> From<StmtContinue<R>> for Stmt<R> {
    fn from(payload: StmtContinue<R>) -> Self {
        Stmt::Continue(payload)
    }
}

#[derive(Clone, Debug, PartialEq, is_macro::Is)]
pub enum Stmt<R = TextRange> {
    #[is(name = "function_def_stmt")]
    FunctionDef(StmtFunctionDef<R>),
    #[is(name = "async_function_def_stmt")]
    AsyncFunctionDef(StmtAsyncFunctionDef<R>),
    #[is(name = "class_def_stmt")]
    ClassDef(StmtClassDef<R>),
    #[is(name = "return_stmt")]
    Return(StmtReturn<R>),
    #[is(name = "delete_stmt")]
    Delete(StmtDelete<R>),
    #[is(name = "assign_stmt")]
    Assign(StmtAssign<R>),
    #[is(name = "aug_assign_stmt")]
    AugAssign(StmtAugAssign<R>),
    #[is(name = "ann_assign_stmt")]
    AnnAssign(StmtAnnAssign<R>),
    #[is(name = "for_stmt")]
    For(StmtFor<R>),
    #[is(name = "async_for_stmt")]
    AsyncFor(StmtAsyncFor<R>),
    #[is(name = "while_stmt")]
    While(StmtWhile<R>),
    #[is(name = "if_stmt")]
    If(StmtIf<R>),
    #[is(name = "with_stmt")]
    With(StmtWith<R>),
    #[is(name = "async_with_stmt")]
    AsyncWith(StmtAsyncWith<R>),
    #[is(name = "match_stmt")]
    Match(StmtMatch<R>),
    #[is(name = "raise_stmt")]
    Raise(StmtRaise<R>),
    #[is(name = "try_stmt")]
    Try(StmtTry<R>),
    #[is(name = "try_star_stmt")]
    TryStar(StmtTryStar<R>),
    #[is(name = "assert_stmt")]
    Assert(StmtAssert<R>),
    #[is(name = "import_stmt")]
    Import(StmtImport<R>),
    #[is(name = "import_from_stmt")]
    ImportFrom(StmtImportFrom<R>),
    #[is(name = "global_stmt")]
    Global(StmtGlobal<R>),
    #[is(name = "nonlocal_stmt")]
    Nonlocal(StmtNonlocal<R>),
    #[is(name = "expr_stmt")]
    Expr(StmtExpr<R>),
    #[is(name = "pass_stmt")]
    Pass(StmtPass<R>),
    #[is(name = "break_stmt")]
    Break(StmtBreak<R>),
    #[is(name = "continue_stmt")]
    Continue(StmtContinue<R>),
}

#[derive(Clone, Debug, PartialEq)]
pub struct ExprBoolOp<R = TextRange> {
    pub op: Boolop,
    pub values: Vec<Expr<R>>,
    pub range: R,
}

impl<R> From<ExprBoolOp<R>> for Expr<R> {
    fn from(payload: ExprBoolOp<R>) -> Self {
        Expr::BoolOp(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct ExprNamedExpr<R = TextRange> {
    pub target: Box<Expr<R>>,
    pub value: Box<Expr<R>>,
    pub range: R,
}

impl<R> From<ExprNamedExpr<R>> for Expr<R> {
    fn from(payload: ExprNamedExpr<R>) -> Self {
        Expr::NamedExpr(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct ExprBinOp<R = TextRange> {
    pub left: Box<Expr<R>>,
    pub op: Operator,
    pub right: Box<Expr<R>>,
    pub range: R,
}

impl<R> From<ExprBinOp<R>> for Expr<R> {
    fn from(payload: ExprBinOp<R>) -> Self {
        Expr::BinOp(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct ExprUnaryOp<R = TextRange> {
    pub op: Unaryop,
    pub operand: Box<Expr<R>>,
    pub range: R,
}

impl<R> From<ExprUnaryOp<R>> for Expr<R> {
    fn from(payload: ExprUnaryOp<R>) -> Self {
        Expr::UnaryOp(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct ExprLambda<R = TextRange> {
    pub args: Box<Arguments<R>>,
    pub body: Box<Expr<R>>,
    pub range: R,
}

impl<R> From<ExprLambda<R>> for Expr<R> {
    fn from(payload: ExprLambda<R>) -> Self {
        Expr::Lambda(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct ExprIfExp<R = TextRange> {
    pub test: Box<Expr<R>>,
    pub body: Box<Expr<R>>,
    pub orelse: Box<Expr<R>>,
    pub range: R,
}

impl<R> From<ExprIfExp<R>> for Expr<R> {
    fn from(payload: ExprIfExp<R>) -> Self {
        Expr::IfExp(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct ExprDict<R = TextRange> {
    pub keys: Vec<Option<Expr<R>>>,
    pub values: Vec<Expr<R>>,
    pub range: R,
}

impl<R> From<ExprDict<R>> for Expr<R> {
    fn from(payload: ExprDict<R>) -> Self {
        Expr::Dict(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct ExprSet<R = TextRange> {
    pub elts: Vec<Expr<R>>,
    pub range: R,
}

impl<R> From<ExprSet<R>> for Expr<R> {
    fn from(payload: ExprSet<R>) -> Self {
        Expr::Set(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct ExprListComp<R = TextRange> {
    pub elt: Box<Expr<R>>,
    pub generators: Vec<Comprehension<R>>,
    pub range: R,
}

impl<R> From<ExprListComp<R>> for Expr<R> {
    fn from(payload: ExprListComp<R>) -> Self {
        Expr::ListComp(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct ExprSetComp<R = TextRange> {
    pub elt: Box<Expr<R>>,
    pub generators: Vec<Comprehension<R>>,
    pub range: R,
}

impl<R> From<ExprSetComp<R>> for Expr<R> {
    fn from(payload: ExprSetComp<R>) -> Self {
        Expr::SetComp(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct ExprDictComp<R = TextRange> {
    pub key: Box<Expr<R>>,
    pub value: Box<Expr<R>>,
    pub generators: Vec<Comprehension<R>>,
    pub range: R,
}

impl<R> From<ExprDictComp<R>> for Expr<R> {
    fn from(payload: ExprDictComp<R>) -> Self {
        Expr::DictComp(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct ExprGeneratorExp<R = TextRange> {
    pub elt: Box<Expr<R>>,
    pub generators: Vec<Comprehension<R>>,
    pub range: R,
}

impl<R> From<ExprGeneratorExp<R>> for Expr<R> {
    fn from(payload: ExprGeneratorExp<R>) -> Self {
        Expr::GeneratorExp(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct ExprAwait<R = TextRange> {
    pub value: Box<Expr<R>>,
    pub range: R,
}

impl<R> From<ExprAwait<R>> for Expr<R> {
    fn from(payload: ExprAwait<R>) -> Self {
        Expr::Await(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct ExprYield<R = TextRange> {
    pub value: Option<Box<Expr<R>>>,
    pub range: R,
}

impl<R> From<ExprYield<R>> for Expr<R> {
    fn from(payload: ExprYield<R>) -> Self {
        Expr::Yield(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct ExprYieldFrom<R = TextRange> {
    pub value: Box<Expr<R>>,
    pub range: R,
}

impl<R> From<ExprYieldFrom<R>> for Expr<R> {
    fn from(payload: ExprYieldFrom<R>) -> Self {
        Expr::YieldFrom(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct ExprCompare<R = TextRange> {
    pub left: Box<Expr<R>>,
    pub ops: Vec<Cmpop>,
    pub comparators: Vec<Expr<R>>,
    pub range: R,
}

impl<R> From<ExprCompare<R>> for Expr<R> {
    fn from(payload: ExprCompare<R>) -> Self {
        Expr::Compare(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct ExprCall<R = TextRange> {
    pub func: Box<Expr<R>>,
    pub args: Vec<Expr<R>>,
    pub keywords: Vec<Keyword<R>>,
    pub range: R,
}

impl<R> From<ExprCall<R>> for Expr<R> {
    fn from(payload: ExprCall<R>) -> Self {
        Expr::Call(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct ExprFormattedValue<R = TextRange> {
    pub value: Box<Expr<R>>,
    pub conversion: Int,
    pub format_spec: Option<Box<Expr<R>>>,
    pub range: R,
}

impl<R> From<ExprFormattedValue<R>> for Expr<R> {
    fn from(payload: ExprFormattedValue<R>) -> Self {
        Expr::FormattedValue(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct ExprJoinedStr<R = TextRange> {
    pub values: Vec<Expr<R>>,
    pub range: R,
}

impl<R> From<ExprJoinedStr<R>> for Expr<R> {
    fn from(payload: ExprJoinedStr<R>) -> Self {
        Expr::JoinedStr(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct ExprConstant<R = TextRange> {
    pub value: Constant,
    pub kind: Option<String>,
    pub range: R,
}

impl<R> From<ExprConstant<R>> for Expr<R> {
    fn from(payload: ExprConstant<R>) -> Self {
        Expr::Constant(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct ExprAttribute<R = TextRange> {
    pub value: Box<Expr<R>>,
    pub attr: Identifier,
    pub ctx: ExprContext,
    pub range: R,
}

impl<R> From<ExprAttribute<R>> for Expr<R> {
    fn from(payload: ExprAttribute<R>) -> Self {
        Expr::Attribute(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct ExprSubscript<R = TextRange> {
    pub value: Box<Expr<R>>,
    pub slice: Box<Expr<R>>,
    pub ctx: ExprContext,
    pub range: R,
}

impl<R> From<ExprSubscript<R>> for Expr<R> {
    fn from(payload: ExprSubscript<R>) -> Self {
        Expr::Subscript(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct ExprStarred<R = TextRange> {
    pub value: Box<Expr<R>>,
    pub ctx: ExprContext,
    pub range: R,
}

impl<R> From<ExprStarred<R>> for Expr<R> {
    fn from(payload: ExprStarred<R>) -> Self {
        Expr::Starred(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct ExprName<R = TextRange> {
    pub id: Identifier,
    pub ctx: ExprContext,
    pub range: R,
}

impl<R> From<ExprName<R>> for Expr<R> {
    fn from(payload: ExprName<R>) -> Self {
        Expr::Name(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct ExprList<R = TextRange> {
    pub elts: Vec<Expr<R>>,
    pub ctx: ExprContext,
    pub range: R,
}

impl<R> From<ExprList<R>> for Expr<R> {
    fn from(payload: ExprList<R>) -> Self {
        Expr::List(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct ExprTuple<R = TextRange> {
    pub elts: Vec<Expr<R>>,
    pub ctx: ExprContext,
    pub range: R,
}

impl<R> From<ExprTuple<R>> for Expr<R> {
    fn from(payload: ExprTuple<R>) -> Self {
        Expr::Tuple(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct ExprSlice<R = TextRange> {
    pub lower: Option<Box<Expr<R>>>,
    pub upper: Option<Box<Expr<R>>>,
    pub step: Option<Box<Expr<R>>>,
    pub range: R,
}

impl<R> From<ExprSlice<R>> for Expr<R> {
    fn from(payload: ExprSlice<R>) -> Self {
        Expr::Slice(payload)
    }
}

#[derive(Clone, Debug, PartialEq, is_macro::Is)]
pub enum Expr<R = TextRange> {
    #[is(name = "bool_op_expr")]
    BoolOp(ExprBoolOp<R>),
    #[is(name = "named_expr_expr")]
    NamedExpr(ExprNamedExpr<R>),
    #[is(name = "bin_op_expr")]
    BinOp(ExprBinOp<R>),
    #[is(name = "unary_op_expr")]
    UnaryOp(ExprUnaryOp<R>),
    #[is(name = "lambda_expr")]
    Lambda(ExprLambda<R>),
    #[is(name = "if_exp_expr")]
    IfExp(ExprIfExp<R>),
    #[is(name = "dict_expr")]
    Dict(ExprDict<R>),
    #[is(name = "set_expr")]
    Set(ExprSet<R>),
    #[is(name = "list_comp_expr")]
    ListComp(ExprListComp<R>),
    #[is(name = "set_comp_expr")]
    SetComp(ExprSetComp<R>),
    #[is(name = "dict_comp_expr")]
    DictComp(ExprDictComp<R>),
    #[is(name = "generator_exp_expr")]
    GeneratorExp(ExprGeneratorExp<R>),
    #[is(name = "await_expr")]
    Await(ExprAwait<R>),
    #[is(name = "yield_expr")]
    Yield(ExprYield<R>),
    #[is(name = "yield_from_expr")]
    YieldFrom(ExprYieldFrom<R>),
    #[is(name = "compare_expr")]
    Compare(ExprCompare<R>),
    #[is(name = "call_expr")]
    Call(ExprCall<R>),
    #[is(name = "formatted_value_expr")]
    FormattedValue(ExprFormattedValue<R>),
    #[is(name = "joined_str_expr")]
    JoinedStr(ExprJoinedStr<R>),
    #[is(name = "constant_expr")]
    Constant(ExprConstant<R>),
    #[is(name = "attribute_expr")]
    Attribute(ExprAttribute<R>),
    #[is(name = "subscript_expr")]
    Subscript(ExprSubscript<R>),
    #[is(name = "starred_expr")]
    Starred(ExprStarred<R>),
    #[is(name = "name_expr")]
    Name(ExprName<R>),
    #[is(name = "list_expr")]
    List(ExprList<R>),
    #[is(name = "tuple_expr")]
    Tuple(ExprTuple<R>),
    #[is(name = "slice_expr")]
    Slice(ExprSlice<R>),
}

#[derive(Clone, Debug, PartialEq, is_macro::Is, Copy, Hash, Eq)]
pub enum ExprContext {
    Load,
    Store,
    Del,
}

#[derive(Clone, Debug, PartialEq, is_macro::Is, Copy, Hash, Eq)]
pub enum Boolop {
    And,
    Or,
}

#[derive(Clone, Debug, PartialEq, is_macro::Is, Copy, Hash, Eq)]
pub enum Operator {
    Add,
    Sub,
    Mult,
    MatMult,
    Div,
    Mod,
    Pow,
    LShift,
    RShift,
    BitOr,
    BitXor,
    BitAnd,
    FloorDiv,
}

#[derive(Clone, Debug, PartialEq, is_macro::Is, Copy, Hash, Eq)]
pub enum Unaryop {
    Invert,
    Not,
    UAdd,
    USub,
}

#[derive(Clone, Debug, PartialEq, is_macro::Is, Copy, Hash, Eq)]
pub enum Cmpop {
    Eq,
    NotEq,
    Lt,
    LtE,
    Gt,
    GtE,
    Is,
    IsNot,
    In,
    NotIn,
}

#[derive(Clone, Debug, PartialEq)]
pub struct Comprehension<R = TextRange> {
    pub target: Expr<R>,
    pub iter: Expr<R>,
    pub ifs: Vec<Expr<R>>,
    pub is_async: bool,
    #[cfg(feature = "all-nodes-with-ranges")]
    pub range: R,
    #[cfg(not(feature = "all-nodes-with-ranges"))]
    pub range: crate::EmptyRange<R>,
}

#[derive(Clone, Debug, PartialEq)]
pub struct ExcepthandlerExceptHandler<R = TextRange> {
    pub type_: Option<Box<Expr<R>>>,
    pub name: Option<Identifier>,
    pub body: Vec<Stmt<R>>,
    pub range: R,
}

impl<R> From<ExcepthandlerExceptHandler<R>> for Excepthandler<R> {
    fn from(payload: ExcepthandlerExceptHandler<R>) -> Self {
        Excepthandler::ExceptHandler(payload)
    }
}

#[derive(Clone, Debug, PartialEq, is_macro::Is)]
pub enum Excepthandler<R = TextRange> {
    ExceptHandler(ExcepthandlerExceptHandler<R>),
}

#[derive(Clone, Debug, PartialEq)]
pub struct Arguments<R = TextRange> {
    pub posonlyargs: Vec<Arg<R>>,
    pub args: Vec<Arg<R>>,
    pub vararg: Option<Box<Arg<R>>>,
    pub kwonlyargs: Vec<Arg<R>>,
    pub kw_defaults: Vec<Expr<R>>,
    pub kwarg: Option<Box<Arg<R>>>,
    pub defaults: Vec<Expr<R>>,
    #[cfg(feature = "all-nodes-with-ranges")]
    pub range: R,
    #[cfg(not(feature = "all-nodes-with-ranges"))]
    pub range: crate::EmptyRange<R>,
}

#[derive(Clone, Debug, PartialEq)]
pub struct Arg<R = TextRange> {
    pub arg: Identifier,
    pub annotation: Option<Box<Expr<R>>>,
    pub type_comment: Option<String>,
    pub range: R,
}

#[derive(Clone, Debug, PartialEq)]
pub struct Keyword<R = TextRange> {
    pub arg: Option<Identifier>,
    pub value: Expr<R>,
    pub range: R,
}

#[derive(Clone, Debug, PartialEq)]
pub struct Alias<R = TextRange> {
    pub name: Identifier,
    pub asname: Option<Identifier>,
    pub range: R,
}

#[derive(Clone, Debug, PartialEq)]
pub struct Withitem<R = TextRange> {
    pub context_expr: Expr<R>,
    pub optional_vars: Option<Box<Expr<R>>>,
    #[cfg(feature = "all-nodes-with-ranges")]
    pub range: R,
    #[cfg(not(feature = "all-nodes-with-ranges"))]
    pub range: crate::EmptyRange<R>,
}

#[derive(Clone, Debug, PartialEq)]
pub struct MatchCase<R = TextRange> {
    pub pattern: Pattern<R>,
    pub guard: Option<Box<Expr<R>>>,
    pub body: Vec<Stmt<R>>,
    #[cfg(feature = "all-nodes-with-ranges")]
    pub range: R,
    #[cfg(not(feature = "all-nodes-with-ranges"))]
    pub range: crate::EmptyRange<R>,
}

#[derive(Clone, Debug, PartialEq)]
pub struct PatternMatchValue<R = TextRange> {
    pub value: Box<Expr<R>>,
    pub range: R,
}

impl<R> From<PatternMatchValue<R>> for Pattern<R> {
    fn from(payload: PatternMatchValue<R>) -> Self {
        Pattern::MatchValue(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct PatternMatchSingleton<R = TextRange> {
    pub value: Constant,
    pub range: R,
}

impl<R> From<PatternMatchSingleton<R>> for Pattern<R> {
    fn from(payload: PatternMatchSingleton<R>) -> Self {
        Pattern::MatchSingleton(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct PatternMatchSequence<R = TextRange> {
    pub patterns: Vec<Pattern<R>>,
    pub range: R,
}

impl<R> From<PatternMatchSequence<R>> for Pattern<R> {
    fn from(payload: PatternMatchSequence<R>) -> Self {
        Pattern::MatchSequence(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct PatternMatchMapping<R = TextRange> {
    pub keys: Vec<Expr<R>>,
    pub patterns: Vec<Pattern<R>>,
    pub rest: Option<Identifier>,
    pub range: R,
}

impl<R> From<PatternMatchMapping<R>> for Pattern<R> {
    fn from(payload: PatternMatchMapping<R>) -> Self {
        Pattern::MatchMapping(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct PatternMatchClass<R = TextRange> {
    pub cls: Box<Expr<R>>,
    pub patterns: Vec<Pattern<R>>,
    pub kwd_attrs: Vec<Identifier>,
    pub kwd_patterns: Vec<Pattern<R>>,
    pub range: R,
}

impl<R> From<PatternMatchClass<R>> for Pattern<R> {
    fn from(payload: PatternMatchClass<R>) -> Self {
        Pattern::MatchClass(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct PatternMatchStar<R = TextRange> {
    pub name: Option<Identifier>,
    pub range: R,
}

impl<R> From<PatternMatchStar<R>> for Pattern<R> {
    fn from(payload: PatternMatchStar<R>) -> Self {
        Pattern::MatchStar(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct PatternMatchAs<R = TextRange> {
    pub pattern: Option<Box<Pattern<R>>>,
    pub name: Option<Identifier>,
    pub range: R,
}

impl<R> From<PatternMatchAs<R>> for Pattern<R> {
    fn from(payload: PatternMatchAs<R>) -> Self {
        Pattern::MatchAs(payload)
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct PatternMatchOr<R = TextRange> {
    pub patterns: Vec<Pattern<R>>,
    pub range: R,
}

impl<R> From<PatternMatchOr<R>> for Pattern<R> {
    fn from(payload: PatternMatchOr<R>) -> Self {
        Pattern::MatchOr(payload)
    }
}

#[derive(Clone, Debug, PartialEq, is_macro::Is)]
pub enum Pattern<R = TextRange> {
    MatchValue(PatternMatchValue<R>),
    MatchSingleton(PatternMatchSingleton<R>),
    MatchSequence(PatternMatchSequence<R>),
    MatchMapping(PatternMatchMapping<R>),
    MatchClass(PatternMatchClass<R>),
    MatchStar(PatternMatchStar<R>),
    MatchAs(PatternMatchAs<R>),
    MatchOr(PatternMatchOr<R>),
}

#[derive(Clone, Debug, PartialEq)]
pub struct TypeIgnoreTypeIgnore<R = TextRange> {
    pub lineno: Int,
    pub tag: String,
    #[cfg(feature = "all-nodes-with-ranges")]
    pub range: R,
    #[cfg(not(feature = "all-nodes-with-ranges"))]
    pub range: crate::EmptyRange<R>,
}

impl<R> From<TypeIgnoreTypeIgnore<R>> for TypeIgnore<R> {
    fn from(payload: TypeIgnoreTypeIgnore<R>) -> Self {
        TypeIgnore::TypeIgnore(payload)
    }
}

#[derive(Clone, Debug, PartialEq, is_macro::Is)]
pub enum TypeIgnore<R = TextRange> {
    TypeIgnore(TypeIgnoreTypeIgnore<R>),
}