use crate::ast::{
Comprehension, ExceptHandler, Expr, FStrPart, Keyword, MatchCase, Params, Pattern, Stmt,
StmtKind, WithItem,
};
pub fn mangle(class: &str, name: &str) -> Option<String> {
if !name.starts_with("__") || name.ends_with("__") {
return None;
}
let stripped = class.trim_start_matches('_');
if stripped.is_empty() {
return None;
}
Some(format!("_{stripped}{name}"))
}
fn fix(class: &str, name: &mut String) {
if let Some(m) = mangle(class, name) {
*name = m;
}
}
pub fn has_class(body: &[Stmt]) -> bool {
body.iter().any(|s| match &s.kind {
StmtKind::ClassDef { .. } => true,
StmtKind::If { body, orelse, .. }
| StmtKind::While { body, orelse, .. }
| StmtKind::For { body, orelse, .. } => has_class(body) || has_class(orelse),
StmtKind::With { body, .. } | StmtKind::FuncDef { body, .. } => has_class(body),
StmtKind::Try {
body,
handlers,
orelse,
finalbody,
} => {
has_class(body)
|| handlers.iter().any(|h| has_class(&h.body))
|| has_class(orelse)
|| has_class(finalbody)
}
StmtKind::Match { cases, .. } => cases.iter().any(|c| has_class(&c.body)),
_ => false,
})
}
pub fn mangle_body(class: &str, body: &mut [Stmt]) {
for s in body {
stmt(class, s);
}
}
fn block(class: &str, body: &mut [Stmt]) {
for s in body {
stmt(class, s);
}
}
fn stmt(class: &str, s: &mut Stmt) {
match &mut s.kind {
StmtKind::Expr(e) => expr(class, e),
StmtKind::Assign { targets, value } => {
for t in targets {
expr(class, t);
}
expr(class, value);
}
StmtKind::AugAssign { target, value, .. } => {
expr(class, target);
expr(class, value);
}
StmtKind::AnnAssign {
target,
annotation,
value,
} => {
expr(class, target);
expr(class, annotation);
if let Some(v) = value {
expr(class, v);
}
}
StmtKind::If { test, body, orelse } | StmtKind::While { test, body, orelse } => {
expr(class, test);
block(class, body);
block(class, orelse);
}
StmtKind::For {
target,
iter,
body,
orelse,
..
} => {
expr(class, target);
expr(class, iter);
block(class, body);
block(class, orelse);
}
StmtKind::With { items, body, .. } => {
for WithItem { context, vars } in items {
expr(class, context);
if let Some(v) = vars {
expr(class, v);
}
}
block(class, body);
}
StmtKind::FuncDef {
name,
params,
body,
decorators,
..
} => {
fix(class, name);
parameters(class, params);
block(class, body);
for d in decorators {
expr(class, d);
}
}
StmtKind::ClassDef {
name,
bases,
keywords,
body,
decorators,
} => {
let inner = name.clone();
fix(class, name);
for b in bases {
expr(class, b);
}
for k in keywords {
expr(class, &mut k.value);
}
for d in decorators {
expr(class, d);
}
block(&inner, body);
}
StmtKind::Return(Some(e)) => expr(class, e),
StmtKind::Return(None) | StmtKind::Pass | StmtKind::Break | StmtKind::Continue => {}
StmtKind::Delete(xs) => {
for x in xs {
expr(class, x);
}
}
StmtKind::Import(names) => {
for a in names {
match &mut a.asname {
Some(n) => fix(class, n),
None => fix(class, &mut a.name),
}
}
}
StmtKind::ImportFrom { names, .. } => {
for a in names {
if let Some(n) = &mut a.asname {
fix(class, n);
}
}
}
StmtKind::Global(names) | StmtKind::Nonlocal(names) => {
for n in names {
fix(class, n);
}
}
StmtKind::Raise { exc, cause } => {
if let Some(e) = exc {
expr(class, e);
}
if let Some(c) = cause {
expr(class, c);
}
}
StmtKind::Try {
body,
handlers,
orelse,
finalbody,
} => {
block(class, body);
for ExceptHandler {
typ, name, body, ..
} in handlers
{
if let Some(t) = typ {
expr(class, t);
}
if let Some(n) = name {
fix(class, n);
}
block(class, body);
}
block(class, orelse);
block(class, finalbody);
}
StmtKind::Assert { test, msg } => {
expr(class, test);
if let Some(m) = msg {
expr(class, m);
}
}
StmtKind::Match { subject, cases } => {
expr(class, subject);
for MatchCase {
pattern,
guard,
body,
} in cases
{
pat(class, pattern);
if let Some(g) = guard {
expr(class, g);
}
block(class, body);
}
}
}
}
fn parameters(class: &str, p: &mut Params) {
for n in &mut p.names {
fix(class, n);
}
for n in &mut p.kwonly {
fix(class, n);
}
if let Some(n) = &mut p.star {
fix(class, n);
}
if let Some(n) = &mut p.kwargs {
fix(class, n);
}
for d in &mut p.defaults {
expr(class, d);
}
for d in p.kwonly_defaults.iter_mut().flatten() {
expr(class, d);
}
for (n, a) in &mut p.annotations {
fix(class, n);
expr(class, a);
}
}
fn pat(class: &str, p: &mut Pattern) {
match p {
Pattern::Wildcard => {}
Pattern::Capture(n) => fix(class, n),
Pattern::Value(e) => expr(class, e),
Pattern::Or(ps) => {
for q in ps {
pat(class, q);
}
}
Pattern::As(inner, n) => {
pat(class, inner);
fix(class, n);
}
Pattern::Sequence { elems, .. } => {
for q in elems {
pat(class, q);
}
}
Pattern::Star(Some(n)) => fix(class, n),
Pattern::Star(None) => {}
Pattern::Mapping { keys, rest } => {
for (k, q) in keys {
expr(class, k);
pat(class, q);
}
if let Some(n) = rest {
fix(class, n);
}
}
Pattern::Class { cls, pos, kw } => {
expr(class, cls);
for q in pos {
pat(class, q);
}
for (n, q) in kw {
fix(class, n);
pat(class, q);
}
}
}
}
fn comps(class: &str, cs: &mut [Comprehension]) {
for c in cs {
expr(class, &mut c.target);
expr(class, &mut c.iter);
for i in &mut c.ifs {
expr(class, i);
}
}
}
fn fparts(class: &str, ps: &mut [FStrPart]) {
for p in ps {
if let FStrPart::Expr { expr: e, spec, .. } = p {
expr(class, e);
fparts(class, spec);
}
}
}
fn expr(class: &str, e: &mut Expr) {
match e {
Expr::Name(n) => fix(class, n),
Expr::Attribute(v, attr) => {
expr(class, v);
fix(class, attr);
}
Expr::None
| Expr::True
| Expr::False
| Expr::Ellipsis
| Expr::Int(_)
| Expr::BigInt(_)
| Expr::Float(_)
| Expr::Complex(_)
| Expr::Str(_)
| Expr::Bytes(_) => {}
Expr::FString(ps) | Expr::TString(ps) => fparts(class, ps),
Expr::List(xs) | Expr::Tuple(xs) | Expr::Set(xs) => {
for x in xs {
expr(class, x);
}
}
Expr::Dict(items) => {
for (k, v) in items {
if let Some(k) = k {
expr(class, k);
}
expr(class, v);
}
}
Expr::Starred(x) | Expr::UnaryOp(_, x) | Expr::YieldFrom(x) | Expr::Await(x) => {
expr(class, x)
}
Expr::BoolOp(_, xs) => {
for x in xs {
expr(class, x);
}
}
Expr::BinOp(_, a, b) | Expr::NamedExpr(a, b) | Expr::Subscript(a, b) => {
expr(class, a);
expr(class, b);
}
Expr::Compare(l, links) => {
expr(class, l);
for (_, r) in links {
expr(class, r);
}
}
Expr::IfExp { test, body, orelse } => {
expr(class, test);
expr(class, body);
expr(class, orelse);
}
Expr::Call {
func,
args,
keywords,
} => {
expr(class, func);
for a in args {
expr(class, a);
}
for Keyword { value, .. } in keywords {
expr(class, value);
}
}
Expr::Slice { lo, hi, step } => {
for b in [lo, hi, step].into_iter().flatten() {
expr(class, b);
}
}
Expr::Lambda { params, body } => {
parameters(class, params);
expr(class, body);
}
Expr::ListComp(el, cs) | Expr::SetComp(el, cs) | Expr::GenExp(el, cs) => {
expr(class, el);
comps(class, cs);
}
Expr::DictComp(k, v, cs) => {
expr(class, k);
expr(class, v);
comps(class, cs);
}
Expr::Yield(x) => {
if let Some(x) = x {
expr(class, x);
}
}
Expr::Spanned(x, _) => expr(class, x),
}
}