matches!(

stmt,

Stmt::FunctionDef(_)

| Stmt::ClassDef(_)

| Stmt::While(_)

| Stmt::For(_)

| Stmt::Match(_)

| Stmt::With(_)

| Stmt::If(_)

| Stmt::Try(_)

)

F: Fn(&str) -> bool,

matches!(id, "list" | "tuple" | "set" | "dict" | "frozenset") && is_builtin(id)

/// The expression is definitely side-effect-free.

Absent,

/// The expression may have side effects (e.g., f-string interpolation

/// may invoke `__format__` or `__str__`).

Possible,

/// The expression is assumed to have side effects.

Present,

pub const fn is_present(self) -> bool {

matches!(self, Self::Present)

}

pub const fn is_absent(self) -> bool {

matches!(self, Self::Absent)

}

#[must_use]

pub const fn merge(self, other: Self) -> Self {

match (self, other) {

(Self::Present, _) | (_, Self::Present) => Self::Present,

(Self::Possible, _) | (_, Self::Possible) => Self::Possible,

_ => Self::Absent,

}

}

/// Classify a single expression node's side effect.

fn from_expr(expr: &Expr, is_builtin: &dyn Fn(&str) -> bool) -> Self {

match expr {

// Empty initializers for known builtins are side-effect-free.

Expr::Call(ast::ExprCall {

func, arguments, ..

}) if arguments.is_empty() => {

if let Expr::Name(ast::ExprName { id, .. }) = func.as_ref() {

if is_iterable_initializer(id.as_str(), |id| is_builtin(id)) {

return Self::Absent;

}

}

Self::Present

}

// Overloaded operators: only side-effect-free if both sides are literals.

Expr::BinOp(ast::ExprBinOp { left, right, .. }) => {

if is_known_safe_binop_operand(left) && is_known_safe_binop_operand(right) {

Self::Absent

} else {

Self::Present

}

}

// Non-literal f-string interpolation may invoke `__format__`/`__str__`.

Expr::FString(ast::ExprFString { value, .. }) => {

if value.elements().any(has_uncertain_interpolation) {

Self::Possible

} else {

Self::Absent

}

}

Expr::TString(ast::ExprTString { value, .. }) => {

if value.elements().any(has_uncertain_interpolation) {

Self::Possible

} else {

Self::Absent

}

}

// Named expressions (walrus operator) are assignments.

Expr::Named(_) => Self::Present,

// Complex expressions that are assumed to have side effects.

Expr::Await(_)

| Expr::Call(_)

| Expr::DictComp(_)

| Expr::Generator(_)

| Expr::ListComp(_)

| Expr::SetComp(_)

| Expr::Subscript(_)

| Expr::Yield(_)

| Expr::YieldFrom(_)

| Expr::IpyEscapeCommand(_) => Self::Present,

// Side-effect-free expressions — continue walking child nodes.

Expr::BoolOp(_)

| Expr::Compare(_)

| Expr::Dict(_)

| Expr::If(_)

| Expr::Lambda(_)

| Expr::List(_)

| Expr::Set(_)

| Expr::Slice(_)

| Expr::Starred(_)

| Expr::Tuple(_)

| Expr::UnaryOp(_)

| Expr::Attribute(_)

| Expr::Name(_)

| Expr::StringLiteral(_)

| Expr::BytesLiteral(_)

| Expr::NumberLiteral(_)

| Expr::Constant(_)

| Expr::BooleanLiteral(_)

| Expr::NoneLiteral(_)

| Expr::EllipsisLiteral(_) => Self::Absent,

}

}

match expr {

Expr::StringLiteral(_)

| Expr::BytesLiteral(_)

| Expr::NumberLiteral(_)

| Expr::Constant(_)

| Expr::BooleanLiteral(_)

| Expr::NoneLiteral(_)

| Expr::EllipsisLiteral(_)

| Expr::FString(_)

| Expr::List(_)

| Expr::Tuple(_)

| Expr::Set(_)

| Expr::Dict(_)

| Expr::ListComp(_)

| Expr::SetComp(_)

| Expr::DictComp(_) => true,

Expr::BoolOp(_)

| Expr::Named(_)

| Expr::BinOp(_)

| Expr::UnaryOp(_)

| Expr::Lambda(_)

| Expr::If(_)

| Expr::Compare(_)

| Expr::Call(_)

| Expr::Generator(_)

| Expr::Await(_)

| Expr::Yield(_)

| Expr::YieldFrom(_)

| Expr::Attribute(_)

| Expr::Subscript(_)

| Expr::Starred(_)

| Expr::Name(_)

| Expr::Slice(_)

| Expr::IpyEscapeCommand(_)

| Expr::TString(_) => false,

}

matches!(

expr,

Expr::NumberLiteral(_)

| Expr::Constant(_)

| Expr::BooleanLiteral(_)

| Expr::NoneLiteral(_)

| Expr::EllipsisLiteral(_)

| Expr::StringLiteral(_)

| Expr::BytesLiteral(_)

)

match element {

InterpolatedStringElement::Literal(_) => false,

InterpolatedStringElement::Interpolation(interp) => {

!is_definitely_side_effect_free_interpolation_expr(&interp.expression)

|| interp

.format_spec

.as_ref()

.is_some_and(|spec| spec.elements.iter().any(has_uncertain_interpolation))

}

}

F: Fn(&str) -> bool,

side_effect(expr, is_builtin).is_present()

F: Fn(&str) -> bool,

let mut effect = SideEffect::Absent;

any_over_expr(expr, |expr| {

match SideEffect::from_expr(expr, &is_builtin) {

SideEffect::Present => {

effect = SideEffect::Present;

true

}

SideEffect::Possible => {

effect = effect.merge(SideEffect::Possible);

false

}

SideEffect::Absent => false,

}

});

effect

F: FnMut(&Expr) -> bool,

fn inner(expr: &Expr, func: &mut dyn FnMut(&Expr) -> bool) -> bool {

if func(expr) {

return true;

}

match expr {

Expr::BoolOp(ast::ExprBoolOp { values, .. }) => {

values.iter().any(|expr| any_over_expr(expr, &mut *func))

}

Expr::FString(ast::ExprFString { value, .. }) => value

.elements()

.any(|expr| any_over_interpolated_string_element(expr, &mut *func)),

Expr::TString(ast::ExprTString { value, .. }) => value

.elements()

.any(|expr| any_over_interpolated_string_element(expr, &mut *func)),

Expr::Named(ast::ExprNamed {

target,

value,

range: _,

node_index: _,

}) => any_over_expr(target, &mut *func) || any_over_expr(value, &mut *func),

Expr::BinOp(ast::ExprBinOp { left, right, .. }) => {

any_over_expr(left, &mut *func) || any_over_expr(right, &mut *func)

}

Expr::UnaryOp(ast::ExprUnaryOp { operand, .. }) => any_over_expr(operand, func),

Expr::Lambda(ast::ExprLambda {

body, parameters, ..

}) => {

parameters

.iter()

.flat_map(|parameters| parameters.iter_non_variadic_params())

.filter_map(|parameter| parameter.default.as_deref())

.any(|default| any_over_expr(default, &mut *func))

|| any_over_expr(body, func)

}

Expr::If(ast::ExprIf {

test,

body,

orelse,

range: _,

node_index: _,

}) => {

any_over_expr(test, &mut *func)

|| any_over_expr(body, &mut *func)

|| any_over_expr(orelse, &mut *func)

}

Expr::Dict(ast::ExprDict { items, .. }) => {

items.iter().any(|ast::DictItem { key, value }| {

any_over_expr(value, &mut *func)

|| key

.as_ref()

.is_some_and(|key| any_over_expr(key, &mut *func))

})

}

Expr::Set(ast::ExprSet { elts, .. })

| Expr::List(ast::ExprList { elts, .. })

| Expr::Tuple(ast::ExprTuple { elts, .. }) => {

elts.iter().any(|expr| any_over_expr(expr, &mut *func))

}

Expr::ListComp(ast::ExprListComp {

elt,

generators,

range: _,

node_index: _,

})

| Expr::SetComp(ast::ExprSetComp {

elt,

generators,

range: _,

node_index: _,

})

| Expr::Generator(ast::ExprGenerator {

elt,

generators,

range: _,

node_index: _,

parenthesized: _,

}) => {

any_over_expr(elt, &mut *func)

|| generators.iter().any(|generator| {

any_over_expr(&generator.target, &mut *func)

|| any_over_expr(&generator.iter, &mut *func)

|| generator

.ifs

.iter()

.any(|expr| any_over_expr(expr, &mut *func))

})

}

Expr::DictComp(ast::ExprDictComp {

key,

value,

generators,

range: _,

node_index: _,

}) => {

key.as_deref()

.is_some_and(|key| any_over_expr(key, &mut *func))

|| any_over_expr(value, &mut *func)

|| generators.iter().any(|generator| {

any_over_expr(&generator.target, &mut *func)

|| any_over_expr(&generator.iter, &mut *func)

|| generator

.ifs

.iter()

.any(|expr| any_over_expr(expr, &mut *func))

})

}

Expr::Await(ast::ExprAwait {

value,

range: _,

node_index: _,

})

| Expr::YieldFrom(ast::ExprYieldFrom {

value,

range: _,

node_index: _,

})

| Expr::Attribute(ast::ExprAttribute { value, .. })

| Expr::Starred(ast::ExprStarred { value, .. }) => any_over_expr(value, func),

Expr::Yield(ast::ExprYield {

value,

range: _,

node_index: _,

}) => value

.as_ref()

.is_some_and(|value| any_over_expr(value, func)),

Expr::Compare(ast::ExprCompare { operands, .. }) => {

operands.iter().any(|expr| any_over_expr(expr, &mut *func))

}

Expr::Call(ast::ExprCall {

func: call_func,

arguments,

range_start: _,

node_index: _,

}) => {

// Note that this is the evaluation order but not necessarily the declaration order

// (e.g. for `f(*args, a=2, *args2, **kwargs)` it's not)

any_over_expr(call_func, &mut *func)

|| arguments

.args

.iter()

.any(|expr| any_over_expr(expr, &mut *func))

|| arguments

.keywords

.iter()

.any(|keyword| any_over_expr(&keyword.value, &mut *func))

}

Expr::Subscript(ast::ExprSubscript { value, slice, .. }) => {

any_over_expr(value, &mut *func) || any_over_expr(slice, &mut *func)

}

Expr::Slice(ast::ExprSlice {

lower,

upper,

step,

range: _,

node_index: _,

}) => {

lower

.as_ref()

.is_some_and(|value| any_over_expr(value, &mut *func))

|| upper

.as_ref()

.is_some_and(|value| any_over_expr(value, &mut *func))

|| step

.as_ref()

.is_some_and(|value| any_over_expr(value, &mut *func))

}

Expr::Name(_)

| Expr::StringLiteral(_)

| Expr::BytesLiteral(_)

| Expr::NumberLiteral(_)

| Expr::Constant(_)

| Expr::BooleanLiteral(_)

| Expr::NoneLiteral(_)

| Expr::EllipsisLiteral(_)

| Expr::IpyEscapeCommand(_) => false,

}

}

inner(expr, &mut func)

match type_param {

TypeParam::TypeVar(ast::TypeParamTypeVar { bound, default, .. }) => {

bound

.as_ref()

.is_some_and(|value| any_over_expr(value, &mut *func))

|| default

.as_ref()

.is_some_and(|value| any_over_expr(value, &mut *func))

}

TypeParam::TypeVarTuple(ast::TypeParamTypeVarTuple { default, .. }) => default

.as_ref()

.is_some_and(|value| any_over_expr(value, &mut *func)),

TypeParam::ParamSpec(ast::TypeParamParamSpec { default, .. }) => default

.as_ref()

.is_some_and(|value| any_over_expr(value, &mut *func)),

}

match pattern {

Pattern::MatchValue(ast::PatternMatchValue {

value,

range: _,

node_index: _,

}) => any_over_expr(value, func),

Pattern::MatchSingleton(_) => false,

Pattern::MatchSequence(ast::PatternMatchSequence { patterns, .. }) => patterns

.iter()

.any(|pattern| any_over_pattern(pattern, &mut *func)),

Pattern::MatchMapping(ast::PatternMatchMapping { keys, patterns, .. }) => {

keys.iter().any(|key| any_over_expr(key, &mut *func))

|| patterns

.iter()

.any(|pattern| any_over_pattern(pattern, &mut *func))

}

Pattern::MatchClass(ast::PatternMatchClass { cls, arguments, .. }) => {

any_over_expr(cls, &mut *func)

|| arguments

.patterns

.iter()

.any(|pattern| any_over_pattern(pattern, &mut *func))

|| arguments

.keywords

.iter()

.any(|keyword| any_over_pattern(&keyword.pattern, &mut *func))

}

Pattern::MatchStar(_) => false,

Pattern::MatchAs(ast::PatternMatchAs { pattern, .. }) => pattern

.as_ref()

.is_some_and(|pattern| any_over_pattern(pattern, func)),

Pattern::MatchOr(ast::PatternMatchOr { patterns, .. }) => patterns

.iter()

.any(|pattern| any_over_pattern(pattern, &mut *func)),

}

element: &ast::InterpolatedStringElement,

func: &mut dyn FnMut(&Expr) -> bool,

) -> bool {

match element {

ast::InterpolatedStringElement::Literal(_) => false,

ast::InterpolatedStringElement::Interpolation(ast::InterpolatedElement {

expression,

format_spec,

..

}) => {

any_over_expr(expression, &mut *func)

|| format_spec.as_ref().is_some_and(|spec| {

spec.elements.iter().any(|spec_element| {

any_over_interpolated_string_element(spec_element, &mut *func)

})

})

}

}

F: FnMut(&Expr) -> bool,

fn inner(stmt: &Stmt, func: &mut dyn FnMut(&Expr) -> bool) -> bool {

match stmt {

Stmt::FunctionDef(ast::StmtFunctionDef {

parameters,

type_params,

body,

decorator_list,

returns,

..

}) => {

parameters.iter().any(|param| {

param

.default()

.is_some_and(|default| any_over_expr(default, &mut *func))

|| param

.annotation()

.is_some_and(|annotation| any_over_expr(annotation, &mut *func))

}) || type_params.as_ref().is_some_and(|type_params| {

type_params

.iter()

.any(|type_param| any_over_type_param(type_param, &mut *func))

}) || body.iter().any(|stmt| any_over_stmt(stmt, &mut *func))

|| decorator_list

.iter()

.any(|decorator| any_over_expr(&decorator.expression, &mut *func))

|| returns

.as_ref()

.is_some_and(|value| any_over_expr(value, func))

}

Stmt::ClassDef(ast::StmtClassDef {

arguments,

type_params,

body,

decorator_list,

..

}) => {

// Note that e.g. `class A(*args, a=2, *args2, **kwargs): pass` is a valid class

// definition

arguments

.as_deref()

.is_some_and(|Arguments { args, keywords, .. }| {

args.iter().any(|expr| any_over_expr(expr, &mut *func))

|| keywords

.iter()

.any(|keyword| any_over_expr(&keyword.value, &mut *func))

})

|| type_params.as_ref().is_some_and(|type_params| {

type_params

.iter()

.any(|type_param| any_over_type_param(type_param, &mut *func))

})

|| body.iter().any(|stmt| any_over_stmt(stmt, &mut *func))

|| decorator_list

.iter()

.any(|decorator| any_over_expr(&decorator.expression, &mut *func))

}

Stmt::Return(ast::StmtReturn {

value,

range: _,

node_index: _,

}) => value

.as_ref()

.is_some_and(|value| any_over_expr(value, func)),

Stmt::Delete(ast::StmtDelete { targets, .. }) => {

targets.iter().any(|expr| any_over_expr(expr, &mut *func))

}

Stmt::TypeAlias(ast::StmtTypeAlias {

name,

type_params,

value,

..

}) => {

any_over_expr(name, &mut *func)

|| type_params.as_ref().is_some_and(|type_params| {

type_params

.iter()

.any(|type_param| any_over_type_param(type_param, &mut *func))

})

|| any_over_expr(value, func)

}

Stmt::Assign(ast::StmtAssign { targets, value, .. }) => {

targets.iter().any(|expr| any_over_expr(expr, &mut *func))

|| any_over_expr(value, func)

}

Stmt::AugAssign(ast::StmtAugAssign { target, value, .. }) => {

any_over_expr(target, &mut *func) || any_over_expr(value, &mut *func)

}

Stmt::AnnAssign(ast::StmtAnnAssign {

target,

annotation,

value,

..

}) => {

any_over_expr(target, &mut *func)

|| any_over_expr(annotation, &mut *func)

|| value

.as_ref()

.is_some_and(|value| any_over_expr(value, &mut *func))

}

Stmt::For(ast::StmtFor {

target,

iter,

body,

orelse,

..

}) => {

any_over_expr(target, &mut *func)

|| any_over_expr(iter, &mut *func)

|| any_over_body(body, &mut *func)

|| any_over_body(orelse, &mut *func)

}

Stmt::While(ast::StmtWhile {

test, body, orelse, ..

}) => {

any_over_expr(test, &mut *func)

|| any_over_body(body, &mut *func)

|| any_over_body(orelse, &mut *func)

}

Stmt::If(ast::StmtIf {

test,

body,

elif_else_clauses,

..

}) => {

any_over_expr(test, &mut *func)

|| any_over_body(body, &mut *func)

|| elif_else_clauses.iter().any(|clause| {

clause

.test

.as_ref()

.is_some_and(|test| any_over_expr(test, &mut *func))

|| any_over_body(&clause.body, &mut *func)

})

}

Stmt::With(ast::StmtWith { items, body, .. }) => {

items.iter().any(|with_item| {

any_over_expr(&with_item.context_expr, &mut *func)

|| with_item

.optional_vars

.as_ref()

.is_some_and(|expr| any_over_expr(expr, &mut *func))

}) || any_over_body(body, &mut *func)

}

Stmt::Raise(ast::StmtRaise {

exc,

cause,

range: _,

node_index: _,

}) => {

exc.as_ref()

.is_some_and(|value| any_over_expr(value, &mut *func))

|| cause

.as_ref()

.is_some_and(|value| any_over_expr(value, &mut *func))

}

Stmt::Try(ast::StmtTry {

body,

handlers,

orelse,

finalbody,

..

}) => {

any_over_body(body, &mut *func)

|| handlers.iter().any(|handler| {

let ExceptHandler::ExceptHandler(ast::ExceptHandlerExceptHandler {

type_,

body,

..

}) = handler;

type_

.as_ref()

.is_some_and(|expr| any_over_expr(expr, &mut *func))

|| any_over_body(body, &mut *func)

})

|| any_over_body(orelse, &mut *func)

|| any_over_body(finalbody, &mut *func)

}

Stmt::Assert(ast::StmtAssert {

test,

msg,

range: _,

node_index: _,

}) => {

any_over_expr(test, &mut *func)

|| msg

.as_ref()

.is_some_and(|value| any_over_expr(value, &mut *func))

}

Stmt::Match(ast::StmtMatch {

subject,

cases,

range: _,

node_index: _,

}) => {

any_over_expr(subject, &mut *func)

|| cases.iter().any(|case| {

let MatchCase {

pattern,

guard,

body,

..

} = case;

any_over_pattern(pattern, &mut *func)

|| guard

.as_ref()

.is_some_and(|expr| any_over_expr(expr, &mut *func))

|| any_over_body(body, &mut *func)

})

}

Stmt::Import(_) => false,

Stmt::ImportFrom(_) => false,

Stmt::Global(_) => false,

Stmt::Nonlocal(_) => false,

Stmt::Expr(ast::StmtExpr {

value,

range: _,

node_index: _,

}) => any_over_expr(value, func),

Stmt::Pass(_) | Stmt::Break(_) | Stmt::Continue(_) => false,

Stmt::IpyEscapeCommand(_) => false,

}

}

inner(stmt, &mut func)

F: FnMut(&Expr) -> bool,

body.iter().any(|stmt| any_over_stmt(stmt, &mut func))

// Check whether it's an assignment to a dunder, with or without a type

// annotation. This is what pycodestyle (as of 2.9.1) does.

match stmt {

Stmt::Assign(ast::StmtAssign { targets, .. }) => {

if let [Expr::Name(ast::ExprName { id, .. })] = targets.as_slice() {

is_dunder(id)

} else {

false

}

}

Stmt::AnnAssign(ast::StmtAnnAssign { target, .. }) => {

if let Expr::Name(ast::ExprName { id, .. }) = target.as_ref() {

is_dunder(id)

} else {

false

}

}

_ => false,

}

matches!(

expr,

Expr::NoneLiteral(_)

| Expr::BooleanLiteral(_)

| Expr::EllipsisLiteral(_)

| Expr::Constant(ast::ExprConstant {

value: ConstantValue::None | ConstantValue::Boolean(_) | ConstantValue::Ellipsis,

..

})

)

if let Expr::Tuple(tuple) = expr {

tuple.iter().all(is_constant)

} else {

expr.is_literal_expr()

}

matches!(

expr,

Expr::BooleanLiteral(ast::ExprBooleanLiteral { value: true, .. }),

)

matches!(

expr,

Expr::BooleanLiteral(ast::ExprBooleanLiteral { value: false, .. }),

)

matches!(

expr,

Expr::Set(_)

| Expr::SetComp(_)

| Expr::List(_)

| Expr::ListComp(_)

| Expr::Dict(_)

| Expr::DictComp(_)

)

let mut handled_exceptions = Vec::new();

for handler in handlers {

match handler {

ExceptHandler::ExceptHandler(ast::ExceptHandlerExceptHandler { type_, .. }) => {

if let Some(type_) = type_ {

if let Expr::Tuple(tuple) = &**type_ {

for type_ in tuple {

handled_exceptions.push(type_);

}