Struct rustpython_ast::ConstantOptimizer

#[non_exhaustive]
pub struct ConstantOptimizer {}

Implementations

impl ConstantOptimizer

pub fn new() -> Self

Trait Implementations

impl Default for ConstantOptimizer

fn default() -> ConstantOptimizer

Returns the “default value” for a type.

impl<U> Fold<U> for ConstantOptimizer

type TargetU = U

type Error = Infallible

fn map_user(&mut self, user: U) -> Result<Self::TargetU, Self::Error>

fn fold_expr(&mut self, node: Expr<U>) -> Result<Expr<U>, Self::Error>

fn fold_mod(&mut self, node: Mod<U>) -> Result<Mod<Self::TargetU>, Self::Error>

fn fold_stmt(
    &mut self,
    node: Stmt<U>
) -> Result<Stmt<Self::TargetU>, Self::Error>

fn fold_expr_context(
    &mut self,
    node: ExprContext
) -> Result<ExprContext, Self::Error>

fn fold_boolop(&mut self, node: Boolop) -> Result<Boolop, Self::Error>

fn fold_operator(&mut self, node: Operator) -> Result<Operator, Self::Error>

fn fold_unaryop(&mut self, node: Unaryop) -> Result<Unaryop, Self::Error>

fn fold_cmpop(&mut self, node: Cmpop) -> Result<Cmpop, Self::Error>

fn fold_comprehension(
    &mut self,
    node: Comprehension<U>
) -> Result<Comprehension<Self::TargetU>, Self::Error>

fn fold_excepthandler(
    &mut self,
    node: Excepthandler<U>
) -> Result<Excepthandler<Self::TargetU>, Self::Error>

fn fold_arguments(
    &mut self,
    node: Arguments<U>
) -> Result<Arguments<Self::TargetU>, Self::Error>

fn fold_arg(&mut self, node: Arg<U>) -> Result<Arg<Self::TargetU>, Self::Error>

fn fold_keyword(
    &mut self,
    node: Keyword<U>
) -> Result<Keyword<Self::TargetU>, Self::Error>

fn fold_alias(
    &mut self,
    node: Alias<U>
) -> Result<Alias<Self::TargetU>, Self::Error>

fn fold_withitem(
    &mut self,
    node: Withitem<U>
) -> Result<Withitem<Self::TargetU>, Self::Error>

fn fold_match_case(
    &mut self,
    node: MatchCase<U>
) -> Result<MatchCase<Self::TargetU>, Self::Error>

fn fold_pattern(
    &mut self,
    node: Pattern<U>
) -> Result<Pattern<Self::TargetU>, Self::Error>

fn fold_type_ignore(
    &mut self,
    node: TypeIgnore
) -> Result<TypeIgnore, Self::Error>