cure_java_simplify/

lib.rs

//! # cure-java-simplify
//!
//! Java 简化门面：引擎通用规则 + Java 特有规则，一站式 [`simplify`]。
//!
//! 引擎规则（布尔、自赋值、常量条件、局部传播……）定义在 cure-engine，
//! 通过 `Lang` 抽象复用；本 crate 只放需要 Java 类型/负载信息的规则。

mod jdk;
pub use jdk::set_jdk_home;
mod vexec;

use cure_engine::kind::{BinOp, UnOp};
use cure_engine::{Config, Edit, Effect, Lang, LitRef, NodeKind, Report, RewriteCtx, Rule};
use cure_java_ast::{CompilationUnit, JavaAst, JavaId, JType, Lit, Member, NoopCandidate, NodeData, TypeDecl, TypeKind};

// ---------------------------------------------------------------------------
// Java 特有规则
// ---------------------------------------------------------------------------

/// 冗余 cast：
/// - `(T)(T) x → (T) x`（嵌套同型）
/// - `(T) x → x`（x 的声明类型就是 T，作用域解析后可知）
pub struct CastSimplify;

impl Rule<JavaAst> for CastSimplify {
    fn name(&self) -> &'static str {
        "cast_simplify"
    }
    fn kinds(&self) -> &'static [NodeKind] {
        &[NodeKind::Cast]
    }
    fn check(&self, ctx: RewriteCtx<'_, JavaAst>, id: JavaId) -> Option<Edit<JavaAst>> {
        let lang = ctx.lang;
        let NodeData::Cast { ty } = lang.data(id) else {
            return None;
        };
        let ty = ty.clone();
        let inner = lang.children(id)[0];

        // (T)(T) x → (T) x
        if let NodeData::Cast { ty: inner_ty } = lang.data(inner) {
            if *inner_ty == ty {
                return Some(Edit::Replace {
                    target: id,
                    with: inner,
                });
            }
        }

        // (T) x，x 声明类型 == T → 去掉 cast
        if let NodeData::VarRef { .. } = lang.data(inner) {
            if lang.var_type(inner) == Some(&ty) {
                return Some(Edit::Replace {
                    target: id,
                    with: inner,
                });
            }
        }
        // (T)(Object) x → (T) x：dex 的连续 check-cast（先 Object 再具体
        // 类型）被忠实再现成双重 cast。`(Object)` 一跳在**操作数静态类型
        // 为 Object 或 null** 时是纯噪声——`(T) objTypedAsObject` 合法。
        // 操作数类型是具体类型（Void/String/方法返回值等）时 `(Object)`
        // 是必需跳板（`(Number) voidReturning()` 不可编译——lark LayoutNode
        // ×4 教训）——不折叠。三语料实测：Object 类型源占大多数。
        if let NodeData::Cast { ty: inner_cast_ty } = lang.data(inner) {
            let is_obj = matches!(inner_cast_ty,
                JType::Ref(r) if r == "java.lang.Object" || r == "Object");
            if is_obj {
                let operand = lang.children(inner).first().copied()?;
                // 操作数静态类型检查：null/this/literal 恒为 Object（安全）；
                // VarRef 须解析到 Object 声明；其余（方法调用返回具体类型、
                // 嵌套 cast 后的具体类型等）不可判 → 保守放过
                let operand_is_object = match lang.data(operand) {
                    NodeData::Literal(_) | NodeData::This => true,
                    NodeData::VarRef { .. } => {
                        matches!(lang.var_type(operand),
                            Some(JType::Ref(r)) if r == "java.lang.Object" || r == "Object")
                    }
                    _ => false,
                };
                if operand_is_object {
                    return Some(Edit::Replace {
                        target: inner,
                        with: operand,
                    });
                }
            }
        }
        None
    }
}

/// 同一整数局部变量的 `x == x → true` / `x != x → false`
/// （浮点有 NaN 语义，引用保守起见不碰）。
pub struct SelfCompare;

impl Rule<JavaAst> for SelfCompare {
    fn name(&self) -> &'static str {
        "self_compare"
    }
    fn kinds(&self) -> &'static [NodeKind] {
        &[NodeKind::Binary]
    }
    fn check(&self, ctx: RewriteCtx<'_, JavaAst>, id: JavaId) -> Option<Edit<JavaAst>> {
        use cure_engine::kind::BinOp::{Eq, Ne};
        let lang = ctx.lang;
        let NodeData::Binary { op } = lang.data(id) else {
            return None;
        };
        if !matches!(op, Eq | Ne) {
            return None;
        }
        let ch = lang.children(id);
        let (NodeData::VarRef { name: n1 }, NodeData::VarRef { name: n2 }) =
            (lang.data(ch[0]), lang.data(ch[1]))
        else {
            return None;
        };
        if n1 != n2 || !lang.is_exact_int(ch[0]) {
            return None;
        }
        let val = lang.build_bool(*op == Eq);
        Some(Edit::Replace {
            target: id,
            with: val,
        })
    }
}


// ---------------------------------------------------------------------------
// StringBuilder 链还原（反编译器高频产物）：
//   new StringBuilder().append(a).append(b).toString()  →  a + b
//   new StringBuilder("s").append(x).toString()          →  "s" + x
// 安全性：两侧每个实参恰好按序求值一次；null/基本类型转换语义一致
// （append(String.valueOf 语义) == 字符串拼接的 String.valueOf 语义）。
// 首参非 String 类型时前置 ""（`1 + 2` 是整数加法，`"" + 1 + 2` 才是拼接）。
// new StringBuilder(int容量) 形态**不折叠**（容量构造，语义不同）。
// ---------------------------------------------------------------------------

pub struct StringBuilderFold;

impl Rule<JavaAst> for StringBuilderFold {
    fn name(&self) -> &'static str {
        "string_builder_fold"
    }
    fn kinds(&self) -> &'static [NodeKind] {
        &[NodeKind::Call]
    }
    fn check(&self, ctx: RewriteCtx<'_, JavaAst>, id: JavaId) -> Option<Edit<JavaAst>> {
        let root = ctx.root();
        let lang = ctx.lang;
        // 外层：X.toString()
        if lang.kind(id) != NodeKind::Call {
            return None;
        }
        let callee = lang.children(id)[0];
        if let NodeData::Member { name } = lang.data(callee) {
            if lang.sn(*name) != "toString" || !lang.children(id)[1..].is_empty() {
                return None;
            }
        } else {
            return None;
        }
        let mut node = lang.children(callee)[0]; // 链头：… .append(...)
        let mut parts: Vec<JavaId> = Vec::new();
        // 沿 append 链下溯
        loop {
            match lang.data(node) {
                NodeData::Call => {
                    let c = lang.children(node);
                    if let NodeData::Member { name } = lang.data(c[0]) {
                        if lang.sn(*name) == "append" && c.len() == 2 {
                            parts.push(c[1]);
                            node = lang.children(c[0])[0];
                            continue;
                        }
                    }
                    return None;
                }
                NodeData::New { ty, .. } => {
                    let is_sb = !lang.unit_shadows_lang
                && matches!(ty, JType::Ref(n) if n == "StringBuilder" || n == "java.lang.StringBuilder");
                    if !is_sb {
                        return None;
                    }
                    let args = lang.children(node).to_vec();
                    match args.len() {
                        0 => {} // new StringBuilder()
                        1 => {
                            // String 内容构造参与拼接；int/long 字面量必为
                            // 容量构造（无接收 int 的内容重载）——容量只是
                            // 分配提示，无语义差异，按无参处理；变量实参
                            // 类型不可证，保守拒绝
                            let a = args[0];
                            let stringy = matches!(lang.literal(a), Some(LitRef::Str(_)))
                                || lang
                                    .var_type(a)
                                    .is_some_and(|t| matches!(t, JType::Ref(n) if n == "String"));
                            if stringy {
                                parts.push(a);
                            } else if !matches!(
                                lang.literal(a),
                                Some(LitRef::Int(_) | LitRef::Long(_))
                            ) {
                                return None;
                            }
                        }
                        _ => return None,
                    }
                    break;
                }
                _ => return None,
            }
        }
        // 全字面量链折叠结果是常量表达式（javac 池化），而 sb.toString() 是
        // 运行期新建未池化的串——== 语义会变 → 身份守卫。混合链（含变量/调用）
        // 折叠后是非常量拼接，运行期行为与 toString 一致，无需守卫。
        if parts.iter().all(|&p| lang.literal(p).is_some())
            && lang.has_string_identity_compare(root)
        {
            return None;
        }
        if parts.is_empty() {
            // new StringBuilder().toString() → ""
            let empty = lang.build_str("");
            return Some(Edit::Replace {
                target: id,
                with: empty,
            });
        }
        // 逆序收集：parts 从链尾到链头，反转得源顺序
        parts.reverse();
        let first = parts[0];
        let stringy_first = matches!(lang.literal(first), Some(LitRef::Str(_)))
            || lang
                .var_type(first)
                .is_some_and(|t| matches!(t, JType::Ref(n) if n == "String"));
        let mut acc = if stringy_first {
            first
        } else {
            let empty = lang.build_str("");
            lang.build_bin(BinOp::Add, empty, first)
        };
        for &p in &parts[1..] {
            acc = lang.build_bin(BinOp::Add, acc, p);
        }
        Some(Edit::Replace {
            target: id,
            with: acc,
        })
    }
}

// ---------------------------------------------------------------------------
// 装箱-拆箱链还原（反编译器产物）：
//   Integer.valueOf(n).intValue() → n（Long/Boolean/Double/Float/Character/Short/Byte 同理）
//   new Integer(n).intValue()     → n
// 类型守卫：实参必须匹配包装类型的原始形态（valueOf(String) 是解析，语义不同）。
// ---------------------------------------------------------------------------

pub struct BoxUnboxChain;

const BOXERS: &[(&str, &str)] = &[
    ("Integer", "intValue"),
    ("java.lang.Integer", "intValue"),
    ("Long", "longValue"),
    ("java.lang.Long", "longValue"),
    ("Boolean", "booleanValue"),
    ("java.lang.Boolean", "booleanValue"),
    ("Double", "doubleValue"),
    ("java.lang.Double", "doubleValue"),
    ("Float", "floatValue"),
    ("java.lang.Float", "floatValue"),
    ("Character", "charValue"),
    ("java.lang.Character", "charValue"),
    ("Short", "shortValue"),
    ("java.lang.Short", "shortValue"),
    ("Byte", "byteValue"),
    ("java.lang.Byte", "byteValue"),
];

impl Rule<JavaAst> for BoxUnboxChain {
    fn name(&self) -> &'static str {
        "box_unbox_chain"
    }
    fn kinds(&self) -> &'static [NodeKind] {
        &[NodeKind::Call]
    }
    fn check(&self, ctx: RewriteCtx<'_, JavaAst>, id: JavaId) -> Option<Edit<JavaAst>> {
        let lang = ctx.lang;
        // 外层：inner.xxxValue()
        if lang.kind(id) != NodeKind::Call {
            return None;
        }
        let callee = lang.children(id)[0];
        let NodeData::Member { name: unbox } = lang.data(callee) else {
            return None;
        };
        if !lang.children(id)[1..].is_empty() {
            return None;
        }
        let inner = lang.children(callee)[0];
        if lang.kind(inner) != NodeKind::Call {
            return None;
        }
        // 内层：Box.valueOf(arg) 或 new Box(arg)
        let ich = lang.children(inner).to_vec();
        let (box_name, arg): (String, JavaId) = if let NodeData::New { ty, .. } = lang.data(inner)
        {
            let n = match ty {
                JType::Ref(r) => r.clone(),
                _ => return None,
            };
            if ich.len() != 1 {
                return None;
            }
            (n, ich[0])
        } else {
            // valueOf 静态调用：callee 是 Member 或 VarRef
            let icallee = ich.first().copied()?;
            if let NodeData::Member { name } = lang.data(icallee) {
                // Integer.valueOf：recv 是 VarRef(Integer)
                let recv = lang.children(icallee)[0];
                if lang.sn(*name) != "valueOf" {
                    return None;
                }
                {
                    let n = lang.var_name(recv)?;
                    (n.to_string(), *ich.get(1)?)
                }
            } else if let NodeData::VarRef { name } = lang.data(icallee) {
                // java.lang.Integer.valueOf 形态在解析里是 member 链；
                // 裸 valueOf( 视为同包静态——保守跳过
                let _ = name;
                return None;
            } else {
                return None;
            }
        };
        let unbox_name = *unbox;
        let expected = BOXERS
            .iter()
            .find(|(b, _)| *b == box_name.as_str())
            .map(|(_, u)| *u)?;
        if expected != lang.sn(unbox_name) {
            return None;
        }
        // 类型守卫：实参必须是该包装类型对应的原始类型表达式
        // （valueOf(String) 是解析语义，原始类型形态天然排除字符串）。
        let var_is = |t: fn(&JType) -> bool| lang.var_type(arg).is_some_and(t);
        let lit_is_num = lang.literal(arg).is_some_and(|l| {
            matches!(
                l,
                LitRef::Int(_) | LitRef::Long(_) | LitRef::Float(_) | LitRef::Double(_)
            )
        });
        let ok = match box_name.trim_start_matches("java.lang.") {
            "Integer" | "Long" | "Short" | "Byte" => lang.is_exact_int(arg),
            "Double" | "Float" => {
                lit_is_num
                    || var_is(|t| matches!(t, JType::Double | JType::Float | JType::Int | JType::Long))
            }
            "Boolean" => lang.is_bool(arg),
            "Character" => {
                matches!(lang.literal(arg), Some(LitRef::Char(_))) || var_is(|t| *t == JType::Char)
            }
            _ => false,
        };
        if !ok {
            return None;
        }
        Some(Edit::Replace {
            target: id,
            with: arg,
        })
    }
}

// ---------------------------------------------------------------------------
// 迭代器模式还原（反编译器经典产物）：
//   for (Iterator<E> it = c.iterator(); it.hasNext(); ) {
//       E e = it.next();
//       …rest…
//   }
//   →  for (E e : c) { …rest… }
// 安全性：与 for-each 的脱糖完全同构（iterator() 各求值一次、hasNext/next 同序）。
// 守卫：`it` 在 body 其余部分不再被引用。
// ---------------------------------------------------------------------------

pub struct IteratorToForEach;

impl Rule<JavaAst> for IteratorToForEach {
    fn name(&self) -> &'static str {
        "iterator_to_for_each"
    }
    fn kinds(&self) -> &'static [NodeKind] {
        &[NodeKind::For]
    }
    fn check(&self, ctx: RewriteCtx<'_, JavaAst>, id: JavaId) -> Option<Edit<JavaAst>> {
        let lang = ctx.lang;
        let NodeData::For {
            inits,
            has_cond,
            steps,
        } = lang.data(id)
        else {
            return None;
        };
        if *inits != 1 || !*has_cond || *steps != 0 {
            return None;
        }
        let ch = lang.children(id).to_vec();
        // children: [init, cond, body]
        let (init, cond, body) = (ch[0], ch[1], ch[2]);

        // init: Iterator<…> it = <iterable>.iterator();
        let NodeData::VarDecl { name: it_name, .. } = lang.data(init) else {
            return None;
        };
        let it_name = it_name.clone();
        let init_call = lang.children(init).first().copied()?;
        if lang.kind(init_call) != NodeKind::Call {
            return None;
        }
        let ic = lang.children(init_call).to_vec();
        let icallee = *ic.first()?;
        let NodeData::Member { name: m0 } = lang.data(icallee) else {
            return None;
        };
        if lang.sn(*m0) != "iterator" || ic.len() != 1 {
            return None;
        }
        let iterable = lang.children(icallee)[0];
        // iterable 不得引用 it（自引用）
        if subtree_has_var(&*lang, iterable, &it_name) {
            return None;
        }

        // cond: it.hasNext()
        if lang.kind(cond) != NodeKind::Call {
            return None;
        }
        let cc = lang.children(cond).to_vec();
        let ccallee = *cc.first()?;
        let NodeData::Member { name: m1 } = lang.data(ccallee) else {
            return None;
        };
        if lang.sn(*m1) != "hasNext" || cc.len() != 1 {
            return None;
        }
        if lang.var_name(lang.children(ccallee)[0]) != Some(it_name.as_str()) {
            return None;
        }

        // body: Block[ VarDecl e = it.next();, rest… ]
        if lang.kind(body) != NodeKind::Block {
            return None;
        }
        let bch = lang.children(body).to_vec();
        let first = *bch.first()?;
        let NodeData::VarDecl { name: e_name, ty, .. } = lang.data(first) else {
            return None;
        };
        let (e_name, ty) = (e_name.clone(), ty.clone());
        let next_call = lang.children(first).first().copied()?;
        if lang.kind(next_call) != NodeKind::Call {
            return None;
        }
        let nc = lang.children(next_call).to_vec();
        let ncallee = *nc.first()?;
        let NodeData::Member { name: m2 } = lang.data(ncallee) else {
            return None;
        };
        if lang.sn(*m2) != "next" || nc.len() != 1 {
            return None;
        }
        if lang.var_name(lang.children(ncallee)[0]) != Some(it_name.as_str()) {
            return None;
        }
        // rest 不得引用 it
        let rest = bch[1..].to_vec();
        for &r in &rest {
            if subtree_has_var(&*lang, r, &it_name) {
                return None;
            }
        }
        let new_body = lang.build_block(rest);
        let with = lang.for_each(&e_name, ty, iterable, new_body);
        Some(Edit::Replace {
            target: id,
            with,
        })
    }
}

/// 剥掉 next() 调用外围的 Paren / Cast 包装（DAD：`String s = (String) it.next();`）
fn unwrap_paren_cast(lang: &JavaAst, mut n: JavaId) -> JavaId {
    loop {
        match lang.kind(n) {
            NodeKind::Paren | NodeKind::Cast => {
                let ch = lang.children(n);
                if ch.is_empty() {
                    return n;
                }
                n = ch[0];
            }
            _ => return n,
        }
    }
}

/// 从任意泛型 Ref（ArrayList<String> / List<T>）提取元素类型；裸类型 None。
fn generic_elem_ty(ty: &JType) -> Option<JType> {
    let name = match ty {
        JType::Ref(n) => n.as_str(),
        _ => return None,
    };
    let lt = name.find('<')?;
    let gt = name.rfind('>')?;
    if gt <= lt {
        return None;
    }
    let inner = name[lt + 1..gt].trim();
    if inner.is_empty() || inner.contains('<') {
        return None; // 嵌套泛型/通配符 → Object 兜底
    }
    Some(JType::Ref(inner.to_string()))
}

/// for-each 可迭代位的静态类型门：数组恒可迭代；Ref 名剥去泛型实参后
/// 取末段，须落在 JDK 已知 Iterable 实现族白名单（java.lang.Iterable 与
/// java.util/java.util.concurrent 集合）。不透明类名（Kotlin Sequence
/// 伪装 d7.e 等）与未知简单名都不过门——while→for-each 还原只在类型
/// 可判定处发生（ddc 输出 FileHelper$…/k6.h0 复现：Sequence 有
/// .iterator() 但不是 java.lang.Iterable，for-each 不可编译）。
fn statically_iterable(ty: &JType) -> bool {
    match ty {
        JType::Array(_) => true,
        JType::Ref(name) => {
            let base = name.split('<').next().unwrap_or(name).trim();
            let last = base.rsplit('.').next().unwrap_or(base);
            matches!(
                last,
                "Iterable"
                    | "Collection"
                    | "List"
                    | "ArrayList"
                    | "LinkedList"
                    | "Vector"
                    | "Stack"
                    | "AbstractList"
                    | "AbstractCollection"
                    | "Set"
                    | "HashSet"
                    | "LinkedHashSet"
                    | "TreeSet"
                    | "SortedSet"
                    | "NavigableSet"
                    | "AbstractSet"
                    | "Queue"
                    | "Deque"
                    | "ArrayDeque"
                    | "PriorityQueue"
                    | "BlockingQueue"
                    | "BlockingDeque"
                    | "ConcurrentLinkedQueue"
                    | "ConcurrentLinkedDeque"
                    | "ConcurrentSkipListSet"
                    | "CopyOnWriteArrayList"
                    | "CopyOnWriteArraySet"
                    | "EnumSet"
                    | "LinkedBlockingQueue"
                    | "LinkedBlockingDeque"
                    | "ArrayBlockingQueue"
                    | "PriorityBlockingQueue"
                    | "DelayQueue"
                    | "SynchronousQueue"
                    | "LinkedTransferQueue"
                    | "TransferQueue"
            )
        }
        _ => false,
    }
}

/// 链式 Map 视图调用的**合成静态类型**：`<Map 族>.keySet()` →
/// `java.util.Set<K>`、`.values()` → `java.util.Collection<V>`（两者皆
/// Iterable，泛型实参沿袭 Map 声明）。仅当接收者是**声明类型可解析的
/// Map 族 VarRef** 且视图方法无实参时合成——entrySet 的 Map.Entry<K,V>
/// 嵌套泛型会让 generic_elem_ty 兜底 Object（保守），不合成。
/// 98c34d9 的 var_type 门只覆盖裸 VarRef 接收位，`m.keySet().iterator()`
/// 形态因 Call 无类型被一律拒绝（new_rules iterator_element_type 抓获）。
fn map_view_synthetic_ty(lang: &JavaAst, call: JavaId) -> Option<JType> {
    if lang.kind(call) != NodeKind::Call {
        return None;
    }
    let ch = lang.children(call).to_vec();
    if ch.len() != 1 {
        return None; // 视图方法无实参
    }
    let callee = *ch.first()?;
    let NodeData::Member { name } = lang.data(callee) else { return None };
    let view = lang.sn(*name);
    if !matches!(view, "keySet" | "values") {
        return None;
    }
    let recv = lang.children(callee).first().copied()?;
    let NodeData::VarRef { name } = lang.data(recv) else { return None };
    // 局部/参数作用域优先；未解析（字段接收位）回退 field_types——
    // 同名二见已被 collect_field_types 移除，命中即全单元唯一声明
    //（与调用点实参类型解析同一回退惯用法）
    let recv_ty = lang
        .var_type(recv)
        .cloned()
        .or_else(|| lang.field_types.get(lang.sn(*name)).cloned())?;
    let JType::Ref(n) = recv_ty else { return None };
    let lt = n.find('<')?;
    let gt = n.rfind('>')?;
    if gt <= lt {
        return None; // 裸 Map：元素类型未知 → 不合成（保守拒绝）
    }
    // 顶层逗号拆分 Map<K, V>（嵌套泛型实参由 generic_elem_ty 兜底）
    let args = n[lt + 1..gt].trim();
    let depth = args.chars().fold(0i32, |d, c| match c {
        '<' => d + 1,
        '>' => d - 1,
        _ => d,
    });
    let top = args.find(',').filter(|_| depth == 0)?;
    let k = args[..top].trim();
    let v = args[top + 1..].trim();
    let base = n[..lt].trim();
    let last = base.rsplit('.').next().unwrap_or(base);
    let map_family = matches!(
        last,
        "Map"
            | "SortedMap"
            | "NavigableMap"
            | "HashMap"
            | "LinkedHashMap"
            | "TreeMap"
            | "Hashtable"
            | "Properties"
            | "ConcurrentMap"
            | "ConcurrentHashMap"
            | "ConcurrentSkipListMap"
            | "ConcurrentNavigableMap"
            | "EnumMap"
            | "WeakHashMap"
            | "IdentityHashMap"
            | "AbstractMap"
    );
    if !map_family || k.is_empty() || v.is_empty() {
        return None;
    }
    match view {
        "keySet" => Some(JType::Ref(format!("java.util.Set<{k}>"))),
        _ => Some(JType::Ref(format!("java.util.Collection<{v}>"))),
    }
}

/// for-each 元素类型合法性：`?`/`? extends …`/`? super …`（通配符）不是
/// 合法变量类型 → Object（jdk-sources Subject 抓获：`Iterator<?> ce =
/// c.iterator()` 还原成 `for (? e2 : c)` 非法 Java）
fn for_each_elem_ok(ty: &JType) -> bool {
    match ty {
        JType::Ref(n) => !n.trim_start().starts_with('?'),
        _ => true,
    }
}

/// 收集子树内 name 的全部 VarRef。
fn collect_var_refs(lang: &JavaAst, root: JavaId, name: &str, out: &mut Vec<JavaId>) {
    let mut stack = vec![root];
    while let Some(n) = stack.pop() {
        if lang.kind(n) == NodeKind::VarRef && lang.var_name(n) == Some(name) {
            out.push(n);
        }
        for &c in lang.children(n) {
            stack.push(c);
        }
    }
}

/// 在 root 子树内找 target 的直接父节点。
fn parent_of_recv(lang: &JavaAst, root: JavaId, target: JavaId) -> JavaId {
    let mut stack = vec![root];
    while let Some(n) = stack.pop() {
        for &c in lang.children(n) {
            if c == target {
                return n;
            }
            stack.push(c);
        }
    }
    root
}

fn subtree_has_var(lang: &JavaAst, id: JavaId, name: &str) -> bool {
    let mut stack = vec![id];
    while let Some(n) = stack.pop() {
        if lang.kind(n) == NodeKind::VarRef && lang.var_name(n) == Some(name) {
            return true;
        }
        for &c in lang.children(n) {
            stack.push(c);
        }
    }
    false
}

/// 名字绑定检查（catch 形参 / for-each 变量——不在 VarRef/VarDecl 扫描域）
fn subtree_has_binding(lang: &JavaAst, id: JavaId, name: &str) -> bool {
    let mut stack = vec![id];
    while let Some(n) = stack.pop() {
        match lang.data(n) {
            NodeData::Catch { name: cn, .. } if cn == name => return true,
            NodeData::ForEach { name: vn, .. } if vn == name => return true,
            // Lambda 显式参数（params_raw 原文切分——T3a 抓获：park(e -> 0)
            // 的未读形参曾使 for-each 变量 e 撞名）
            NodeData::Lambda { params_raw } => {
                for part in
                    params_raw.split(|c: char| !c.is_alphanumeric() && c != '_' && c != '$')
                {
                    if part == name {
                        return true;
                    }
                }
            }
            // instanceof 模式绑定（bind 属性非子节点——T3d）
            NodeData::InstanceOf { bind: Some(b), .. } if b == name => return true,
            // TWR 资源/普通声明（未读资源 var_decl 因 close() 副作用不可删
            // 而存活到碰撞点——T3c；普通未读声明先行删除，此处保守命中无害）
            NodeData::VarDecl { name: dn, .. } if dn == name => return true,
            _ => {}
        }
        for &c in lang.children(n) {
            stack.push(c);
        }
    }
    false
}

// ---------------------------------------------------------------------------
// new String 折叠（混淆器/反编译器产物）：new String("lit") → "lit"、new String() → ""
// 仅字面量实参（new String(charArray/bytes) 是拷贝语义，不折）。
// ---------------------------------------------------------------------------

pub struct NewStringFold;

impl Rule<JavaAst> for NewStringFold {
    fn name(&self) -> &'static str {
        "new_string_fold"
    }
    fn kinds(&self) -> &'static [NodeKind] {
        &[NodeKind::New]
    }
    fn check(&self, ctx: RewriteCtx<'_, JavaAst>, id: JavaId) -> Option<Edit<JavaAst>> {
        let root = ctx.root();
        let lang = ctx.lang;
        let NodeData::New { ty, .. } = lang.data(id) else {
            return None;
        };
        if !matches!(ty, JType::Ref(n) if n == "String" || n == "java.lang.String") {
            return None;
        }
        // 同单元声明 String/StringBuilder 类型 → 遮蔽 java.lang，目标
        // 不是 java.lang.String（探针 T4a：class String{} 同文件时折叠
        // 产出不可编译）
        if lang.unit_shadows_lang {
            return None;
        }
        // 折叠产出池化字面量，改变 String 引用身份 → 守卫（单元级：
        // 字段 init 的 == 观察点在其他方法——单根扫描看不见）
        let _ = root;
        if lang.unit_string_identity {
            return None;
        }
        let args = lang.children(id).to_vec();
        match args.len() {
            0 => {
                let empty = lang.build_str("");
                Some(Edit::Replace {
                    target: id,
                    with: empty,
                })
            }
            1 => {
                if matches!(lang.literal(args[0]), Some(LitRef::Str(_))) {
                    Some(Edit::Replace {
                        target: id,
                        with: args[0],
                    })
                } else {
                    None
                }
            }
            _ => None,
        }
    }
}


// ---------------------------------------------------------------------------
// new String(char 字面量数组) → 字符串字面量（ZKM/Allatori 的字符串藏匿形态）。
// 守卫与 new String(lit) 相同：产出池化字面量改变 == 引用语义。
// ---------------------------------------------------------------------------

pub struct NewStringCharArrayFold;

impl Rule<JavaAst> for NewStringCharArrayFold {
    fn name(&self) -> &'static str {
        "new_string_char_array_fold"
    }
    fn kinds(&self) -> &'static [NodeKind] {
        &[NodeKind::New]
    }
    fn check(&self, ctx: RewriteCtx<'_, JavaAst>, id: JavaId) -> Option<Edit<JavaAst>> {
        let root = ctx.root();
        let lang = ctx.lang;
        let NodeData::New { ty, .. } = lang.data(id) else {
            return None;
        };
        if !matches!(ty, JType::Ref(n) if n == "String" || n == "java.lang.String") {
            return None;
        }
        let _ = root;
        if lang.unit_shadows_lang || lang.unit_string_identity {
            return None;
        }
        // 唯一实参：new char[]{...}（NewArray sized=0，唯一孩子 ArrayLit）
        let args = lang.children(id).to_vec();
        if args.len() != 1 {
            return None;
        }
        let NodeData::NewArray { sized, .. } = lang.data(args[0]) else {
            return None;
        };
        if *sized != 0 {
            return None;
        }
        let arr_children = lang.children(args[0]).to_vec();
        let lit = *arr_children.first()?;
        if lang.kind(lit) != NodeKind::ArrayLit {
            return None;
        }
        let mut text = String::new();
        for &c in lang.children(lit) {
            match lang.literal(c) {
                Some(LitRef::Char(ch)) => text.push(ch),
                _ => return None, // 非字符字面量（变量/表达式）不折
            }
        }
        let with = lang.build_str(&text);
        Some(Edit::Replace {
            target: id,
            with,
        })
    }
}

// ---------------------------------------------------------------------------
// 空 finally 剥除（dex2jar/ProGuard 产物）：
//   try { B } finally {}（无 catch、无资源）→ B
//   try { B } catch… finally {} → try { B } catch…（空 finally 删除）
// 语义：空 finally 无可观察行为；有 catch 时保留 try/catch 结构。
// ---------------------------------------------------------------------------

pub struct EmptyFinallyStrip;

impl Rule<JavaAst> for EmptyFinallyStrip {
    fn name(&self) -> &'static str {
        "empty_finally_strip"
    }
    fn kinds(&self) -> &'static [NodeKind] {
        &[NodeKind::Try]
    }
    fn check(&self, ctx: RewriteCtx<'_, JavaAst>, id: JavaId) -> Option<Edit<JavaAst>> {
        let lang = ctx.lang;
        if lang.kind(id) != NodeKind::Try {
            return None;
        }
        let ch = lang.children(id).to_vec();
        // children: [resource…, try_block, catch…, (finally)?]
        // 【关键】try_block = 第一个 Block 孩子；finally 只能是 try_block 与
        // catch 之后的最后孩子。**try_block 本身绝不在此删**（空 try 块交给
        // TryUnwrapNoCatch 整体解包）——曾经"last 为空块就删"会把空 try_block
        // 误当 finally 剥掉，try-with-resources 的资源直接暴露在 try 头外
        //（spoon sniperPrinter 真实语料抓获）。
        let is_empty_block = |n: JavaId| -> bool {
            lang.kind(n) == NodeKind::Block && lang.children(n).is_empty()
        };
        let try_idx = ch.iter().position(|&c| lang.kind(c) == NodeKind::Block)?;
        if ch.len() < try_idx + 2 {
            return None; // try_block 后没有孩子（无 finally）
        }
        // finally 存在性：最后孩子在 try_idx 之后且不是 catch
        let last = *ch.last()?;
        if lang.kind(last) == NodeKind::Catch {
            return None;
        }
        if !is_empty_block(last) {
            return None;
        }
        // last 距 try_idx 至少隔 1（try_idx 本身不可是 last——上面已保证
        // ch.len() ≥ try_idx+2，但 last 也可能是紧随 try_block 的 catch 后的 finally）
        Some(Edit::Splice {
            node: id,
            index: ch.len() - 1,
            remove: 1,
            insert: Vec::new(),
        })
    }
}

// ---------------------------------------------------------------------------
// 无 catch + 无资源 + 空/无 finally → 完全解包 try：
//   try { B } finally {} / try { B } → B
// ---------------------------------------------------------------------------


// ---------------------------------------------------------------------------
// 纯重抛 catch 剥除（fernflower 异常表残迹——审查统计 ≥23 处/11 文件）：
//   try { S } catch (T v) { throw v; }   →  S            （唯一 catch）
//   try { S } catch (A a) { throw a; } catch (B b) { …真处理… } →
//   try { S } catch (B b) { …真处理… }                   （只删重抛臂）
// 守卫：catch 体**只有**一条 throw 语句且抛的正是 catch 绑定变量自身
//（变量在其他处无使用——单一语句保证）；finally / 资源不动。
// 语义：捕获后原样重抛对求值顺序、副作用、异常路径与堆栈完全透明
//（栈深 +1 帧的差异源码层不可观察）。
// ---------------------------------------------------------------------------


// ---------------------------------------------------------------------------
// 虚拟执行 V2（static_exec）：对**根块**（方法体 / 静态初始化块 / 字段
// init）的纯计算段整体求值，重写为「逃逸局部 = 常量」+「字段写 = 常量」
// 的直线赋值。
//
// 目标形态（fernflower 语料 12/66 文件、残留噪声主体）：静态字符串
// 解密机——`"密文".toCharArray()` + `switch(i%5)` 常量键 + `(char)(c^k)`
// 循环 + `new String(arr).intern()`。语义全部由 vexec 解释器保守
// 求值（任何未知读/副作用/超预算立即放弃）。
//
// 正确性不变量：
//   - 仅根块（walk 无父）——嵌套块的存储无法区分外层局部/字段；
//   - 方法参数写 → 放弃（param 守卫）；
//   - 单路径确定性：条件/循环的条件全部求值为常量，执行走过的就是
//     全部活路径；
//   - 提前 Return/Break 只允许发生在**最后一条**顶层语句（此前返回
//     则后续语句在别的路径可达，单路径值不构成证明）；
//   - 逃逸局部（后半块句法引用的段内局部）与字段写的值必须可
//     材料化（Str/Int/Long/Bool/Str[]），否则放弃；
//   - 值中含未配对代理（UTF-8 不可表示）→ 放弃。
// ---------------------------------------------------------------------------


/// 幂等守卫用的宽松等价：字面量按**值**等价（NumRaw{val:Int(0)} ≡
/// Int(0)——打印相同），VarDecl 忽略类型标注差异（Int ≡ var）。
/// static_exec 产物每轮被零打印差编辑重写（ASTParserTokenManager
/// 抓获：ExprStmt→裸Assign/NumRaw→Int 交替），须在此归零。
fn print_equiv(lang: &JavaAst, a: JavaId, b: JavaId) -> bool {
    if lang.kind(a) != lang.kind(b) {
        // ExprStmt{X} ≡ X（裸语句形态差异）
        let (ia, ib) = (lang.kind(a), lang.kind(b));
        let unwrap = |k: NodeKind, x: JavaId| -> Option<JavaId> {
            if k == NodeKind::ExprStmt {
                lang.children(x).first().copied()
            } else {
                Some(x)
            }
        };
        return match (unwrap(ia, a), unwrap(ib, b)) {
            (Some(x), Some(y)) => print_equiv_inner(lang, x, y),
            _ => false,
        };
    }
    print_equiv_inner(lang, a, b)
}

fn print_equiv_inner(lang: &JavaAst, a: JavaId, b: JavaId) -> bool {
    if lang.kind(a) != lang.kind(b) {
        return false;
    }
    // 字面量按值等价
    match (lang.literal(a), lang.literal(b)) {
        (Some(x), Some(y)) => {
            if x != y {
                return false;
            }
        }
        (None, None) => {}
        _ => return false,
    }
    let (ca, cb) = (lang.children(a), lang.children(b));
    if ca.len() != cb.len() {
        return false;
    }
    ca.iter().zip(cb.iter()).all(|(&x, &y)| print_equiv_inner(lang, x, y))
}

/// rest 段是否对裸名字段**再赋值**：Assign/复合 Assign 的目标为该名的
/// VarRef，或 ++/-- 操作数。数组元素写（name[i]=v，Assign 目标是 Index）
/// 改内容不改绑定 → 不算。
fn rest_reassigns_field(lang: &JavaAst, rest: &[JavaId], name: &str) -> bool {
    for &root in rest {
        let mut stack = vec![root];
        while let Some(n) = stack.pop() {
            match lang.kind(n) {
                NodeKind::Assign => {
                    let t = lang.children(n)[0];
                    if lang.kind(t) == NodeKind::VarRef && lang.var_name(t) == Some(name) {
                        return true;
                    }
                }
                NodeKind::Unary => {
                    if let NodeData::Unary { op } = lang.data(n) {
                        if op.is_incdec() {
                            let t = lang.children(n)[0];
                            if lang.kind(t) == NodeKind::VarRef
                                && lang.var_name(t) == Some(name)
                            {
                                return true;
                            }
                        }
                    }
                }
                _ => {}
            }
            for &c in lang.children(n) {
                stack.push(c);
            }
        }
    }
    false
}

pub struct StaticExec;

impl Rule<JavaAst> for StaticExec {
    fn name(&self) -> &'static str {
        "static_exec"
    }
    fn kinds(&self) -> &'static [NodeKind] {
        &[NodeKind::Block]
    }
    fn check(&self, ctx: RewriteCtx<'_, JavaAst>, id: JavaId) -> Option<Edit<JavaAst>> {
        // 仅根块：嵌套块的裸名存储无法区分外层局部与字段（下降遍历在
        // vexec 内部自带作用域管理，规则侧只见根）
        if ctx.parent(id).is_some() {
            return None;
        }
        let lang = ctx.lang;
        if lang.kind(id) != NodeKind::Block {
            return None;
        }
        let stmts = lang.children(id).to_vec();
        if stmts.len() < 3 {
            return None; // 少于 3 条语句的段无折叠价值
        }
        // 前缀遍历（子块截断）：逐语句执行，失败语句若是 Block/Label/Try
        // 则下降进孩子继续；语句级失败前深快照、失败后回滚——遍历后的
        // 状态只含已完成语句的效应（「半途倾倒」污染从根上消除，
        // r/a4/a5/a3 的 AIOOBE/final 双赋值即此污染）。Class.forName
        //（JDK 类）假设成功，作为不透明副作用进 effect_log 重放。
        let mut ex = vexec::Exec::new(lang);
        let run = ex.run_prefix(&stmts).ok()?;
        if std::env::var("CURE_DBG_P1").is_ok() {
            eprintln!(
                "[P1-se] run ok: cuts={} total_completed={} budget={} log_len={} root_cut=({},{}) events={:?}",
                run.cuts.len(),
                run.cuts.iter().map(|c| c.completed).sum::<usize>(),
                ex.budget_exhausted(),
                ex.effect_log().len(),
                run.cuts.last().map(|c| c.log_start).unwrap_or(0),
                run.cuts.last().map(|c| c.log_end).unwrap_or(0),
                ex.effect_log().iter().map(|e| match e {
                    vexec::EffectEvent::FieldWrite(_) => "FW",
                    vexec::EffectEvent::ClassLoad { .. } => "CL",
                    vexec::EffectEvent::OpaqueFieldWrite { .. } => "OFW",
                }).collect::<Vec<_>>()
            );
        }
        // 步数预算耗尽：中途状态非收敛值——整段放弃（不回写任何常量）
        if ex.budget_exhausted() {
            return None;
        }
        let root_idx = run.root_cut_index();
        // 总完成量门槛（根 + 嵌套层合计；嵌套截断单独也有价值）
        let total_completed: usize = run.cuts.iter().map(|c| c.completed).sum();
        if total_completed < 3 {
            return None;
        }
        // ---- 截断守卫：前缀字段写（全日志）被**真实剩余**再赋值 → 放弃
        // 整段（final 双重赋值不可编译）。仅读 → 放行（材料化写恰为读
        // 供值）。真实剩余 = 各停止层剩余语句全集（含失败语句内部）。
        let true_rest = run.true_rest();
        if !true_rest.is_empty() {
            for ev in ex.effect_log().iter() {
                if let vexec::EffectEvent::FieldWrite(k) = ev {
                    if let Some(name) = lang.name_of_key(*k) {
                        // final 双重赋值不可编译 → 放弃整段；非 final 的
                        // 材料化写被 rest 再赋值杀掉 = 死写，语义恒等
                        //（a3/a4/a5：尾部 fernflower 复制分支再赋值非 final
                        // 字段曾使整段放弃——全有或全无 → 放宽为部分材料化）
                        if lang.final_fields.contains(&name)
                            && rest_reassigns_field(lang, &true_rest, &name)
                        {
                            return None;
                        }
                    }
                }
            }
        }
        // ---- 提取数据（解除 &mut 借用）----
        let log: Vec<vexec::EffectEvent> = ex.effect_log().to_vec();
        let field_finals: Vec<(u32, vexec::VVal)> =
            ex.field_writes().iter().map(|(k, v)| (*k, v.clone())).collect();
        let decl_order: Vec<u32> = ex.decl_order().to_vec();
        // Return 载荷是段输出的一部分：`int m(){…;return x;}` 的 x 必须
        // 物化为 `return <常量>;`（CLI 测试抓获：方法体曾被吞成空体）
        let ret_payload: Option<Option<vexec::VVal>> = match &run.early_exit {
            Some(vexec::Flow::Return(v)) => Some(v.clone()),
            _ => None,
        };
        // 每层逃逸局部：decl_order[decl_start .. 更深层 decl_start] 中
        // 存活且名字被该层以下剩余引用者。值先取出。
        let mut escaped_by_cut: Vec<Vec<(u32, vexec::VVal, u8, JType)>> = Vec::new();
        // 被剪裁删除的**存活**局部名（逐 cut）：opaque 调用重放的悬空守
        // 卫用——重放语句在完成区间内，rest_j 看不见它，其保留原子树的
        // 实参不得引用这些名字（k.java：`Object[] v0x=…; v0x[0]=…;
        // String.format(…, v0x)` 的 vararg 实参位——剪掉声明留裸名 →
        // 找不到符号）
        let mut cut_live_names: Vec<std::collections::HashSet<String>> = Vec::new();
        for (j, cut) in run.cuts.iter().enumerate() {
            let range_end = if j == 0 {
                decl_order.len()
            } else {
                run.cuts[j - 1].decl_start
            };
            let rest_j = run.rest_for_cut(j);
            let mut esc: Vec<(u32, vexec::VVal, u8, JType)> = Vec::new();
            let mut live_names: std::collections::HashSet<String> =
                std::collections::HashSet::new();
            for &k in &decl_order[cut.decl_start.min(range_end)..range_end] {
                if ex.var_value(k).is_none() {
                    continue; // 已随作用域弹出——非存活局部
                }
                let name = lang.name_of_key(k)?;
                live_names.insert(name.clone());
                let referenced = rest_j.iter().any(|&st| {
                    cure_engine::analysis::subtree_contains(lang, st, |n| {
                        lang.kind(n) == NodeKind::VarRef
                            && lang.var_name(n) == Some(name.as_str())
                    })
                });
                if referenced {
                    esc.push((
                        k,
                        ex.var_value(k).cloned().unwrap_or(vexec::VVal::Undef),
                        ex.var_domain(k),
                        // 原声明类型：引用声明（装箱语义）材料化必须原样
                        // 恢复——var 推断基本类型使接收位不可解引用
                        ex.var_decl_ty(k).unwrap_or(JType::Var),
                    ));
                }
            }
            escaped_by_cut.push(esc);
            cut_live_names.push(live_names);
        }
        drop(ex);
        // ---- 每层材料化（日志区间按执行序重放）----
        let mut edits: Vec<Edit<JavaAst>> = Vec::new();
        for (j, cut) in run.cuts.iter().enumerate() {
            let block_id = if j == root_idx {
                id
            } else {
                cut.block_hint?
            };
            let mut insert: Vec<JavaId> = Vec::new();
            // 日志区间 [log_start, log_end)：
            for pos in cut.log_start..cut.log_end {
                match &log[pos] {
                    vexec::EffectEvent::FieldWrite(k) => {
                        // 仅该名字全日志最后一次写发语句（末值；中间写被杀）
                        let is_last = !log[pos + 1..]
                            .iter()
                            .any(|ev| matches!(ev, vexec::EffectEvent::FieldWrite(k2) if k2 == k));
                        if !is_last {
                            continue;
                        }
                        let name = lang.name_of_key(*k)?;
                        // 参数守卫（方法根：字段名撞参数名 → 放弃）
                        if lang.is_param_name(&name) {
                            return None;
                        }
                        let v = field_finals
                            .iter()
                            .find(|(fk, _)| fk == k)
                            .map(|(_, v)| v.clone())?;
                        // 字段声明域截断（静态块里 f += …L 的复合赋值
                        // 隐式收窄）：static int/byte/short/char 字段上的
                        // L 值按域截断成 Int（t04i 抓获：f = 3000000001L
                        // 写进 static int 不可编译且值错）
                        let v = match (&v, lang.field_types.get(&name)) {
                            (vexec::VVal::L(x), Some(JType::Int)) => vexec::VVal::I(*x as i32),
                            (vexec::VVal::L(x), Some(JType::Byte)) => vexec::VVal::I(*x as i8 as i32),
                            (vexec::VVal::L(x), Some(JType::Short)) => vexec::VVal::I(*x as i16 as i32),
                            (vexec::VVal::L(x), Some(JType::Char)) => vexec::VVal::I(*x as u16 as i32),
                            _ => v,
                        };
                        let (val, mut extra) = materialize(lang, &v)?;
                        let tgt = lang.var(&name);
                        insert.push(lang.assign(tgt, val));
                        insert.append(&mut extra);
                    }
                    vexec::EffectEvent::OpaqueFieldWrite { k, stmt, call, args } => {
                        if std::env::var("CURE_DBG_P1").is_ok() {
                            eprintln!("[P1-mat] OpaqueFieldWrite entered k={}", k);
                        }
                        // 屏障重放：`name = <原调用子树，可求值实参代常量>`。
                        // 实参逐个求值——VVal::S/I/L/B → 字面量替换；
                        // 不可求值（Undef/数组）→ 保留原子树（语义不触碰）。
                        // 副作用 = 原调用在原位置执行——求值序保持
                        let name = lang.name_of_key(*k)?;
                        // 参数守卫（方法根：字段名撞参数名 → 放弃）
                        if lang.is_param_name(&name) {
                            return None;
                        }
                        let cch = lang.children(*call).to_vec();
                        let mut new_args: Vec<JavaId> = Vec::new();
                        let mut kept_original: Vec<bool> = Vec::new();
                        for (i, &arg) in cch.iter().enumerate().skip(1) {
                            let val = args.get(i - 1).cloned().flatten();
                            let replaced = match val {
                                Some(vexec::VVal::S(t)) => Some(lang.lit(Lit::Str(t))),
                                Some(vexec::VVal::I(x)) => Some(lang.lit(Lit::Int(x as i64))),
                                Some(vexec::VVal::L(x)) => Some(lang.lit(Lit::Long(x))),
                                Some(vexec::VVal::B(b)) => Some(lang.lit(Lit::Bool(b))),
                                _ => None,
                            };
                            kept_original.push(replaced.is_none());
                            new_args.push(replaced.unwrap_or_else(|| lang.copy_subtree(arg)));
                        }
                        // 悬空守卫：保留原子树的实参（数组/Undef 等不可求
                        // 值值）若引用被剪裁删除的存活局部 → 该调用重放后
                        // 残留对已删声明的裸名引用 → 整段放弃（保守）
                        let names_j = cut_live_names.get(j)?;
                        for ((i, &arg), &kept) in
                            cch.iter().enumerate().skip(1).zip(kept_original.iter())
                        {
                            let _ = i;
                            if kept
                                && !names_j.is_empty()
                                && cure_engine::analysis::subtree_contains(
                                    lang,
                                    arg,
                                    |n| {
                                        lang.kind(n) == NodeKind::VarRef
                                            && lang
                                                .var_name(n)
                                                .is_some_and(|nm| names_j.contains(nm))
                                    },
                                )
                            {
                                return None;
                            }
                        }
                        let callee = *lang.children(*call).first()?;
                        let callee_copy = lang.copy_subtree(callee);
                        let mut ch = vec![callee_copy];
                        ch.extend(new_args);
                        let new_call = lang.clone_node(*call, ch);
                        let new_stmt = if lang.kind(*stmt) == NodeKind::ExprStmt {
                            lang.clone_node(*stmt, vec![new_call])
                        } else {
                            new_call
                        };
                        // 赋值重放：name = <调用>
                        let tgt = lang.var(&name);
                        let assign = lang.assign(tgt, new_stmt);
                        insert.push(assign);
                    }
                    vexec::EffectEvent::ClassLoad { stmt, call, name } => {
                        // 重放为「try { 原语句(字面量实参) } catch (Exception
                        // cure$ex) {}」——forName 抛受检 ClassNotFoundException，
                        // 裸语句在 javac 下不可编译（终审代理抓获：修复输入
                        // 固有缺陷后输出独有「未报告的异常错误」——曾因 var121
                        // 前置错误掩蔽）。catch 在 JDK 假设下是死路，仅为
                        // 受检异常路径的编译合法性；形参名 cure$ex 防局部撞名
                        //（catch 形参不得遮蔽作用域内局部）
                        let lit = lang.lit(Lit::Str(name.clone()));
                        let callee = *lang.children(*call).first()?;
                        let callee_copy = lang.copy_subtree(callee);
                        let new_call = lang.clone_node(*call, vec![callee_copy, lit]);
                        let new_stmt = if lang.kind(*stmt) == NodeKind::ExprStmt {
                            lang.clone_node(*stmt, vec![new_call])
                        } else {
                            new_call
                        };
                        let try_block = lang.block(vec![new_stmt]);
                        let catch_block = lang.block(vec![]);
                        let catch_arm = lang.catch_("Exception", "cure$ex", catch_block);
                        let wrapped = lang.try_(vec![], try_block, vec![catch_arm], None);
                        insert.push(wrapped);
                    }
                }
            }
            // 逃逸局部（保持原声明序）：值不可材料化 → 放弃整段重写。
            // 别名保持：同一数组（CA/SA 同 Rc）的多名只发一份字面量，其余
            // 以 `var x = <首名>` 声明——o.java 抓获：var17/var39 双别名
            // 被拆成独立数组，rest 的就地解码写错数组（正则被腐蚀）
            let mut alias_first: std::collections::HashMap<usize, String> =
                std::collections::HashMap::new();
            for (k, v, dom, dty) in &escaped_by_cut[j] {
                let name = lang.name_of_key(*k)?;
                let (val, mut extra) = match v {
                    vexec::VVal::CA(a) => {
                        let addr = std::rc::Rc::as_ptr(a) as usize;
                        match alias_first.get(&addr) {
                            Some(first) => (lang.var(first), vec![]),
                            None => {
                                alias_first.insert(addr, name.clone());
                                materialize(lang, v)?
                            }
                        }
                    }
                    vexec::VVal::SA(a) => {
                        let addr = std::rc::Rc::as_ptr(a) as usize;
                        match alias_first.get(&addr) {
                            Some(first) => (lang.var(first), vec![]),
                            None => {
                                alias_first.insert(addr, name.clone());
                                materialize(lang, v)?
                            }
                        }
                    }
                    _ => materialize(lang, v)?,
                };
                // 声明域恢复：JType::Var 丢失 char/byte/short/long 的
                // 静态类型（v13 抓获：char c='x' 物化成 var c=120，
                // valueOf(c) 折成 "120"；long 同源折 i32）。char 域的
                // I 值发 Char 字面量；long 域的 I 值发 5L
                let (ty, val) = match (*dom, val) {
                    (2, lit) if lang.kind(lit) == NodeKind::Literal => {
                        // Int/Long 字面量都按 char 域转换（t04f 抓获：
                        // Long 直通产出 char c = 98L 不可编译）
                        match lang.literal(lit) {
                            Some(LitRef::Int(v)) => {
                                match u32::try_from(v).ok().and_then(char::from_u32) {
                                    Some(c) => (JType::Char, lang.lit(Lit::Char(c))),
                                    None => (JType::Char, lit),
                                }
                            }
                            Some(LitRef::Long(v)) => {
                                match u32::try_from(v as i32 as i64).ok().and_then(char::from_u32) {
                                    Some(c) => (JType::Char, lang.lit(Lit::Char(c))),
                                    None => (JType::Char, lit),
                                }
                            }
                            _ => (JType::Char, lit),
                        }
                    }
                    (3, lit) => (JType::Byte, lit),
                    (4, lit) => (JType::Short, lit),
                    (5, lit) if lang.kind(lit) == NodeKind::Literal => {
                        if let Some(LitRef::Int(v)) = lang.literal(lit) {
                            (JType::Long, lang.build_int(v, true))
                        } else {
                            (JType::Long, lit)
                        }
                    }
                    // 引用声明（Object/接口等）按原类型恢复（装箱在赋值
                    // 位合法——R14 族 A：`Object o = i + j` 曾发 var o = 3
                    // → o.hashCode() 不可解引用）。基本类型声明保持 var
                    //（与推断同型）
                    (_, lit) => {
                        if matches!(dty, JType::Ref(_)) {
                            (dty.clone(), lit)
                        } else {
                            (JType::Var, lit)
                        }
                    }
                };
                let stmt = lang.var_decl(&name, ty, Some(val));
                insert.push(stmt);
                insert.append(&mut extra);
            }
            // 根层 return 载荷（void 裸 return 不发——trailing_return 清理）
            if j == root_idx {
                if let Some(v) = ret_payload.clone().flatten() {
                    let (val, mut extra) = materialize(lang, &v)?;
                    let stmt = lang.ret(Some(val));
                    insert.push(stmt);
                    insert.append(&mut extra);
                }
            }
            // 无内容无删减的层跳过
            if insert.is_empty() && cut.completed == 0 {
                continue;
            }
            // 幂等守卫：该层产物与被删前缀逐位一致 → 跳过该层
            //（ASTParserTokenManager 曾每轮 1 次零差编辑——振荡误报）
            {
                let removed = lang.children(block_id).to_vec();
                if insert.len() == cut.completed
                    && cut.completed <= removed.len()
                    && insert
                        .iter()
                        .zip(removed[..cut.completed].iter())
                        .all(|(&n, &o)| print_equiv(lang, n, o))
                {
                    continue;
                }
            }
            edits.push(Edit::Splice {
                node: block_id,
                index: 0,
                remove: cut.completed,
                insert,
            });
        }
        if std::env::var("CURE_DBG_P1").is_ok() {
            eprintln!("[P1-se] edits={} (empty→reject)", edits.len());
        }
        if edits.is_empty() {
            return None;
        }
        // 纯死段（无输出无逃逸整段删除）等历史形态由空 insert splice 承载
        let candidate = if edits.len() == 1 {
            edits.pop().unwrap()
        } else {
            Edit::Multi(edits)
        };
        // 零降本提案（打印等价但成本相同的重排）在 release 会被引擎跳过，
        // debug 断言会 panic。规则侧直接拒绝（BindingsTest1 语料抓获）。
        if candidate.cost_reduction(lang) <= 0 {
            return None;
        }
        Some(candidate)
    }
}

/// 值 → 常量字面量节点（不可材料化 → None）。
/// 值 → 常量表达式节点 + 追加语句（部分填充数组需 new T[n] + 分槽赋值）。
fn materialize(lang: &mut JavaAst, v: &vexec::VVal) -> Option<(JavaId, Vec<JavaId>)> {
    use vexec::VVal;
    match v {
        VVal::I(x) => Some((lang.lit(Lit::Int(*x as i64)), vec![])),
        VVal::L(x) => Some((lang.lit(Lit::Long(*x)), vec![])),
        VVal::B(b) => Some((lang.lit(Lit::Bool(*b)), vec![])),
        VVal::S(s) => Some((lang.lit(Lit::Str(s.clone())), vec![])),
        VVal::CA(a) => {
            // char[] 字面量：new char[]{...}
            let chars: Vec<char> = a.borrow().clone();
            let lits: Vec<JavaId> = chars.iter().map(|&c| lang.lit(Lit::Char(c))).collect();
            let lit_arr = lang.array_lit(lits);
            let node = lang.new_array(JType::Char, 1, 0, vec![], Some(lit_arr));
            Some((node, vec![]))
        }
        VVal::SA(elems) => {
            // String[]：全填充 → 字面量数组；部分填充 → new String[n] +
            // 逐元素赋值（null 槽保留——后半段继续填充）
            let arr = elems.borrow().clone();
            if arr.iter().all(|e| matches!(e, VVal::S(_))) {
                let lits: Vec<JavaId> = arr
                    .iter()
                    .map(|e| match e {
                        VVal::S(sv) => lang.lit(Lit::Str(sv.clone())),
                        _ => unreachable!(),
                    })
                    .collect();
                let lit_arr = lang.array_lit(lits);
                let node =
                    lang.new_array(JType::Ref("String".to_string()), 1, 0, vec![], Some(lit_arr));
                Some((node, vec![]))
            } else {
                // 部分填充（含 Undef 槽）：元素静态类型未知——
                // new T[n] 的 T 无法从值推断（差分抓获：new int[5]
                // 曾被物化成 new String[5]，类型损坏不可编译）。
                // 保守放弃（整段重写回退）
                None
            }
        }
        // Undef → 不可材料化（逃逸未初始化值可疑，放弃）
        VVal::Undef => None,
    }
}

pub struct TryUnwrapRethrow;

impl Rule<JavaAst> for TryUnwrapRethrow {
    fn name(&self) -> &'static str {
        "try_unwrap_rethrow"
    }
    fn kinds(&self) -> &'static [NodeKind] {
        &[NodeKind::Try]
    }
    fn check(&self, ctx: RewriteCtx<'_, JavaAst>, id: JavaId) -> Option<Edit<JavaAst>> {
        let lang = ctx.lang;
        if lang.kind(id) != NodeKind::Try {
            return None;
        }
        let ch = lang.children(id).to_vec();
        // 布局 [resource…, try_block, catch…, (finally)?]
        let try_block = *ch.iter().find(|&&c| lang.kind(c) == NodeKind::Block)?;
        let catches: Vec<JavaId> =
            ch.iter().copied().filter(|&c| lang.kind(c) == NodeKind::Catch).collect();
        if catches.is_empty() {
            return None;
        }
        let rethrow_only = |c: JavaId| -> bool {
            // Catch 布局 children: [block]；绑定名在 NodeData::Catch
            let block = match lang.children(c).first() {
                Some(&b) => b,
                None => return false,
            };
            let stmts = lang.children(block);
            if stmts.len() != 1 {
                return false;
            }
            let stmt = stmts[0];
            if lang.kind(stmt) != NodeKind::Throw {
                return false;
            }
            let Some(&thrown) = lang.children(stmt).first() else { return false };
            // 抛的必须是 catch 绑定变量自身（整枝唯一使用 ⇒ 无别名逃逸）
            if lang.kind(thrown) != NodeKind::VarRef {
                return false;
            }
            match &lang.node(c).data {
                NodeData::Catch { name, .. } => lang.var_name(thrown) == Some(name.as_str()),
                _ => false,
            }
        };
        let all_rethrow = catches.iter().all(|&c| rethrow_only(c));
        if all_rethrow {
            // 无 finally / 资源（try_block 之外只允许这些 catch）→ 整体剥壳
            let extras: Vec<JavaId> = ch
                .iter()
                .copied()
                .filter(|&c| c != try_block && lang.kind(c) != NodeKind::Catch)
                .collect();
            if extras.is_empty() {
                return Some(Edit::Replace {
                    target: id,
                    with: try_block,
                });
            }
            return None;
        }
        // 混合：只删重抛臂（Splice 掉对应 catch 槽）。守卫：被删臂**之后**
        // 的所有 catch 也必须是纯重抛——否则该类型异常改道后续真处理臂
        //（JavaInputAstVisitor 抓获：删 catch(FormattingError){throw e} 后
        // Error 落进 catch(Throwable) 被重新包装，异常消息可观察改变）。
        // catch 匹配按序——更早的臂不受影响（它们本来就先匹配）。
        let catch_slots: Vec<usize> = ch
            .iter()
            .enumerate()
            .filter(|(_, &c)| lang.kind(c) == NodeKind::Catch)
            .map(|(i, _)| i)
            .collect();
        for &slot in &catch_slots {
            let c = ch[slot];
            if !rethrow_only(c) {
                continue;
            }
            let later_all_rethrow = catch_slots
                .iter()
                .filter(|&&s2| s2 > slot)
                .all(|&s2| rethrow_only(ch[s2]));
            if !later_all_rethrow {
                continue;
            }
            return Some(Edit::Splice {
                node: id,
                index: slot,
                remove: 1,
                insert: vec![],
            });
        }
        None
    }
}

pub struct TryUnwrapNoCatch;

impl Rule<JavaAst> for TryUnwrapNoCatch {
    fn name(&self) -> &'static str {
        "try_unwrap_no_catch"
    }
    fn kinds(&self) -> &'static [NodeKind] {
        &[NodeKind::Try]
    }
    fn check(&self, ctx: RewriteCtx<'_, JavaAst>, id: JavaId) -> Option<Edit<JavaAst>> {
        let lang = ctx.lang;
        if lang.kind(id) != NodeKind::Try {
            return None;
        }
        let ch = lang.children(id).to_vec();
        if ch.is_empty() {
            return None;
        }
        // 布局 [resource…, try_block, catch…, (finally)?]：
        // catch 节点识别（NodeData::Catch）；资源是语句节点（VarDecl/ExprStmt）。
        let has_catch = ch.iter().any(|&c| lang.kind(c) == NodeKind::Catch);
        if has_catch {
            return None;
        }
        // 资源识别：try 块之前、非 try-block 的孩子数 —— 保守做法：
        // try_block = 第一个 Block 孩子（资源不会是 Block）；其后的孩子
        // 只能是 finally（无 catch）。
        let try_block = *ch.iter().find(|&&c| lang.kind(c) == NodeKind::Block)?;
        let rest: Vec<JavaId> = ch
            .iter()
            .copied()
            .filter(|&c| c != try_block)
            .collect();
        // 其余（资源 + finally）必须全部为空 Block（即无 finally 或空 finally）
        // 且无资源语句。
        for &r in &rest {
            let is_empty_block = lang.kind(r) == NodeKind::Block && lang.children(r).is_empty();
            if !is_empty_block {
                return None; // 有资源或非空 finally
            }
        }
        Some(Edit::Replace {
            target: id,
            with: try_block,
        })
    }
}

// ---------------------------------------------------------------------------
// 循环头断路还原（jadx/反编译器高频形态）：
//   while (true) { if (c) { break; } REST }        →  while (!c) { REST }
//   while (true) { if (c) break; else { REST } … }  →  while (!c) { REST… }
// 安全性：c 在两种形态下都于每次迭代头部求值一次；break 无标签（目标是本循环）。
// ---------------------------------------------------------------------------

pub struct LoopHeadBreak;

impl Rule<JavaAst> for LoopHeadBreak {
    fn name(&self) -> &'static str {
        "loop_head_break"
    }
    fn kinds(&self) -> &'static [NodeKind] {
        &[NodeKind::While, NodeKind::DoWhile]
    }
    fn check(&self, ctx: RewriteCtx<'_, JavaAst>, id: JavaId) -> Option<Edit<JavaAst>> {
        let lang = ctx.lang;
        let body = match lang.kind(id) {
            NodeKind::While => {
                let ch = lang.children(id).to_vec();
                if !matches!(lang.literal(ch[0]), Some(LitRef::Bool(true))) {
                    return None;
                }
                ch[1]
            }
            NodeKind::DoWhile => {
                let ch = lang.children(id).to_vec();
                if !matches!(lang.literal(ch[1]), Some(LitRef::Bool(true))) {
                    return None;
                }
                ch[0]
            }
            _ => return None,
        };
        if lang.kind(body) != NodeKind::Block {
            return None;
        }
        let bch = lang.children(body).to_vec();
        let is_do = lang.kind(id) == NodeKind::DoWhile;
        // do-while 形态：if 必须是体里唯一语句
        if is_do && bch.len() != 1 {
            return None;
        }
        let first = *bch.first()?;
        if lang.kind(first) != NodeKind::If {
            return None;
        }
        let ich = lang.children(first).to_vec();
        let c = ich[0];

        let bare_break = |n: JavaId| matches!(lang.data(n), NodeData::Break { label: None });
        let is_break = |n: JavaId| match lang.kind(n) {
            NodeKind::Break => bare_break(n),
            NodeKind::Block if lang.children(n).len() == 1 => bare_break(lang.children(n)[0]),
            _ => false,
        };
        let bare_continue = |n: JavaId| matches!(lang.data(n), NodeData::Continue { label: None });
        let ends_with_continue = |n: JavaId| -> bool {
            match lang.kind(n) {
                NodeKind::Continue => bare_continue(n),
                NodeKind::Block => lang
                    .children(n)
                    .last()
                    .is_some_and(|&l| lang.kind(l) == NodeKind::Continue && bare_continue(l)),
                _ => false,
            }
        };
        let strip_tail_continue = |n: JavaId| -> Vec<JavaId> {
            match lang.kind(n) {
                NodeKind::Continue => vec![],
                NodeKind::Block => {
                    let ch = lang.children(n).to_vec();
                    if ch
                        .last()
                        .is_some_and(|&l| lang.kind(l) == NodeKind::Continue && bare_continue(l))
                    {
                        ch[..ch.len() - 1].to_vec()
                    } else {
                        ch
                    }
                }
                _ => vec![n],
            }
        };

        match ich.len() {
            2 => {
                // while (true) { if (c) { break; } REST } → while (!c) { REST }
                if is_do || !is_break(ich[1]) {
                    return None;
                }
                let mut rest: Vec<JavaId> = bch[1..].to_vec();
                if let Some(&last) = rest.last() {
                    if lang.kind(last) == NodeKind::Continue && bare_continue(last) {
                        rest.pop();
                    }
                }
                let nc = lang.build_unary(UnOp::Not, c);
                let inner = lang.build_block(rest);
                let w = lang.while_(nc, inner);
                Some(Edit::Replace {
                    target: id,
                    with: w,
                })
            }
            3 => {
                let (then, els) = (ich[1], ich[2]);
                // 形态 B/C：then 以 continue 结尾、else 是 break → while (c) { then' }
                if ends_with_continue(then) && is_break(els) {
                    let rest = strip_tail_continue(then);
                    let inner = lang.build_block(rest);
                    let w = lang.while_(c, inner);
                    return Some(Edit::Replace {
                        target: id,
                        with: w,
                    });
                }
                // 形态 D：then 是 break、else 以 continue 结尾 → while (!c) { else' }
                if is_break(then) && ends_with_continue(els) {
                    let rest = strip_tail_continue(els);
                    let inner = lang.build_block(rest);
                    let nc = lang.build_unary(UnOp::Not, c);
                    let w = lang.while_(nc, inner);
                    return Some(Edit::Replace {
                        target: id,
                        with: w,
                    });
                }
                // 既有形态：while (true) { if (c) break; else { REST } … }
                if !is_do && is_break(then) {
                    let mut all = strip_tail_continue(els);
                    all.extend(bch[1..].iter().copied());
                    let inner = lang.build_block(all);
                    let nc = lang.build_unary(UnOp::Not, c);
                    let w = lang.while_(nc, inner);
                    return Some(Edit::Replace {
                        target: id,
                        with: w,
                    });
                }
                None
            }
            _ => None,
        }
    }
}

pub struct WhileIteratorToForEach;

impl Rule<JavaAst> for WhileIteratorToForEach {
    fn name(&self) -> &'static str {
        "while_iterator_to_for_each"
    }
    fn kinds(&self) -> &'static [NodeKind] {
        &[NodeKind::While]
    }
    fn check(&self, ctx: RewriteCtx<'_, JavaAst>, id: JavaId) -> Option<Edit<JavaAst>> {
        // 先取结构信息（避免 lang 的可变借用与 ctx 方法冲突）
        let parent = ctx.parent(id)?;
        let idx = ctx.index(id)?;
        let lang = ctx.lang;
        if lang.kind(id) != NodeKind::While {
            return None;
        }
        let wch = lang.children(id).to_vec();
        let body = wch[1];
        // 前置声明：Iterator<…> it = <iterable>.iterator();
        if lang.kind(parent) != NodeKind::Block {
            return None;
        }
        if idx == 0 {
            return None;
        }
        let stmts = lang.children(parent).to_vec();
        // 向上扫描（最多 4 条）找 it 的 VarDecl（声明与 while 之间可能夹
        // 无关语句，如 acc 声明）；中间语句引用 it 则拒
        let cond = wch[0];
        let it_hint = match lang.kind(cond) {
            NodeKind::Call => {
                let cc0 = lang.children(cond).to_vec();
                match lang.data(*cc0.first()?) {
                    NodeData::Member { name } if lang.sn(*name) == "hasNext" => {
                        lang.var_name(lang.children(cc0[0])[0]).map(|x| x.to_string())
                    }
                    _ => None,
                }
            }
            _ => None,
        };
        let mut decl = None;
        if let Some(hint) = it_hint {
            let mut up = idx;
            for _ in 0..4 {
                if up == 0 {
                    break;
                }
                up -= 1;
                let st = stmts[up];
                if lang.kind(st) == NodeKind::VarDecl && lang.var_name(st) == Some(hint.as_str()) {
                    decl = Some(st);
                    break;
                }
                if subtree_has_var(lang, st, &hint) {
                    break;
                }
            }
        }
        let decl = decl?;
        let it_name = lang.var_name(decl)?.to_string();
        // it 在 while **之后**不得再被引用：for-each 把迭代器声明消费进循
        // 环头，循环后残留的裸名引用会悬空（Kotlin 协程状态机的保存块
        // `it2x = iterator;`——ddc lark viewmodel/a 复现：找到符号 →
        // 找不到符号）。rest = 同块 while 之后的全部语句（含嵌套子树）。
        if stmts[idx + 1..]
            .iter()
            .any(|&s| subtree_has_var(lang, s, &it_name))
        {
            return None;
        }
        let init_call = lang.children(decl).first().copied()?;
        if lang.kind(init_call) != NodeKind::Call {
            return None;
        }
        let ic = lang.children(init_call).to_vec();
        let NodeData::Member { name: m0 } = lang.data(*ic.first()?) else {
            return None;
        };
        if lang.sn(*m0) != "iterator" || ic.len() != 1 {
            return None;
        }
        let iterable = lang.children(ic[0])[0];
        if subtree_has_var(&*lang, iterable, &it_name) {
            return None;
        }
        // ===== for-each 可迭代位静态类型门 =====
        // for (T e : expr) 要求 expr 的静态类型是数组或 java.lang.Iterable
        // 子类型。源码级只有 VarRef 的**声明类型**可见（NewArray 本就无
        // .iterator() 调用，不会走到这）；不透明方法调用返回值与不透明
        // 类名（Kotlin Sequence：d7.j.f(…) 的返回 / d7.e 形参）都判不
        // 出 Iterable —— 内联成 for-each 会产出「for-each 不适用于表达
        // 式类型」（ddc 输出 FileHelper$removeFirstLinesFromFile$1 /
        // k6.h0 复现）。类型未知或不在已知 Iterable 族白名单 → 保守拒
        // 绝（保留 while 形态，语义不变）。
        {
            // 裸 VarRef 接收位：声明类型白名单；链式 Map 视图调用
            // （`m.keySet().iterator()`——Call 无 var_type）按方法名 +
            // 接收者 Map 族声明裁决（98c34d9 的门曾一律拒绝该形态，
            // new_rules iterator_element_type_from_declaration 抓获）
            let ok = match lang.var_type(iterable) {
                Some(t) => statically_iterable(t),
                None => map_view_synthetic_ty(lang, iterable).is_some(),
            };
            if !ok {
                return None;
            }
        }
        // cond: it.hasNext()
        if lang.kind(cond) != NodeKind::Call {
            return None;
        }
        let cc = lang.children(cond).to_vec();
        let NodeData::Member { name: m1 } = lang.data(*cc.first()?) else {
            return None;
        };
        if lang.sn(*m1) != "hasNext" || cc.len() != 1 {
            return None;
        }
        if lang.var_name(lang.children(cc[0])[0]) != Some(it_name.as_str()) {
            return None;
        }
        // body: Block[ VarDecl e = it.next();, REST… ]
        if lang.kind(body) != NodeKind::Block {
            return None;
        }
        let bch = lang.children(body).to_vec();
        let first = *bch.first()?;
        if lang.kind(first) != NodeKind::VarDecl {
            // ===== 内联形态：body 中恰好一次 it.next()（可能 Cast/Paren 包裹）=====
            // it 在体内只能出现这一次（hasNext 已在 cond 消费）
            let it_refs_in_body: Vec<JavaId> = {
                let mut v = Vec::new();
                collect_var_refs(&*lang, body, &it_name, &mut v);
                v
            };
            if it_refs_in_body.len() != 1 {
                return None;
            }
            let next_recv = it_refs_in_body[0];
            // receiver 的父是 Member{next}，Member 的父才是 Call（无实参）
            let member = parent_of_recv(lang, body, next_recv);
            if lang.kind(member) != NodeKind::Member {
                return None;
            }
            let NodeData::Member { name: mn } = lang.data(member) else {
                return None;
            };
            if lang.sn(*mn) != "next" {
                return None;
            }
            let next_call = parent_of_recv(lang, body, member);
            if lang.kind(next_call) != NodeKind::Call {
                return None;
            }
            if lang.children(next_call).len() != 1 {
                return None;
            }
            // 包裹节点（要被替换的）：从 next_call 向上收集 Cast/Paren
            let mut wrapped = next_call;
            loop {
                let par = parent_of_recv(lang, body, wrapped);
                match lang.kind(par) {
                    NodeKind::Cast | NodeKind::Paren => wrapped = par,
                    _ => break,
                }
            }
            // 消费条件性守卫（第 12 轮攻击 A4a 抓获）：next() 必须每轮
            // **无条件求值一次**。两类条件语境拒绝：
            //   a) 语句级：wrapped 所在语句嵌于 if/for/while/try/catch/
            //      switch/synchronized 内（消费次数或 0 或 N——A4a 内层
            //      for 消费 3 个/外层轮 → 3 9 变 9 27 实锤）；
            //   b) 表达式级：三元分支位 / 短路 &&、|| 右操作数（求值可跳过）。
            // 顺序包裹（Block/Group/ExprStmt/Label/Return/Throw）与无条件
            // 求值位（Call/New 实参、非短路 Binary、Assign、Cast、Paren、
            // Index）放行
            {
                let mut cur = wrapped;
                while cur != body {
                    let par = parent_of_recv(lang, body, cur);
                    if par == body || par == cur {
                        break; // 直达 body（防御：不在子树内则停）
                    }
                    let ch = lang.children(par).to_vec();
                    let idx = ch.iter().position(|&c| c == cur);
                    match lang.kind(par) {
                        NodeKind::Block
                        | NodeKind::ExprStmt
                        | NodeKind::Label
                        | NodeKind::Return
                        | NodeKind::Throw => {}
                        NodeKind::Ternary => {
                            // 分支位（1/2）条件求值；条件位（0）无条件
                            if idx.unwrap_or(0) > 0 {
                                return None;
                            }
                        }
                        NodeKind::Binary => {
                            if let Some(op) = lang.bin_op(par) {
                                if matches!(op, BinOp::And | BinOp::Or) && idx == Some(1) {
                                    return None; // 短路右操作数
                                }
                            }
                        }
                        NodeKind::If
                        | NodeKind::While
                        | NodeKind::DoWhile
                        | NodeKind::For
                        | NodeKind::Switch
                        | NodeKind::Try
                        | NodeKind::Catch
                        | NodeKind::Synchronized
                        | NodeKind::ForEach => {
                            return None;
                        }
                        // Lambda 体：延迟求值（可能永不调用）——R13 T2d/
                        // T2f 抓获：() -> it.next() 传给从不调的方法曾被
                        // 折进 for-each 隐式消费（11→3）；Assert：仅在断言
                        // 启用且到达时求值（默认禁用 = 0 消费）——T2e
                        NodeKind::Lambda | NodeKind::Assert => {
                            return None;
                        }
                        _ => {} // Call 实参/New 实参/Assign/Cast/Paren/Index…
                    }
                    cur = par;
                }
            }
            // 循环变量类型推导（三源优先级）：
            // 1) **迭代器声明类型的泛型实参**（`Iterator<ByteArrayWrapper> it`
            //    → ByteArrayWrapper——最可靠：声明即约束，jedis JedisByteMap
            //    抓获：曾退化成 Object → e.data 编译错误，38 处/28 文件）
            // 2) 可迭代对象的元素类型（ArrayList<String>→String，裸类型→Object）
            // 元素为 Object 时【保留 Cast】（裸集合上 for (String e : raw) 非法，
            // 必须 for (Object e) + (String) e）
            let it_decl_elem = match lang.data(decl) {
                NodeData::VarDecl { ty, .. } => generic_elem_ty(ty),
                _ => None,
            };
            let elem = match it_decl_elem {
                Some(t) => t,
                None => match lang.var_type(iterable) {
                    Some(t) => generic_elem_ty(t).unwrap_or(JType::Ref("Object".into())),
                    None => JType::Ref("Object".into()),
                },
            };
            let elem = if for_each_elem_ok(&elem) {
                elem
            } else {
                JType::Ref("Object".into())
            };
            let is_object = matches!(&elem, JType::Ref(n) if n == "Object");
            let (replace_target, e_ty) = match lang.data(wrapped) {
                NodeData::Cast { .. } if is_object => (next_call, elem),
                NodeData::Cast { ty } => (wrapped, if is_object { ty.clone() } else { elem }),
                _ => (wrapped, elem),
            };
            // 新变量名（不与体内现有变量/catch 形参/for-each 绑定冲突——
            // A4c 抓获：catch (Exception e) 的形参不在 VarRef/VarDecl 域，
            // 撞名输出 javac「已定义变量 e」）
            let taken = |nm: &str| {
                subtree_has_var(&*lang, body, nm)
                    || subtree_has_binding(&*lang, body, nm)
            };
            let e_name = if taken("e") {
                if taken("e2") { "e3" } else { "e2" }
            } else {
                "e"
            };
            let e_ref = lang.var(e_name);
            let foreach = lang.for_each(e_name, e_ty, iterable, body);
            // 语句位置的裸 it.next();（ExprStmt 内容全体 = 该调用）——
            // 替换成 e; 不是合法语句（ConfigurationKeysLoader 抓获）；
            // for-each 已隐式消费元素 → 整条 ExprStmt 删除
            let wrapped_parent = parent_of_recv(lang, body, wrapped);
            if lang.kind(wrapped_parent) == NodeKind::ExprStmt
                && *lang.children(wrapped_parent).first().unwrap_or(&wrapped) == wrapped
            {
                let stmt_block = parent_of_recv(lang, body, wrapped_parent);
                if let Some(si) = lang
                    .children(stmt_block)
                    .iter()
                    .position(|&c| c == wrapped_parent)
                {
                    return Some(Edit::Multi(vec![
                        Edit::Splice {
                            node: stmt_block,
                            index: si,
                            remove: 1,
                            insert: vec![],
                        },
                        Edit::Splice {
                            node: parent,
                            index: idx,
                            remove: 1,
                            insert: vec![foreach],
                        },
                        Edit::Delete { node: decl },
                    ]));
                }
            }
            return Some(Edit::Multi(vec![
                Edit::Replace {
                    target: replace_target,
                    with: e_ref,
                },
                Edit::Splice {
                    node: parent,
                    index: idx,
                    remove: 1,
                    insert: vec![foreach],
                },
                Edit::Delete { node: decl },
            ]));
        }
        let NodeData::VarDecl { name: e_name, ty, .. } = lang.data(first) else {
            return None;
        };
        let (e_name, ty) = (e_name.clone(), ty.clone());
        let next_call = lang.children(first).first().copied()?;
        let next_call = unwrap_paren_cast(&*lang, next_call);
        if lang.kind(next_call) != NodeKind::Call {
            return None;
        }
        let nc = lang.children(next_call).to_vec();
        let NodeData::Member { name: m2 } = lang.data(*nc.first()?) else {
            return None;
        };
        if lang.sn(*m2) != "next" || nc.len() != 1 {
            return None;
        }
        if lang.var_name(lang.children(nc[0])[0]) != Some(it_name.as_str()) {
            return None;
        }
        // 裸集合（元素 Object）上 for (更窄类型 e : raw) 非法 → 保守拒绝
        let elem_is_object = match lang.var_type(iterable) {
            Some(it_t) => generic_elem_ty(it_t).is_none(),
            None => map_view_synthetic_ty(lang, iterable)
                .as_ref()
                .and_then(generic_elem_ty)
                .is_none(),
        };
        if elem_is_object && ty != JType::Ref("Object".into()) {
            return None;
        }
        // 通配符元素（Iterator<?> → for (? e : …) 非法）→ Object 兜底
        let ty = if for_each_elem_ok(&ty) { ty } else { JType::Ref("Object".into()) };
        let rest = bch[1..].to_vec();
        for &r in &rest {
            if subtree_has_var(&*lang, r, &it_name) {
                return None;
            }
        }
        let new_body = lang.build_block(rest);
        let foreach = lang.for_each(&e_name, ty, iterable, new_body);
        // 用 for-each 替换 while + 删除 it 声明（两处独立位置，
        // 顺序先 Splice（较大索引）后 Delete）
        Some(Edit::Multi(vec![
            Edit::Splice {
                node: parent,
                index: idx,
                remove: 1,
                insert: vec![foreach],
            },
            Edit::Delete { node: decl },
        ]))
    }
}

// ---------------------------------------------------------------------------
// 拼接中的 String.valueOf 剥离（混淆器/反编译器包装）：
//   String.valueOf(x) + y  →  x + y（y 为 String 字面量/已知 String 时）
//   y + String.valueOf(x)  →  y + x（同上）
// 安全性：valueOf 的字符串化语义与 + 拼接的隐式转换一致（null → "null"）；
// 守卫：另一侧必须可证为 String（保证 + 是拼接而非数值加法）。
// ---------------------------------------------------------------------------

pub struct ConcatValueOfDrop;

impl Rule<JavaAst> for ConcatValueOfDrop {
    fn name(&self) -> &'static str {
        "concat_value_of_drop"
    }
    fn kinds(&self) -> &'static [NodeKind] {
        &[NodeKind::Binary]
    }
    fn check(&self, ctx: RewriteCtx<'_, JavaAst>, id: JavaId) -> Option<Edit<JavaAst>> {
        let root = ctx.root();
        let lang = ctx.lang;
        if lang.kind(id) != NodeKind::Binary {
            return None;
        }
        if lang.bin_op(id) != Some(BinOp::Add) {
            return None;
        }
        let ch = lang.children(id).to_vec();
        let (l, r) = (ch[0], ch[1]);
        // 折叠后若成为常量表达式（双方均字面量），拼接串会被 javac 池化，
        // 而原 valueOf(...) 调用是运行期新建 → == 语义会变 → 身份守卫
        let becomes_constant = |x: JavaId, other: JavaId| {
            lang.literal(x).is_some() && matches!(lang.literal(other), Some(LitRef::Str(_)))
        };
        let is_value_of = |n: JavaId| -> Option<JavaId> {
            if lang.kind(n) != NodeKind::Call {
                return None;
            }
            let c = lang.children(n).to_vec();
            if c.len() != 2 {
                return None;
            }
            let callee = c[0];
            if let NodeData::Member { name } = lang.data(callee) {
                if lang.sn(*name) == "valueOf" && lang.var_name(lang.children(callee)[0]) == Some("String") {
                    return Some(c[1]);
                }
            }
            if let NodeData::VarRef { name } = lang.data(callee) {
                if lang.sn(*name) == "valueOf" {
                    return Some(c[1]);
                }
            }
            None
        };
        let stringy = |n: JavaId| -> bool {
            matches!(lang.literal(n), Some(LitRef::Str(_)))
                || lang
                    .var_type(n)
                    .is_some_and(|t| matches!(t, JType::Ref(n) if n == "String"))
        };
        // String.valueOf(x) + y（y 可证 String）
        if let Some(x) = is_value_of(l) {
            if stringy(r) {
                if becomes_constant(x, r) && lang.has_string_identity_compare(root) {
                    return None;
                }
                let with = lang.build_bin(BinOp::Add, x, r);
                return Some(Edit::Replace {
                    target: id,
                    with,
                });
            }
        }
        // y + String.valueOf(x)
        if let Some(x) = is_value_of(r) {
            if stringy(l) {
                if becomes_constant(x, l) && lang.has_string_identity_compare(root) {
                    return None;
                }
                let with = lang.build_bin(BinOp::Add, l, x);
                return Some(Edit::Replace {
                    target: id,
                    with,
                });
            }
        }
        None
    }
}


// ---------------------------------------------------------------------------
// 语句级 StringBuilder 链还原（ddc/jcdc 经典产物）：
//   StringBuilder v0 = new StringBuilder().append(a0);
//   v0 = v0.append(a1);              // 重赋值形态
//   StringBuilder v1 = v0.append(a2); // 新变量形态
//   String s = v1.toString();
//   →  String s = <a0 + a1 + a2>;
// 守卫：链上每个变量的读次数恰为 1（仅作下一步 receiver），
// 首参非 String 时前置 ""（与表达式版一致）；容量构造不折叠。
// 语义：各实参按序求值一次，两种形态一致。
// ---------------------------------------------------------------------------

pub struct StringBuilderStatements;

fn count_var_uses_in(lang: &JavaAst, root: JavaId, name: &str) -> usize {
    // 语义上是【读】的 VarRef 计数：简单赋值的 target 是纯写（不计）；
    // 复合赋值（x += 1）与 inc/dec 的 target 是读+写（计）。
    let mut n = 0;
    let mut stack = vec![root];
    while let Some(x) = stack.pop() {
        if lang.kind(x) == NodeKind::Assign && lang.assign_op(x).is_none() {
            let ch = lang.children(x).to_vec();
            if let Some(&t) = ch.first() {
                let is_named_target =
                    lang.kind(t) == NodeKind::VarRef && lang.var_name(t) == Some(name);
                if !is_named_target {
                    stack.push(t);
                }
                for &c in &ch[1..] {
                    stack.push(c);
                }
            }
            continue;
        }
        if lang.kind(x) == NodeKind::VarRef && lang.var_name(x) == Some(name) {
            n += 1;
        }
        for &c in lang.children(x) {
            stack.push(c);
        }
    }
    n
}

impl Rule<JavaAst> for StringBuilderStatements {
    fn name(&self) -> &'static str {
        "string_builder_statements"
    }
    fn kinds(&self) -> &'static [NodeKind] {
        &[NodeKind::VarDecl]
    }
    fn check(&self, ctx: RewriteCtx<'_, JavaAst>, id: JavaId) -> Option<Edit<JavaAst>> {
        // 取结构信息（避免与 ctx 方法借用冲突）
        let parent = ctx.parent(id)?;
        let idx = ctx.index(id)?;
        let root = ctx.root();
        let lang = ctx.lang;

        if lang.kind(id) != NodeKind::VarDecl {
            return None;
        }
        if lang.kind(parent) != NodeKind::Block {
            return None;
        }
        let v0 = lang.var_name(id)?.to_string();
        // init: new SB().append(a0)
        let init = *lang.children(id).first()?;
        if lang.kind(init) != NodeKind::Call {
            return None;
        }
        let ic = lang.children(init).to_vec();
        if ic.len() != 2 {
            return None;
        }
        let NodeData::Member { name: m0 } = lang.data(ic[0]) else {
            return None;
        };
        if lang.sn(*m0) != "append" {
            return None;
        }
        let sb_new = lang.children(ic[0])[0];
        let (ctor_arg, a0) = match lang.data(sb_new) {
            NodeData::New { ty, .. } => {
                let is_sb = !lang.unit_shadows_lang
                && matches!(ty, JType::Ref(n) if n == "StringBuilder" || n == "java.lang.StringBuilder");
                if !is_sb {
                    return None;
                }
                let args = lang.children(sb_new).to_vec();
                match args.len() {
                    0 => (None, ic[1]),
                    1 => {
                        let a = args[0];
                        let stringy = matches!(lang.literal(a), Some(LitRef::Str(_)))
                            || lang
                                .var_type(a)
                                .is_some_and(|t| matches!(t, JType::Ref(n) if n == "String"));
                        if stringy {
                            (Some(a), ic[1])
                        } else if matches!(
                            lang.literal(a),
                            Some(LitRef::Int(_) | LitRef::Long(_))
                        ) {
                            // int/long 字面量必为容量构造——无语义差异
                            (None, ic[1])
                        } else {
                            return None; // 变量实参类型不可证
                        }
                    }
                    _ => return None,
                }
            }
            _ => return None,
        };

        let stmts = lang.children(parent).to_vec();
        // 沿链前进：收集 append 实参与链语句
        let mut parts: Vec<JavaId> = vec![a0];
        let mut expected_reads: std::collections::HashMap<String, usize> =
            std::collections::HashMap::new();
        let mut chain_len = 1usize; // 已消费 v0 的 decl
        let mut cur = v0.clone();
        while idx + chain_len < stmts.len() {
            let s = stmts[idx + chain_len];
            let (recv, arg, new_var, consumed) = match lang.data(s) {
                // v = v.append(arg)（重赋值；ExprStmt 包裹或裸）
                NodeData::Assign { op: None } => {
                    let ch = lang.children(s).to_vec();
                    if ch.len() != 2 {
                        break;
                    }
                    let (t, v) = (ch[0], ch[1]);
                    if lang.kind(t) != NodeKind::VarRef
                        || lang.var_name(t) != Some(cur.as_str())
                        || lang.kind(v) != NodeKind::Call
                    {
                        break;
                    }
                    let vc = lang.children(v).to_vec();
                    if vc.len() != 2 {
                        break;
                    }
                    let NodeData::Member { name: mn } = lang.data(vc[0]) else {
                        break;
                    };
                    if lang.sn(*mn) != "append" {
                        break;
                    }
                    let recv = lang.children(vc[0])[0];
                    (recv, vc[1], false, s)
                }
                NodeData::ExprStmt => {
                    let ch = lang.children(s).to_vec();
                    if ch.len() != 1 {
                        break;
                    }
                    let inner = ch[0];
                    if !matches!(lang.data(inner), NodeData::Assign { op: None }) {
                        break;
                    }
                    let ach = lang.children(inner).to_vec();
                    if ach.len() != 2 {
                        break;
                    }
                    let (t, v) = (ach[0], ach[1]);
                    if lang.kind(t) != NodeKind::VarRef
                        || lang.var_name(t) != Some(cur.as_str())
                        || lang.kind(v) != NodeKind::Call
                    {
                        break;
                    }
                    let vc = lang.children(v).to_vec();
                    if vc.len() != 2 {
                        break;
                    }
                    let NodeData::Member { name: mn } = lang.data(vc[0]) else {
                        break;
                    };
                    if lang.sn(*mn) != "append" {
                        break;
                    }
                    let recv = lang.children(vc[0])[0];
                    (recv, vc[1], false, s)
                }
                // StringBuilder v2 = v.append(arg)（新变量）
                NodeData::VarDecl { .. } => {
                    let init = match lang.children(s).first() {
                        Some(&x) => x,
                        None => break,
                    };
                    if lang.kind(init) != NodeKind::Call {
                        break;
                    }
                    let vc = lang.children(init).to_vec();
                    if vc.len() != 2 {
                        break;
                    }
                    let NodeData::Member { name: mn } = lang.data(vc[0]) else {
                        break;
                    };
                    if lang.sn(*mn) != "append" {
                        break;
                    }
                    let recv = lang.children(vc[0])[0];
                    if lang.var_name(recv) != Some(cur.as_str()) {
                        break;
                    }
                    (recv, vc[1], true, s)
                }
                _ => break,
            };
            // receiver 必须是当前变量
            if lang.var_name(recv) != Some(cur.as_str()) {
                break;
            }
            parts.push(arg);
            *expected_reads.entry(cur.clone()).or_insert(0) += 1;
            if new_var {
                cur = lang.var_name(consumed)?.to_string();
            }
            chain_len += 1;
            let _ = consumed;
        }

        // 链后必须紧跟：String s = <cur>.toString();
        let final_stmt = *stmts.get(idx + chain_len)?;
        let NodeData::VarDecl { .. } = lang.data(final_stmt) else {
            return None;
        };
        let s_init = *lang.children(final_stmt).first()?;
        if lang.kind(s_init) != NodeKind::Call {
            return None;
        }
        let sc = lang.children(s_init).to_vec();
        if sc.len() != 1 {
            return None;
        }
        let NodeData::Member { name: mn } = lang.data(sc[0]) else {
            return None;
        };
        if lang.sn(*mn) != "toString" {
            return None;
        }
        if lang.var_name(lang.children(sc[0])[0]) != Some(cur.as_str()) {
            return None;
        }

        // 读次数守卫：实际读数 == 链内预期读数（receiver 次数 + toString 1 次），
        // 差值即存在链外使用 → 拒绝
        *expected_reads.entry(cur.clone()).or_insert(0) += 1; // toString receiver
        for (v, exp) in &expected_reads {
            if count_var_uses_in(&*lang, parent, v) != *exp {
                return None;
            }
        }

        // 构造拼接表达式（全字面量链会折叠成常量表达式 → 池化 → 身份守卫）
        let mut all_parts: Vec<JavaId> = Vec::new();
        if let Some(ca) = ctor_arg {
            all_parts.push(ca);
        }
        all_parts.extend(parts);
        if all_parts.iter().all(|&p| lang.literal(p).is_some())
            && lang.has_string_identity_compare(root)
        {
            return None;
        }
        if all_parts.is_empty() {
            let empty = lang.build_str("");
            return Some(Edit::Multi(vec![
                Edit::Replace {
                    target: s_init,
                    with: empty,
                },
                Edit::Splice {
                    node: parent,
                    index: idx,
                    remove: chain_len,
                    insert: Vec::new(),
                },
            ]));
        }
        let first = all_parts[0];
        let stringy_first = matches!(lang.literal(first), Some(LitRef::Str(_)))
            || lang
                .var_type(first)
                .is_some_and(|t| matches!(t, JType::Ref(n) if n == "String"));
        let mut acc = if stringy_first {
            first
        } else {
            let empty = lang.build_str("");
            lang.build_bin(BinOp::Add, empty, first)
        };
        for &p in &all_parts[1..] {
            acc = lang.build_bin(BinOp::Add, acc, p);
        }
        Some(Edit::Multi(vec![
            Edit::Replace {
                target: s_init,
                with: acc,
            },
            Edit::Splice {
                node: parent,
                index: idx,
                remove: chain_len,
                insert: Vec::new(),
            },
        ]))
    }
}


// ---------------------------------------------------------------------------
// 尾部 continue 删除（标签感知版，从引擎移入）：
//   循环体最后一条 continue：无标签，或标签即本循环 → 与落入下一轮等价，删除。
//   标签指向外层循环 → 语义不同，保留。
// ---------------------------------------------------------------------------

pub struct TrailingContinueJava;

impl Rule<JavaAst> for TrailingContinueJava {
    fn name(&self) -> &'static str {
        "trailing_continue"
    }
    fn kinds(&self) -> &'static [NodeKind] {
        &[NodeKind::While, NodeKind::For, NodeKind::DoWhile, NodeKind::ForEach]
    }
    fn check(&self, ctx: RewriteCtx<'_, JavaAst>, id: JavaId) -> Option<Edit<JavaAst>> {
        let parent = ctx.parent(id)?;
        let lang = ctx.lang;
        let body = match lang.kind(id) {
            NodeKind::While | NodeKind::For | NodeKind::DoWhile | NodeKind::ForEach => {
                *lang.children(id).last()?
            }
            _ => return None,
        };
        if lang.kind(body) != NodeKind::Block {
            return None;
        }
        let ch = lang.children(body).to_vec();
        let last = *ch.last()?;
        if lang.kind(last) != NodeKind::Continue {
            return None;
        }
        let label = match lang.data(last) {
            NodeData::Continue { label } => label.clone(),
            _ => return None,
        };
        match label {
            None => Some(Edit::Delete { node: last }),
            Some(l) => {
                // 标签必须命名本循环：父链上是 Label{l} 包着本循环
                if lang.kind(parent) == NodeKind::Label {
                    if let NodeData::Label { name } = lang.data(parent) {
                        if *name == l {
                            return Some(Edit::Delete { node: last });
                        }
                    }
                }
                None
            }
        }
    }
}


// ---------------------------------------------------------------------------
// 异或噪声消除（Java 语义版）：Java 中 ^ 的操作数必为整型，
// 故无需 is_exact_int 类型证明即可折叠——覆盖含副作用/未知类型的场景：
//   (mark(5) ^ 0x5A) ^ 0x5A → mark(5)（调用保留、位置不变）
//   x ^ 0 / 0 ^ x → x
// ---------------------------------------------------------------------------

pub struct XorNoise;

impl Rule<JavaAst> for XorNoise {
    fn name(&self) -> &'static str {
        "xor_noise"
    }
    fn kinds(&self) -> &'static [NodeKind] {
        &[NodeKind::Binary]
    }
    fn check(&self, ctx: RewriteCtx<'_, JavaAst>, id: JavaId) -> Option<Edit<JavaAst>> {
        let lang = ctx.lang;
        if lang.kind(id) != NodeKind::Binary {
            return None;
        }
        let op = lang.bin_op(id)?;
        if op != BinOp::BitXor {
            return None;
        }
        let ch = lang.children(id).to_vec();
        let (l, r) = (ch[0], ch[1]);
        // x ^ 0 / 0 ^ x → x（x 任意：求值位置与次数都不变）
        let int_lit = |n: JavaId| lang.literal(n).and_then(|x| x.as_int());
        if int_lit(r) == Some(0) {
            return Some(Edit::Replace {
                target: id,
                with: l,
            });
        }
        if int_lit(l) == Some(0) {
            return Some(Edit::Replace {
                target: id,
                with: r,
            });
        }
        // (x ^ K1) ^ K2 → x ^ (K1^K2)；K1^K2 == 0 → x（x 任意，保留原位）
        if lang.kind(l) != NodeKind::Binary || lang.bin_op(l) != Some(BinOp::BitXor) {
            return None;
        }
        let ich = lang.children(l).to_vec();
        let k1 = lang.literal(ich[1]).and_then(|x| x.as_int())?;
        let k2 = int_lit(r)?;
        let x = ich[0];
        let k = k1 ^ k2;
        let with = if k == 0 {
            x
        } else {
            let lit = lang.build_int(k, false);
            lang.build_bin(BinOp::BitXor, x, lit)
        };
        Some(Edit::Replace {
            target: id,
            with,
        })
    }
}

// ---------------------------------------------------------------------------
// 字面量 length 折叠："abc".length() → 3（字符串字面量长度编译期已知）。
// ---------------------------------------------------------------------------

pub struct StrLenFold;

impl Rule<JavaAst> for StrLenFold {
    fn name(&self) -> &'static str {
        "str_len_fold"
    }
    fn kinds(&self) -> &'static [NodeKind] {
        &[NodeKind::Call]
    }
    fn check(&self, ctx: RewriteCtx<'_, JavaAst>, id: JavaId) -> Option<Edit<JavaAst>> {
        // 语句位标志先取（ctx.lang 借用后 ctx 部分移动——R13 教训）
        let _at_stmt_pos = ctx
            .parent(id)
            .map(|p| ctx.lang.kind(p) == NodeKind::ExprStmt)
            .unwrap_or(false);
        let lang = ctx.lang;
        if lang.kind(id) != NodeKind::Call {
            return None;
        }
        let ch = lang.children(id).to_vec();
        if ch.len() != 1 {
            return None;
        }
        let NodeData::Member { name } = lang.data(ch[0]) else {
            return None;
        };
        if lang.sn(*name) != "length" {
            return None;
        }
        let recv = lang.children(ch[0])[0];
        if let Some(LitRef::Str(s)) = lang.literal(recv) {
            let with = lang.build_int(s.chars().count() as i64, false);
            return Some(Edit::Replace {
                target: id,
                with,
            });
        }
        None
    }
}


// ---------------------------------------------------------------------------
// 部分求值器（"虚拟执行"）：纯 JDK 方法 + 全字面量实参 → 编译期求值。
// 只在**求值成功**时折叠（失败/越界/异常路径保持原样交给运行时）。
// 覆盖混淆器常用的字符串藏匿手段：
//   "HelloWorld".substring(0,5) / .indexOf / .replace / .trim / .startsWith…
//   Integer.parseInt("42") / String.format("%s=%d",…) / String.valueOf
//   Math.abs/max/min / Character.isXxx / (char)('a'+2)
//   {"a","b"}[1]（字面量数组下标） / Base64 解码链 new String(decoder.decode("…"))
// 语义安全边界：不折 toUpperCase/toLowerCase（locale 敏感）、
// parseInt 解析失败不折、substring 越界不折。
// ---------------------------------------------------------------------------

pub struct LiteralEval;

impl Rule<JavaAst> for LiteralEval {
    fn name(&self) -> &'static str {
        "literal_eval"
    }
    fn kinds(&self) -> &'static [NodeKind] {
        &[NodeKind::Call, NodeKind::Index, NodeKind::Cast]
    }
    fn check(&self, ctx: RewriteCtx<'_, JavaAst>, id: JavaId) -> Option<Edit<JavaAst>> {
        let root = ctx.root();
        let lang = ctx.lang;
        let edit = match lang.kind(id) {
            NodeKind::Call => self.eval_call(&mut *lang, id),
            NodeKind::Index => self.eval_index(&mut *lang, id),
            NodeKind::Cast => eval_cast_literal(&mut *lang, id),
            _ => None,
        };
        // Str 字面量结果：原表达式（valueOf/toString/concat/substring…）是运行期
        // 新建的串，折成字面量会引入池化引用；若方法内存在 String 的 ==/!=，
        // 身份语义可能改变 → 守卫。Bool/Int 结果走值语义，不受影响。
        if let Some(Edit::Replace { with, .. }) = &edit {
            if matches!(lang.literal(*with), Some(LitRef::Str(_)))
                && lang.has_string_identity_compare(root)
            {
                if std::env::var("CURE_DEBUG_GATE").is_ok() {
                    eprintln!("[gate] blocked literal_eval at {id:?}");
                }
                return None;
            }
        }
        edit
    }
}

impl LiteralEval {
    fn eval_call(&self, lang: &mut JavaAst, id: JavaId) -> Option<Edit<JavaAst>> {
        let ch = lang.children(id).to_vec();
        let callee = ch[0];
        let NodeData::Member { name: method } = lang.data(callee) else {
            return None;
        };
        let method = *method;
        let recv = lang.children(callee)[0];
        // 实参必须全部为字面量
        let args: Vec<Lit> = ch[1..]
            .iter()
            .map(|&a| litref_to_lit(lang.literal(a)))
            .collect::<Option<Vec<_>>>()?;

        let result: Option<Lit> = if let Some(LitRef::Str(s)) = lang.literal(recv) {
            eval_str_method(s, lang.sn(method), &args)
        } else if let Some(cls) = lang.var_name(recv) {
            eval_static_method(cls, lang.sn(method), &args)
        } else {
            None
        };
        let lit = result?;
        let with = lit_to_node(lang, &lit);
        Some(Edit::Replace {
            target: id,
            with,
        })
    }

    fn eval_index(&self, lang: &mut JavaAst, id: JavaId) -> Option<Edit<JavaAst>> {
        // {"a","b"}[1] / new String[]{"a","b"}[1] → "b"（字面量数组 + 字面量下标，界内）
        let ch = lang.children(id).to_vec();
        // new T[]{…}（解析器归一化形态，sized=0 时唯一子节点是 ArrayLit）
        let arr = match lang.kind(ch[0]) {
            NodeKind::ArrayLit => ch[0],
            NodeKind::NewArray => {
                let nc = lang.children(ch[0]);
                let NodeData::NewArray { sized, .. } = lang.data(ch[0]) else {
                    return None;
                };
                if *sized != 0 || nc.len() != 1 || lang.kind(nc[0]) != NodeKind::ArrayLit {
                    return None;
                }
                nc[0]
            }
            _ => return None,
        };
        let idx = lang.literal(ch[1])?.as_int()?;
        let elems = lang.children(arr).to_vec();
        if idx < 0 || idx >= elems.len() as i64 {
            return None;
        }
        Some(Edit::Replace {
            target: id,
            with: elems[idx as usize],
        })
    }
}

fn litref_to_lit(l: Option<LitRef<'_>>) -> Option<Lit> {
    Some(match l? {
        LitRef::Str(s) => Lit::Str(s.to_string()),
        LitRef::Int(v) => Lit::Int(v),
        LitRef::Long(v) => Lit::Long(v),
        LitRef::Bool(b) => Lit::Bool(b),
        LitRef::Char(c) => Lit::Char(c),
        LitRef::Float(v) => Lit::Float(v),
        LitRef::Double(v) => Lit::Double(v),
        LitRef::Null => return None,
    })
}

fn lit_to_node(lang: &mut JavaAst, lit: &Lit) -> JavaId {
    match lit {
        Lit::Str(s) => lang.build_str(s),
        Lit::Int(v) => lang.build_int(*v, false),
        Lit::Long(v) => lang.build_int(*v, true),
        Lit::Bool(b) => lang.build_bool(*b),
        Lit::Char(c) => lang.build_char(*c),
        Lit::Float(v) => lang.lit(Lit::Float(*v)),
        Lit::Double(v) => lang.lit(Lit::Double(*v)),
        _ => lang.lit(Lit::Null),
    }
}

/// 字面量 cast 折叠：(char)('a'+1) → 'b、(int)'a' → 97、窄化仅在值域内。
fn eval_cast_literal(lang: &mut JavaAst, id: JavaId) -> Option<Edit<JavaAst>> {
    let NodeData::Cast { ty } = lang.data(id) else {
        return None;
    };
    let ty = ty.clone();
    let inner = lang.children(id)[0];
    let lit = litref_to_lit(lang.literal(inner))?;
    let with = match (&ty, &lit) {
        (JType::Char, Lit::Int(v)) if (0_i64..=0xFFFF).contains(v) => {
            lang.build_char(char::from_u32(*v as u32)?)
        }
        (JType::Char, Lit::Char(_)) => inner,
        (JType::Int, Lit::Char(c)) => lang.build_int(*c as i64, false),
        (JType::Long, Lit::Char(c)) => lang.build_int(*c as i64, true),
        (JType::Long, Lit::Int(v)) => lang.build_int(*v, true),
        (JType::Int, Lit::Long(v)) if *v >= i32::MIN as i64 && *v <= i32::MAX as i64 => {
            lang.build_int(*v, false)
        }
        (JType::Int, Lit::Int(_)) => inner,
        _ => return None,
    };
    Some(Edit::Replace {
        target: id,
        with,
    })
}

fn eval_str_method(s: &str, method: &str, args: &[Lit]) -> Option<Lit> {
    let chars: Vec<char> = s.chars().collect();
    let n = chars.len() as i64;
    Some(match (method, args) {
        ("isEmpty", []) => Lit::Bool(s.is_empty()),
        // JLS：字面量编译期即驻留池——"lit".intern() ≡ "lit"（同引用）
        ("intern", []) => Lit::Str(s.to_string()),
        ("trim", []) => Lit::Str(s.trim_matches(|c: char| c <= ' ').to_string()),
        ("concat", [Lit::Str(b)]) => Lit::Str(format!("{s}{b}")),
        ("startsWith", [Lit::Str(p)]) => Lit::Bool(s.starts_with(p.as_str())),
        ("endsWith", [Lit::Str(p)]) => Lit::Bool(s.ends_with(p.as_str())),
        ("contains", [Lit::Str(p)]) => Lit::Bool(s.contains(p.as_str())),
        ("equals", [Lit::Str(p)]) => Lit::Bool(s == p),
        ("equalsIgnoreCase", [Lit::Str(p)]) => {
            Lit::Bool(s.to_lowercase() == p.to_lowercase())
        }
        ("indexOf", [Lit::Char(c)]) => Lit::Int(
            s.find(*c).map(|i| i as i64).unwrap_or(-1),
        ),
        ("indexOf", [Lit::Str(p)]) => Lit::Int(
            s.find(p.as_str()).map(|i| i as i64).unwrap_or(-1),
        ),
        ("length", []) => Lit::Int(n),
        ("charAt", [Lit::Int(i)]) if *i >= 0 && *i < n => {
            Lit::Char(chars[*i as usize])
        }
        ("substring", [Lit::Int(b)]) if *b >= 0 && *b <= n => {
            Lit::Str(s.chars().skip(*b as usize).collect())
        }
        ("substring", [Lit::Int(b), Lit::Int(e)]) if *b >= 0 && *b <= *e && *e <= n => {
            Lit::Str(chars[*b as usize..*e as usize].iter().collect())
        }
        ("replace", [Lit::Char(a), Lit::Char(b)]) => {
            Lit::Str(s.chars().map(|c| if c == *a { *b } else { c }).collect())
        }
        ("replace", [Lit::Str(a), Lit::Str(b)]) if !a.is_empty() => {
            Lit::Str(s.replace(a.as_str(), b))
        }
        // String.hashCode 是 JLS 规定的确定性算法
        ("hashCode", []) => Lit::Int(
            s.chars()
                .fold(0i32, |h, c| h.wrapping_mul(31).wrapping_add(c as i32))
                as i64,
        ),
        _ => return None,
    })
}

fn eval_static_method(cls: &str, method: &str, args: &[Lit]) -> Option<Lit> {
    let cls = cls.rsplit('.').next().unwrap_or(cls);
    Some(match (cls, method, args) {
        ("Integer", "parseInt", [Lit::Str(s)]) => {
            Lit::Int(s.trim().parse::<i64>().ok()?)
        }
        ("Integer", "toString", [Lit::Int(v)]) => Lit::Str(v.to_string()),
        ("Integer", "toString", [Lit::Long(v)]) => Lit::Str(v.to_string()),
        ("Long", "parseLong", [Lit::Str(s)]) => Lit::Long(s.trim().parse::<i64>().ok()?),
        ("Long", "toString", [Lit::Int(v)]) => Lit::Str(v.to_string()),
        ("Long", "toString", [Lit::Long(v)]) => Lit::Str(v.to_string()),
        ("Boolean", "parseBoolean", [Lit::Str(s)]) => {
            Lit::Bool(s.eq_ignore_ascii_case("true"))
        }
        ("Boolean", "toString", [Lit::Bool(b)]) => Lit::Str(b.to_string()),
        ("String", "valueOf", [Lit::Str(s)]) => Lit::Str(s.clone()),
        ("String", "valueOf", [Lit::Int(v)]) => Lit::Str(v.to_string()),
        ("String", "valueOf", [Lit::Long(v)]) => Lit::Str(v.to_string()),
        ("String", "valueOf", [Lit::Char(c)]) => Lit::Str(c.to_string()),
        ("String", "valueOf", [Lit::Bool(b)]) => Lit::Str(b.to_string()),
        ("String", "format", fmt_args @ [Lit::Str(_), ..]) => {
            let fmt = match &fmt_args[0] {
                Lit::Str(s) => s.clone(),
                _ => return None,
            };
            let out = eval_string_format(&fmt, &fmt_args[1..])?;
            Lit::Str(out)
        }
        ("Math", "abs", [Lit::Int(v)]) => Lit::Int(v.wrapping_abs()),
        ("Math", "abs", [Lit::Long(v)]) => Lit::Long(v.wrapping_abs()),
        ("Math", "max", [Lit::Int(a), Lit::Int(b)]) => Lit::Int(*a.max(b)),
        ("Math", "min", [Lit::Int(a), Lit::Int(b)]) => Lit::Int(*a.min(b)),
        ("Math", "max", [Lit::Long(a), Lit::Long(b)]) => Lit::Long(*a.max(b)),
        ("Math", "min", [Lit::Long(a), Lit::Long(b)]) => Lit::Long(*a.min(b)),
        ("Character", "isDigit", [Lit::Char(c)]) => Lit::Bool(c.is_ascii_digit()),
        ("Character", "isLetter", [Lit::Char(c)]) => Lit::Bool(c.is_alphabetic()),
        ("Character", "isWhitespace", [Lit::Char(c)]) => Lit::Bool(c.is_whitespace()),
        ("Character", "isUpperCase", [Lit::Char(c)]) => Lit::Bool(c.is_uppercase()),
        ("Character", "isLowerCase", [Lit::Char(c)]) => Lit::Bool(c.is_lowercase()),
        ("Character", "toUpperCase", [Lit::Char(c)]) => Lit::Char(c.to_uppercase().next()?),
        ("Character", "toLowerCase", [Lit::Char(c)]) => Lit::Char(c.to_lowercase().next()?),
        ("Character", "toString", [Lit::Char(c)]) => Lit::Str(c.to_string()),
        _ => return None,
    })
}

/// String.format 最小子集：%s、%d、%%；其余转换（%f/%x/宽度/精度）不折。
fn eval_string_format(fmt: &str, args: &[Lit]) -> Option<String> {
    let mut out = String::new();
    let mut it = fmt.chars().peekable();
    let mut arg_i = 0usize;
    while let Some(c) = it.next() {
        if c != '%' {
            out.push(c);
            continue;
        }
        match it.next()? {
            '%' => out.push('%'),
            's' => {
                let a = args.get(arg_i)?;
                arg_i += 1;
                match a {
                    Lit::Str(s) => out.push_str(s),
                    Lit::Char(ch) => out.push(*ch),
                    Lit::Bool(b) => out.push_str(&b.to_string()),
                    _ => out.push_str(&lit_debug_str(a)),
                }
            }
            'd' => {
                let a = args.get(arg_i)?;
                arg_i += 1;
                match a {
                    Lit::Int(v) => out.push_str(&v.to_string()),
                    Lit::Long(v) => out.push_str(&v.to_string()),
                    Lit::Char(ch) => out.push_str(&(*ch as i64).to_string()),
                    _ => return None,
                }
            }
            // 未知/未支持转换：交给运行时
            _ => return None,
        }
    }
    if arg_i != args.len() {
        return None; // 实参数量与转换符不匹配 → 运行时异常路径，不折
    }
    Some(out)
}

fn lit_debug_str(l: &Lit) -> String {
    match l {
        Lit::Int(v) => v.to_string(),
        Lit::Long(v) => v.to_string(),
        _ => "?".into(),
    }
}

// ---------------------------------------------------------------------------
// Base64 字符串解码还原（混淆器标准藏匿手段）：
//   new String(Base64.getDecoder().decode("aGVsbG8=")) → "hello"
//   （URL 解码器同理；解码字节须为合法 UTF-8）
// ---------------------------------------------------------------------------


// ---------------------------------------------------------------------------
// URL 解码还原（混淆器 URL 编码字符串的逆操作）：
//   URLDecoder.decode("%E4%BD%A0", "UTF-8") → "你"
// 守卫：
//   - 两个参数全字面量；UTF-8/Locale.CHINA 等常规字符集名（无 charset
//     的单参形态按 UTF-8——JLS 规定 URLDecoder 无 charset 重载不存在，
//     单参是 6 字节 UTF-8 缺省过时形态，保守拒绝）
//   - 解码产物必须**全部可见**（控制字符/代理位不转——用户规则：
//     不可见字符不转换）
//   - 编码串 ≤ 8KB（超长解码性能保护——用户规则：特别长的跳过）
//   - 解码失败（非法 % 序列/未知 charset）→ 保持原样
// ---------------------------------------------------------------------------


/// Member 节点的成员名（Sym → str）。
fn member_name(ast: &JavaAst, m: JavaId) -> Option<String> {
    match ast.data(m) {
        NodeData::Member { name } => Some(ast.sn(*name).to_string()),
        _ => None,
    }
}

pub struct UrlDecodeFold;

impl Rule<JavaAst> for UrlDecodeFold {
    fn name(&self) -> &'static str {
        "url_decode_fold"
    }
    fn kinds(&self) -> &'static [NodeKind] {
        &[NodeKind::Call]
    }
    fn check(&self, ctx: RewriteCtx<'_, JavaAst>, id: JavaId) -> Option<Edit<JavaAst>> {
        let lang = ctx.lang;
        // 形态：URLDecoder.decode(s, charset)——callee 是 Member{decode}，
        // 接收者是 VarRef/Member 链（校验末端名字）
        let ch = lang.children(id).to_vec();
        if ch.len() != 3 {
            return None; // 只处理双参形态
        }
        let callee = ch[0];
        if lang.kind(callee) != NodeKind::Member {
            return None;
        }
        if member_name(lang, callee).as_deref() != Some("decode") {
            return None;
        }
        // 接收者链：URLDecoder（Member{URLDecoder} 或 Member{net.URLDecoder}）
        let recv = *lang.children(callee).first()?;
        let recv_name = match lang.kind(recv) {
            NodeKind::Member => member_name(lang, recv)?,
            NodeKind::VarRef => lang.var_name(recv)?.to_string(),
            _ => return None,
        };
        if !recv_name.ends_with("URLDecoder") {
            return None;
        }
        let s_lit = match lang.literal(ch[1])? {
            LitRef::Str(s) => s.to_string(),
            _ => return None,
        };
        // charset：仅接受 "UTF-8"（其余保守拒绝）
        let cs = match lang.literal(ch[2])? {
            LitRef::Str(s) => s.to_string(),
            _ => return None,
        };
        if cs != "UTF-8" {
            return None;
        }
        // 超长跳过
        if s_lit.len() > 8192 {
            return None;
        }
        let decoded = url_decode(&s_lit)?;
        // 可见性：控制字符/代理位 → 不转换
        if decoded.chars().any(|c| {
            c.is_control() || (c as u32) >= 0xD800 && (c as u32) <= 0xDFFF
        }) {
            return None;
        }
        let lit = lang.lit(Lit::Str(decoded));
        Some(Edit::Replace { target: id, with: lit })
    }
}

/// 手写 URL 解码（%XX + '+' → 空格），UTF-8 字节重组。
/// 非法序列（%后非 hex、孤立 UTF-8 字节）→ None。
fn url_decode(s: &str) -> Option<String> {
    let b = s.as_bytes();
    let mut out: Vec<u8> = Vec::with_capacity(b.len());
    let mut i = 0usize;
    while i < b.len() {
        match b[i] {
            b'+' => {
                out.push(b' ');
                i += 1;
            }
            b'%' => {
                if i + 3 > b.len() {
                    return None;
                }
                let hi = hex_val(b[i + 1])?;
                let lo = hex_val(b[i + 2])?;
                out.push(hi * 16 + lo);
                i += 3;
            }
            c => {
                out.push(c);
                i += 1;
            }
        }
    }
    String::from_utf8(out).ok()
}

fn hex_val(c: u8) -> Option<u8> {
    match c {
        b'0'..=b'9' => Some(c - b'0'),
        b'a'..=b'f' => Some(c - b'a' + 10),
        b'A'..=b'F' => Some(c - b'A' + 10),
        _ => None,
    }
}

pub struct Base64NewStringFold;

impl Rule<JavaAst> for Base64NewStringFold {
    fn name(&self) -> &'static str {
        "base64_new_string_fold"
    }
    fn kinds(&self) -> &'static [NodeKind] {
        &[NodeKind::New]
    }
    fn check(&self, ctx: RewriteCtx<'_, JavaAst>, id: JavaId) -> Option<Edit<JavaAst>> {
        let root = ctx.root();
        let lang = ctx.lang;
        let NodeData::New { ty, .. } = lang.data(id) else {
            return None;
        };
        if !matches!(ty, JType::Ref(n) if n == "String" || n == "java.lang.String") {
            return None;
        }
        // 折叠产出池化字面量，改变 String 引用身份 → 守卫
        if lang.has_string_identity_compare(root) {
            return None;
        }
        let args = lang.children(id).to_vec();
        if args.len() != 1 {
            return None;
        }
        // 参数：Base64.getXxxDecoder().decode("lit")
        if lang.kind(args[0]) != NodeKind::Call {
            return None;
        }
        let dc = lang.children(args[0]).to_vec();
        if dc.len() != 2 {
            return None;
        }
        let NodeData::Member { name: dn } = lang.data(dc[0]) else {
            return None;
        };
        if lang.sn(*dn) != "decode" {
            return None;
        }
        // recv = Base64.getXxxDecoder()（调用）
        let recv = lang.children(dc[0])[0];
        if lang.kind(recv) != NodeKind::Call {
            return None;
        }
        let gc = lang.children(recv).to_vec();
        let NodeData::Member { name: gn } = lang.data(*gc.first()?) else {
            return None;
        };
        let url_safe = match lang.sn(*gn) {
            "getDecoder" => false,
            "getUrlDecoder" => true,
            _ => return None,
        };
        // owner = java.util.Base64（Member 链）或裸 Base64（VarRef）
        let owner = lang.children(gc[0])[0];
        let owner_ok = match lang.data(owner) {
            NodeData::Member { name } => lang.sn(*name) == "Base64",
            _ => matches!(lang.var_name(owner), Some(n) if n == "Base64" || n.ends_with(".Base64")),
        };
        if !owner_ok {
            return None;
        }
        let LitRef::Str(b64) = lang.literal(dc[1])? else {
            return None;
        };
        let bytes = base64_decode(b64, url_safe)?;
        let text = String::from_utf8(bytes).ok()?;
        let with = lang.build_str(&text);
        Some(Edit::Replace {
            target: id,
            with,
        })
    }
}

/// 手写 base64 解码（标准/URL 字母表，允许缺省填充）。
fn base64_decode(s: &str, url_safe: bool) -> Option<Vec<u8>> {
    let val = |c: char| -> Option<u32> {
        match c {
            'A'..='Z' => Some(c as u32 - 'A' as u32),
            'a'..='z' => Some(c as u32 - 'a' as u32 + 26),
            '0'..='9' => Some(c as u32 - '0' as u32 + 52),
            '+' if !url_safe => Some(62),
            '/' if !url_safe => Some(63),
            '-' if url_safe => Some(62),
            '_' if url_safe => Some(63),
            _ => None,
        }
    };
    let clean: String = s.chars().filter(|&c| c != '=' && !c.is_whitespace()).collect();
    if clean.len() % 4 == 1 {
        return None;
    }
    let mut out = Vec::new();
    let mut buf = 0u32;
    let mut bits = 0u32;
    for c in clean.chars() {
        buf = (buf << 6) | val(c)?;
        bits += 6;
        if bits >= 8 {
            bits -= 8;
            out.push((buf >> bits) as u8);
            buf &= (1 << bits) - 1;
        }
    }
    Some(out)
}


// ---------------------------------------------------------------------------
// 控制流扁平化还原（CFF recovery，obfuscator.io / Allatori 风格）：
//   int s = 0;
//   while (true) {
//       switch (s) {
//           case 0: { A(); s = 1; break; }
//           case 1: { if (c) { s = 2; } else { s = 3; } break; }
//           case 2: { B(); s = 5; break; }
//           case 3: { C(); s = 5; break; }
//       }
//       if (s == 5) break;      // 或 default: return
//   }
//   →  A(); if (c) { B(); } else { C(); }
//
// 状态图 → 结构化控制流：
//   线性链顺序拼接；菱形找公共后继 if/else{前缀}+续接（单次发射）；
//   分支回环到条件状态 → while(cond){体}；链内后向边 → while(true){后缀}。
//   其余形态（发散/外部跳转/嵌套异常）保守拒绝。
// 守卫：v 仅作状态变量、循环后不使用、全部 case 可达、每状态体恰发射一次。
// ---------------------------------------------------------------------------

pub struct CffRecover;

struct CffCase {
    body: Vec<JavaId>,
    tail: CffTail,
}

enum CffTail {
    Goto(i64),
    Cond { cond: JavaId, a: i64, b: i64 },
    Term(JavaId),
    Exit,
}

#[derive(Clone, Copy, PartialEq, Debug)]
enum Flow {
    Done,
    Stop,
    Cycle(usize),
    Cond(i64),
    External(i64),
}

struct CffCtx<'a> {
    lang: &'a mut JavaAst,
    cases: std::collections::HashMap<i64, CffCase>,
    /// default: return 的语句（goto 未知状态时发射）
    default_term: Option<Vec<JavaId>>,
    used_default: bool,
    /// 可达性记账（含试探性分支走查）
    reached: std::collections::HashSet<i64>,
    /// 已实际发射的状态（分支试探不得穿入）
    emitted: std::collections::HashSet<i64>,
}

impl Rule<JavaAst> for CffRecover {
    fn name(&self) -> &'static str {
        "cff_recover"
    }
    fn kinds(&self) -> &'static [NodeKind] {
        &[NodeKind::While]
    }
    fn check(&self, ctx: RewriteCtx<'_, JavaAst>, id: JavaId) -> Option<Edit<JavaAst>> {
        let parent = ctx.parent(id)?;
        let idx = ctx.index(id)?;
        let lang = ctx.lang;
        if lang.kind(id) != NodeKind::While {
            return None;
        }
        let wch = lang.children(id).to_vec();
        if !matches!(lang.literal(wch[0]), Some(LitRef::Bool(true))) {
            return None;
        }
        if lang.kind(wch[1]) != NodeKind::Block {
            return None;
        }
                let body_ch = lang.children(wch[1]).to_vec();
        let (switch, exit_if) = match body_ch.len() {
            1 => (body_ch[0], None),
            2 => (body_ch[0], Some(body_ch[1])),
            _ => return None,
        };
        if lang.kind(switch) != NodeKind::Switch {
            return None;
        }
        let sch = lang.children(switch).to_vec();
        if lang.kind(sch[0]) != NodeKind::VarRef || !lang.is_local_var(sch[0]) {
            return None;
        }
        let v = lang.var_name(sch[0])?.to_string();

        // 尾随出口：if (v == SENT) break;
        let sentinel = match exit_if {
            None => None,
            Some(ei) => {
                if lang.kind(ei) != NodeKind::If {
                    return None;
                }
                let ich = lang.children(ei).to_vec();
                if ich.len() != 2 || lang.bin_op(ich[0]) != Some(BinOp::Eq) {
                    return None;
                }
                let cch = lang.children(ich[0]).to_vec();
                let sent = if lang.kind(cch[0]) == NodeKind::VarRef
                    && lang.var_name(cch[0]) == Some(v.as_str())
                {
                    lang.literal(cch[1]).and_then(|x| x.as_int())
                } else if lang.kind(cch[1]) == NodeKind::VarRef
                    && lang.var_name(cch[1]) == Some(v.as_str())
                {
                    lang.literal(cch[0]).and_then(|x| x.as_int())
                } else {
                    return None;
                }?;
                let then_ok = match lang.kind(ich[1]) {
                    NodeKind::Break => matches!(lang.data(ich[1]), NodeData::Break { label: None }),
                    NodeKind::Block if lang.children(ich[1]).len() == 1 => {
                        matches!(lang.data(lang.children(ich[1])[0]), NodeData::Break { label: None })
                    }
                    _ => false,
                };
                if !then_ok {
                    return None;
                }
                Some(sent)
            }
        };

        // 解析 case 表
        let mut cases: std::collections::HashMap<i64, CffCase> = Default::default();
        let mut default_term: Option<Vec<JavaId>> = None;
        for &c in &sch[1..] {
            let NodeData::Case { labels, is_default, arrow } = lang.data(c) else {
                return None;
            };
            let (labels, is_default, arrow) = (*labels, *is_default, *arrow);
            let ch = lang.children(c).to_vec();
            let mut stmts: Vec<JavaId> = ch[labels as usize..].to_vec();
            // 经典形态：剥尾部 break（块外或块内）
            if !arrow
                && stmts
                    .last()
                    .is_some_and(|&n| matches!(lang.data(n), NodeData::Break { label: None }))
            {
                stmts.pop();
            }
            if stmts.len() == 1 && lang.kind(stmts[0]) == NodeKind::Block {
                let mut inner = lang.children(stmts[0]).to_vec();
                if !arrow
                    && inner
                        .last()
                        .is_some_and(|&n| matches!(lang.data(n), NodeData::Break { label: None }))
                {
                    inner.pop();
                }
                stmts = inner;
            }
            if is_default {
                if stmts.len() == 1 && lang.kind(stmts[0]) == NodeKind::Return {
                    default_term = Some(stmts);
                    continue;
                }
                return None;
            }
            // 状态标签：单一整数字面量
            if labels != 1 {
                return None;
            }
            let state = match lang.literal(ch[0]) {
                Some(LitRef::Int(v)) => v,
                _ => return None,
            };
            let tail = parse_cff_tail(lang, &v, &mut stmts)?;
            // 尾部剥离后，剩余体不得引用状态变量
            for &st in &stmts {
                if subtree_has_var(lang, st, &v) {
                    return None;
                }
            }
            cases.insert(state, CffCase { body: stmts, tail });
        }
        if cases.is_empty() {
            return None;
        }

        // 入口：向上扫描（最多 8 条）找设置 v = IntLit 的语句；
        // 中间语句不得有 v 事件（读写皆拒）
        if idx == 0 {
            return None;
        }
        let block_ch = lang.children(parent).to_vec();
        let mut init = None;
        let mut init_idx = idx;
        {
            let mut up = idx;
            for _ in 0..8 {
                if up == 0 {
                    break;
                }
                up -= 1;
                let st = block_ch[up];
                match scan_cff_event(lang, st, &v) {
                    Some(CffEvent::Read) => return None,
                    Some(CffEvent::Write) | Some(CffEvent::Decl) => {
                        init = parse_cff_init(lang, &v, st);
                        init_idx = up;
                        break;
                    }
                    None => continue,
                }
            }
        }
        let init = init?;

        // 循环后 v 不得被使用
        for &st in &block_ch[idx + 1..] {
            if subtree_has_var(lang, st, &v) {
                return None;
            }
        }

        // Goto(未知状态) → Exit（须有出口机制）
        let mut to_exit: Vec<i64> = Vec::new();
        for (k, ci) in cases.iter() {
            if let CffTail::Goto(g) = ci.tail {
                if !cases.contains_key(&g) {
                    if !(sentinel == Some(g) || default_term.is_some()) {
                        return None;
                    }
                    to_exit.push(*k);
                }
            }
        }
        for k in to_exit {
            if let Some(ci) = cases.get_mut(&k) {
                ci.tail = CffTail::Exit;
            }
        }

        let mut c = CffCtx {
            lang,
            cases,
            default_term,
            used_default: false,
            reached: Default::default(),
            emitted: Default::default(),
        };
        let stmts = cff_run(&mut c, init)?;

        // 不可达 case 是死代码（从入口不可达 → 永不执行），可安全丢弃；
        // default 未被走到同理。至少要求发射序列非空。
        if stmts.is_empty() {
            return None;
        }

        // 用恢复序列替换 while + 删除 init 语句（两处独立位置：init 与 while
        // 之间的无关语句保留；顺序先 Splice（较大索引）后 Delete）
        Some(Edit::Multi(vec![
            Edit::Splice {
                node: parent,
                index: idx,
                remove: 1,
                insert: stmts,
            },
            Edit::Delete {
                node: block_ch[init_idx],
            },
        ]))
    }
}

fn parse_cff_tail(lang: &JavaAst, v: &str, stmts: &mut Vec<JavaId>) -> Option<CffTail> {
    let last = *stmts.last()?;
    if lang.kind(last) == NodeKind::Return {
        stmts.pop();
        return Some(CffTail::Term(last));
    }
    let assign_of = |n: JavaId| -> Option<JavaId> {
        let inner = match lang.kind(n) {
            NodeKind::Assign => n,
            NodeKind::ExprStmt => {
                let ch = lang.children(n);
                if ch.len() == 1 && lang.kind(ch[0]) == NodeKind::Assign {
                    ch[0]
                } else {
                    return None;
                }
            }
            _ => return None,
        };
        if lang.assign_op(inner).is_some() {
            return None;
        }
        let ch = lang.children(inner).to_vec();
        if lang.kind(ch[0]) != NodeKind::VarRef || lang.var_name(ch[0]) != Some(v) {
            return None;
        }
        Some(inner)
    };
    if let Some(assign) = assign_of(last) {
        let value = lang.children(assign)[1];
        if let Some(k) = lang.literal(value).and_then(|x| x.as_int()) {
            stmts.pop();
            return Some(CffTail::Goto(k));
        }
        if lang.kind(value) == NodeKind::Ternary {
            let tch = lang.children(value).to_vec();
            let a = lang.literal(tch[1]).and_then(|x| x.as_int())?;
            let b = lang.literal(tch[2]).and_then(|x| x.as_int())?;
            stmts.pop();
            return Some(CffTail::Cond { cond: tch[0], a, b });
        }
        return None;
    }
    if lang.kind(last) == NodeKind::If {
        let ich = lang.children(last).to_vec();
        if ich.len() != 3 {
            return None;
        }
        let arm = |n: JavaId| -> Option<i64> {
            let target = match lang.kind(n) {
                NodeKind::Assign | NodeKind::ExprStmt => assign_of(n)?,
                NodeKind::Block if lang.children(n).len() == 1 => assign_of(lang.children(n)[0])?,
                _ => return None,
            };
            lang.literal(lang.children(target)[1]).and_then(|x| x.as_int())
        };
        let a = arm(ich[1])?;
        let b = arm(ich[2])?;
        stmts.pop();
        return Some(CffTail::Cond { cond: ich[0], a, b });
    }
    None
}


/// CFF 入口向上扫描的事件判定（必经路径语义）。
enum CffEvent {
    Read,
    Write,
    /// v 自身的声明（含 init 时为入口源）
    Decl,
}

fn scan_cff_event(lang: &JavaAst, node: JavaId, name: &str) -> Option<CffEvent> {
    match lang.kind(node) {
        NodeKind::VarRef => {
            if lang.var_name(node) == Some(name) {
                Some(CffEvent::Read)
            } else {
                None
            }
        }
        NodeKind::VarDecl => {
            if lang.var_name(node) == Some(name) {
                Some(CffEvent::Decl)
            } else {
                for &c in lang.children(node) {
                    if let Some(e) = scan_cff_event(lang, c, name) {
                        return Some(e);
                    }
                }
                None
            }
        }
        NodeKind::Assign => {
            let ch = lang.children(node);
            if let Some(&val) = ch.get(1) {
                if let Some(e) = scan_cff_event(lang, val, name) {
                    if matches!(e, CffEvent::Read) {
                        return Some(e);
                    }
                }
            }
            if lang.assign_op(node).is_none() {
                if let Some(&t) = ch.first() {
                    if lang.kind(t) == NodeKind::VarRef && lang.var_name(t) == Some(name) {
                        return Some(CffEvent::Write);
                    }
                }
            }
            None
        }
        NodeKind::If | NodeKind::While => scan_cff_event(lang, *lang.children(node).first()?, name),
        NodeKind::Ternary => scan_cff_event(lang, *lang.children(node).first()?, name),
        NodeKind::Binary => {
            let op = lang.bin_op(node)?;
            let ch = lang.children(node);
            if op.is_short_circuit() {
                scan_cff_event(lang, *ch.first()?, name)
            } else {
                for &c in ch {
                    if let Some(e) = scan_cff_event(lang, c, name) {
                        return Some(e);
                    }
                }
                None
            }
        }
        _ => {
            for &c in lang.children(node) {
                if let Some(e) = scan_cff_event(lang, c, name) {
                    return Some(e);
                }
            }
            None
        }
    }
}

fn parse_cff_init(lang: &JavaAst, v: &str, stmt: JavaId) -> Option<i64> {
    match lang.kind(stmt) {
        NodeKind::VarDecl => {
            let ch = lang.children(stmt).to_vec();
            if ch.len() != 1 || lang.var_name(stmt) != Some(v) {
                return None;
            }
            lang.literal(ch[0]).and_then(|x| x.as_int())
        }
        NodeKind::Assign => {
            if lang.assign_op(stmt).is_some() {
                return None;
            }
            let ch = lang.children(stmt).to_vec();
            if lang.kind(ch[0]) != NodeKind::VarRef || lang.var_name(ch[0]) != Some(v) {
                return None;
            }
            lang.literal(ch[1]).and_then(|x| x.as_int())
        }
        NodeKind::ExprStmt => {
            let ch = lang.children(stmt).to_vec();
            if ch.len() == 1 {
                parse_cff_init(lang, v, ch[0])
            } else {
                None
            }
        }
        _ => None,
    }
}

fn flatten(pairs: &[(i64, Vec<JavaId>)], out: &mut Vec<JavaId>, c: &mut CffCtx) {
    for (s, stmts) in pairs {
        c.emitted.insert(*s);
        out.extend(stmts.iter().copied());
    }
}

fn flatten_prefix(pairs: &[(i64, Vec<JavaId>)], m: i64, out: &mut Vec<JavaId>) {
    for (s, stmts) in pairs {
        if *s == m {
            break;
        }
        out.extend(stmts.iter().copied());
    }
}

fn suffix_pairs(pairs: &[(i64, Vec<JavaId>)], m: i64) -> Vec<(i64, Vec<JavaId>)> {
    let pos = pairs.iter().position(|(s, _)| *s == m).unwrap();
    pairs[pos..].to_vec()
}

/// 纯收集：沿无条件 goto 前进，不消费条件 case。
fn collect(c: &mut CffCtx, start: i64, stop: Option<i64>) -> Option<(Vec<(i64, Vec<JavaId>)>, Flow)> {
    let mut path: Vec<(i64, Vec<JavaId>)> = Vec::new();
    let mut cur = start;
    let mut guard = 0usize;
    loop {
        guard += 1;
        if guard > 10_000 {
            return None;
        }
        if Some(cur) == stop {
            return Some((path, Flow::Stop));
        }
        if let Some(i) = path.iter().position(|(s, _)| *s == cur) {
            return Some((path, Flow::Cycle(i)));
        }
        if c.emitted.contains(&cur) {
            return Some((path, Flow::External(cur)));
        }
        c.reached.insert(cur);
        let ci = c.cases.get(&cur)?;
        let mut body = ci.body.clone();
        match ci.tail {
            CffTail::Goto(k) => {
                path.push((cur, body));
                cur = k;
            }
            CffTail::Term(r) => {
                body.push(r);
                path.push((cur, body));
                return Some((path, Flow::Done));
            }
            CffTail::Exit => {
                if c.default_term.is_some() {
                    if let Some(dt) = c.default_term.clone() {
                        body.extend(dt);
                        c.used_default = true;
                    }
                }
                path.push((cur, body));
                return Some((path, Flow::Done));
            }
            CffTail::Cond { .. } => return Some((path, Flow::Cond(cur))),
        }
    }
}

/// 顶层：从入口状态结构化整个状态机。
fn cff_run(c: &mut CffCtx, init: i64) -> Option<Vec<JavaId>> {
    let (path, flow) = collect(c, init, None)?;
    cff_structure(c, path, flow)
}

/// 从某状态起递归结构化（混合终点分支的续接构造用）。
fn cff_run_from(c: &mut CffCtx, start: i64) -> Option<Vec<JavaId>> {
    let (path, flow) = collect(c, start, None)?;
    cff_structure(c, path, flow)
}

/// 核心结构化循环：携带当前链（path + flow），直到终止。
/// 混合终点（一支终止、另一支续接）时，续接必须放进继续分支**内部**
/// （续接代码只在走该分支时执行）。
fn cff_structure(c: &mut CffCtx, mut path: Vec<(i64, Vec<JavaId>)>, mut flow: Flow) -> Option<Vec<JavaId>> {
    let mut stmts: Vec<JavaId> = Vec::new();
    loop {
        match flow {
            Flow::Done => {
                flatten(&path, &mut stmts, c);
                return Some(stmts);
            }
            Flow::Cycle(i) => {
                flatten(&path[..i], &mut stmts, c);
                let mut suffix = Vec::new();
                flatten(&path[i..], &mut suffix, c);
                let inner = c.lang.build_block(suffix);
                let cond = c.lang.build_bool(true);
                let w = c.lang.while_(cond, inner);
                stmts.push(w);
                return Some(stmts);
            }
            Flow::Stop | Flow::External(_) => return None,
            Flow::Cond(state) => {
                flatten(&path, &mut stmts, c);
                path.clear();
                let ci = c.cases.get(&state)?;
                stmts.extend(ci.body.iter().copied());
                c.emitted.insert(state);
                let CffTail::Cond { cond, a, b } = ci.tail else {
                    return None;
                };
                // 循环形态：分支走回条件状态
                let (pa, fa) = collect(c, a, Some(state))?;
                if fa == Flow::Stop {
                    let mut lb = Vec::new();
                    flatten(&pa, &mut lb, c);
                    let inner = c.lang.build_block(lb);
                    let w = c.lang.while_(cond, inner);
                    stmts.push(w);
                    let (p2, f2) = collect(c, b, None)?;
                    path = p2;
                    flow = f2;
                    continue;
                }
                let (pb, fb) = collect(c, b, Some(state))?;
                if fb == Flow::Stop {
                    let mut lb = Vec::new();
                    flatten(&pb, &mut lb, c);
                    let inner = c.lang.build_block(lb);
                    let nc = c.lang.build_unary(UnOp::Not, cond);
                    let w = c.lang.while_(nc, inner);
                    stmts.push(w);
                    let (p2, f2) = collect(c, a, None)?;
                    path = p2;
                    flow = f2;
                    continue;
                }
                // 菱形：两支共享后继
                let common = pa
                    .iter()
                    .find(|(s, _)| pb.iter().any(|(t, _)| *s == *t))
                    .map(|(s, _)| *s);
                let same_end = match (fa, fb) {
                    (Flow::Done, Flow::Done) => true,
                    (Flow::Cond(x), Flow::Cond(y)) => x == y,
                    _ => false,
                };
                match common {
                    Some(m) if same_end => {
                        let mut pre_a = Vec::new();
                        let mut pre_b = Vec::new();
                        flatten_prefix(&pa, m, &mut pre_a);
                        flatten_prefix(&pb, m, &mut pre_b);
                        let ba = c.lang.build_block(pre_a);
                        let bb = c.lang.build_block(pre_b);
                        let ifs = c.lang.if_(cond, ba, Some(bb));
                        stmts.push(ifs);
                        path = suffix_pairs(&pa, m);
                        flow = fa;
                        continue;
                    }
                    Some(_) => return None,
                    None => {
                        // 无公共后继的分叉
                        let mut fa_stmts = Vec::new();
                        let mut fb_stmts = Vec::new();
                        flatten(&pa, &mut fa_stmts, c);
                        flatten(&pb, &mut fb_stmts, c);
                        match (fa, fb) {
                            (Flow::Done, Flow::Done) => {
                                let ba = c.lang.build_block(fa_stmts);
                                let bb = c.lang.build_block(fb_stmts);
                                let ifs = c.lang.if_(cond, ba, Some(bb));
                                stmts.push(ifs);
                                return Some(stmts);
                            }
                            // 两支都续接到同一条件 → if/else 后无条件续接（合流）
                            (Flow::Cond(x), Flow::Cond(y)) if x == y => {
                                let ba = c.lang.build_block(fa_stmts);
                                let bb = c.lang.build_block(fb_stmts);
                                let ifs = c.lang.if_(cond, ba, Some(bb));
                                stmts.push(ifs);
                                let (p2, f2) = collect(c, x, None)?;
                                path = p2;
                                flow = f2;
                                continue;
                            }
                            // 混合：一支终止、另一支续接 → 续接放进继续分支【内部】
                            (Flow::Done, Flow::Cond(x)) => {
                                let cont = cff_run_from(c, x)?;
                                fb_stmts.extend(cont);
                                let ba = c.lang.build_block(fa_stmts);
                                let bb = c.lang.build_block(fb_stmts);
                                let ifs = c.lang.if_(cond, ba, Some(bb));
                                stmts.push(ifs);
                                return Some(stmts);
                            }
                            (Flow::Cond(x), Flow::Done) => {
                                let cont = cff_run_from(c, x)?;
                                fa_stmts.extend(cont);
                                let ba = c.lang.build_block(fa_stmts);
                                let bb = c.lang.build_block(fb_stmts);
                                let ifs = c.lang.if_(cond, ba, Some(bb));
                                stmts.push(ifs);
                                return Some(stmts);
                            }
                            _ => return None,
                        }
                    }
                }
            }
        }
    }
}



// ---------------------------------------------------------------------------
// 跨方法常量知识（string-array 解密器的过程间分析入口）：
// simplify_unit 把类级常量字段与单 return 方法体填入 JavaAst 侧表，
// 下面两条规则在 fixed point 中消费，与部分求值/数组下标/Base64 折叠
// 自然组合：d(0) → 方法体 → T[0] → "c3Vw" → Base64 解码 → "sup"。
// ---------------------------------------------------------------------------

/// 收集类级常量：static final 字面量/数组字段（无写、无局部同名）
/// 与单 return 方法体。
pub fn collect_unit_consts(ast: &mut JavaAst, unit: &CompilationUnit) {
    ast.const_fields.clear();
    ast.const_scalars.clear();
    ast.inline_methods.clear();
    ast.field_types.clear();
    ast.final_fields.clear();
    // 已知泛型简单名（raw 接收位传播守卫用）：单元内带 ty_params 的
    // 类型 + 常见 JDK/库泛型
    ast.raw_generic_names = {
        let mut m: std::collections::HashSet<String> = [
            "List", "ArrayList", "LinkedList", "Collection", "Set", "HashSet",
            "TreeSet", "LinkedHashSet", "Map", "HashMap", "TreeMap", "LinkedHashMap",
            "Hashtable", "SortedMap", "SortedSet", "NavigableMap", "NavigableSet",
            "Iterable", "Iterator", "ListIterator", "Comparator", "Optional",
            "Stream", "Class", "Comparable", "Entry", "AbstractList", "AbstractMap",
            "WeakHashMap", "IdentityHashMap", "ConcurrentHashMap", "ConcurrentMap",
            "Queue", "Deque", "ArrayDeque", "Vector", "Stack", "Enumeration",
            "Callable", "Future", "Supplier", "Function", "BiFunction", "Consumer",
            "Predicate", "UnaryOperator", "BinaryOperator", "UnmodifiableList",
            // 第 13 轮 P0-3 补充（R12 攻击代理建议 + T3k 实锤）：
            "AbstractSet", "AbstractCollection", "AbstractQueue", "Spliterator",
            "EnumMap", "EnumSet", "PriorityQueue", "DelayQueue", "LinkedBlockingQueue",
            "LinkedTransferQueue", "ConcurrentLinkedQueue", "ConcurrentSkipListMap",
            "ConcurrentSkipListSet", "CopyOnWriteArrayList", "CopyOnWriteArraySet",
            "ArrayBlockingQueue", "SynchronousQueue", "ThreadLocal", "Reference",
            "SoftReference", "WeakReference", "AtomicReference", "AtomicStampedReference",
        ]
        .iter()
        .map(|x| x.to_string())
        .collect();
        fn collect_generics(ty: &TypeDecl, m: &mut std::collections::HashSet<String>) {
            if !ty.ty_params.trim().is_empty() {
                m.insert(ty.name.clone());
            }
            for mem in &ty.members {
                if let Member::Type(t) = mem {
                    collect_generics(t, m);
                }
            }
        }
        for ty in &unit.types {
            collect_generics(ty, &mut m);
        }
        m
    };
    ast.unit_shadows_lang = {
        fn decl_shadows(ty: &TypeDecl) -> bool {
            if ty.name == "String" || ty.name == "StringBuilder" {
                return true;
            }
            ty.members.iter().any(|m| match m {
                Member::Type(t) => decl_shadows(t),
                _ => false,
            })
        }
        unit.types.iter().any(decl_shadows)
    };

    // 第一遍（递归含嵌套类型——规则也处理嵌套类体内的 VarRef）：
    // 遮蔽集（局部/参数同名声明）+ 全单元名字写计数 + 字段声明名计数。
    // 写计数取代旧「写即除名」污染集：clinit 单写字面量路径需要知道
    // 「写过几次」而不只是「写过没有」。
    let mut shadowed: std::collections::HashSet<String> = Default::default();
    let mut write_counts: std::collections::HashMap<String, u32> = Default::default();
    let mut field_decls: std::collections::HashMap<String, u32> = Default::default();
    let mut bodies: Vec<JavaId> = Vec::new();
    for ty in &unit.types {
        collect_bodies_recursive(ty, &mut bodies, &mut shadowed, &mut field_decls);
    }
    // 字段类型表 + final 集合（调用点实参类型解析 / 截断守卫 finality 用；
    // 同名二见移除——保守）
    for ty in &unit.types {
        collect_field_types(ty, &mut ast.field_types, &mut ast.final_fields);
    }
    // 写扫描：赋值目标子树全部名字（含数组元素写——改内容同样破坏
    // 常量性）、++/-- 目标、Member 目标的成员名（this.a=x / A.a=x——
    // this.a 可写静态字段，裸名计数看不见）。
    for &root in &bodies {
        let mut stack = vec![root];
        while let Some(n) = stack.pop() {
            if ast.kind(n) == NodeKind::VarDecl {
                if let Some(nm) = ast.var_name(n) {
                    shadowed.insert(nm.to_string());
                }
            }
            match ast.data(n) {
                NodeData::Assign { .. } => {
                    let t = ast.children(n)[0];
                    if ast.kind(t) == NodeKind::Member {
                        if let NodeData::Member { name: sym } = ast.data(t) {
                            *write_counts.entry(ast.sn(*sym).to_string()).or_insert(0) += 1;
                        }
                    }
                    let mut ts = vec![t];
                    while let Some(x) = ts.pop() {
                        if ast.kind(x) == NodeKind::VarRef {
                            if let Some(nm) = ast.var_name(x) {
                                *write_counts.entry(nm.to_string()).or_insert(0) += 1;
                            }
                        }
                        for &c in ast.children(x) {
                            ts.push(c);
                        }
                    }
                }
                NodeData::Unary { op } if op.is_incdec() => {
                    let t = ast.children(n)[0];
                    if ast.kind(t) == NodeKind::VarRef {
                        if let Some(nm) = ast.var_name(t) {
                            *write_counts.entry(nm.to_string()).or_insert(0) += 1;
                        }
                    }
                }
                _ => {}
            }
            for &c in ast.children(n) {
                stack.push(c);
            }
        }
    }

    // 第二遍：常量字段收集（声明初始化路径 + clinit 单写路径）
    for ty in &unit.types {
        // 本类型自己的 clinit 顶层字面量赋值（静态初始化块材料化形态）
        let mut own_lits: std::collections::HashMap<String, JavaId> = Default::default();
        collect_own_clinit_lits(ast, ty, &mut own_lits);
        for m in &ty.members {
            if let Member::Field { mods, ty: fty, declarators } = m {
                let words: Vec<&str> = mods.split_whitespace().collect();
                let is_static = words.contains(&"static");
                let is_final = words.contains(&"final");
                let is_private = words.contains(&"private");
                for d in declarators {
                    // 名字唯一性：全单元（含嵌套）恰一个同名字段声明。
                    // 嵌套类同名字段遮蔽外层（或外层遮蔽嵌套）——名字
                    // 全局的传播无法区分裸名解析指向哪个 → 双见即放弃。
                    if field_decls.get(&d.name).copied().unwrap_or(0) != 1 {
                        continue;
                    }
                    let init = match d.init {
                        Some(init) => {
                            // 声明初始化路径：final + 字面量 + 无写 + 无遮蔽
                            if !is_final
                                || !is_const_init(ast, init)
                                || shadowed.contains(&d.name)
                                || write_counts.get(&d.name).copied().unwrap_or(0) != 0
                            {
                                continue;
                            }
                            init
                        }
                        None => {
                            // clinit 单写路径：static final，或 static private
                            //（非 final 必须 private——限定名跨类写 A.a=v 的
                            // 目标是 Member 节点，名字计数对私有字段才无漏洞；
                            // bd.java：static_exec 坍缩 106 段解密循环成
                            // i = new String[]{…} / a = "SHA-512" 后经此路径
                            // 成为常量）
                            if !is_static
                                || (!is_final && !is_private)
                                || shadowed.contains(&d.name)
                                || write_counts.get(&d.name).copied().unwrap_or(0) != 1
                            {
                                continue;
                            }
                            match own_lits.get(&d.name) {
                                Some(&init) if is_const_init(ast, init) => init,
                                _ => continue,
                            }
                        }
                    };
                    // 同名二见 → 除名（跨类型保守去重，旧语义保持）
                    if ast.const_fields.contains_key(&d.name) {
                        ast.const_fields.remove(&d.name);
                        ast.const_scalars.remove(&d.name);
                    } else {
                        let scalar_ok = scalar_lit_of(ast, init)
                            .is_some_and(|l| lit_type_matches_decl(fty, l));
                        ast.const_fields.insert(d.name.clone(), init);
                        if scalar_ok {
                            ast.const_scalars.insert(d.name.clone());
                        }
                    }
                }
            }
        }
    }

    // 单元级 String 身份比较标志（new String(lit) 解包守卫——字段 init
    // 的观察点在其他方法，单根扫描看不见）
    // 同一性断言方法名（assertNotSame/assertSame/isSameInstanceAs/
    // isNotSameInstanceAs——guava/mockito 测试框架的实例同一性断言：
    // new String("a") 折叠会翻转断言结果——ConcurrentHashMultisetTest
    // testIdentityKeyEquality 抓获）→ new String 折叠拒绝
    {
        let identity_assert = [
            "assertSame",
            "assertNotSame",
            "isSameInstanceAs",
            "isNotSameInstanceAs",
            "referenceEquals",
            "same",
        ];
        let mut hit = false;
        for root in &bodies {
            let mut stack = vec![*root];
            while let Some(n) = stack.pop() {
                if let NodeData::Call = ast.data(n) {
                    if let Some(&callee) = ast.children(n).first() {
                        let nm = match ast.data(callee) {
                            NodeData::Member { name } => ast.sn(*name),
                            NodeData::VarRef { name } => ast.sn(*name),
                            _ => "",
                        };
                        if identity_assert.contains(&nm) {
                            hit = true;
                            break;
                        }
                    }
                }
                for &c in ast.children(n) {
                    stack.push(c);
                }
            }
            if hit {
                break;
            }
        }
        ast.unit_string_identity =
            ast.any_string_identity(&bodies) || hit;
    }

    // 单 return 方法收集（仅**不可覆写**方法：private/static/final——
    // UIAction.accept 抓获：protected 单 return 方法被子类覆写，
    // this.m(实参) 被内联成常量 → 虚分派破坏，XEmbeddedFrame 的
    // traverseOut @Override 整段副作用丢失）
    // **同名方法全单元计数**：重载存在（含被下方守卫拒绝的 varargs/匿名
    // 体形态——它们不落 insert 分支故旧 contains_key/remove 对撞失效）时
    // 名字整体否决——调用点无法静态分辨目标重载（javapoet TypeSpec 抓获：
    // anonymousClassBuilder("") 曾被绑定进 anonymousClassBuilder(CodeBlock)
    // 单 return 体 → javac 不兼容类型）
    let mut method_name_count: std::collections::HashMap<String, usize> =
        std::collections::HashMap::new();
    for_each_type(unit, &mut |ty: &TypeDecl| {
        for m in &ty.members {
            if let Member::Method { name, .. } = m {
                *method_name_count.entry(name.clone()).or_insert(0) += 1;
            }
        }
    });
    for ty in &unit.types {
        for m in &ty.members {
            if let Member::Method { mods, name, params, body: Some(b), .. } = m {
                let words: Vec<&str> = mods.split_whitespace().collect();
                let non_overridable = words.contains(&"private")
                    || words.contains(&"static")
                    || words.contains(&"final");
                if !non_overridable {
                    continue;
                }
                let ch = ast.children(*b).to_vec();
                if ch.len() == 1 && ast.kind(ch[0]) == NodeKind::Return {
                    if let Some(&expr) = ast.children(ch[0]).first() {
                        if params.len() <= 3
                            // 匿名类体：参数替换盲区（体内 return rms 的
                            // rms 是参数——内联后自由引用悬空——
                            // EvaluationRmsCheckerTest 抓获：16 文件输出
                            // 不可编译）→ 拒绝
                            && !subtree_has_anon(ast, expr)
                            // varargs 形参：单实参直通 `array(arg)` 的
                            // 内联丢 `new T[]{arg}` 包装——junit5 131 处
                            // 断言恒败 → 拒绝
                            && !params.iter().any(|p| p.varargs)
                            && !subtree_calls_self(ast, expr, name)
                            // 类型敏感守卫：字面量替换会改变形参位置的静态类型
                            // （switch 模式选择器 / instanceof 被测式 / Raw 不
                            // 可见构造）——`match(42)` 内联成 switch(42) 遭
                            // javac 拒绝（Adv6 差分抓获）。混淆 helper（纯算
                            // 术/字符串体）不受影响。
                            && !subtree_has_type_sensitive(ast, expr)
                        && method_name_count.get(name).copied() == Some(1)
                        {
                            let ps: Vec<String> = params.iter().map(|p| p.name.clone()).collect();
                            let owner = ty.name.rsplit('.').next().unwrap_or(&ty.name).to_string();
                            ast.inline_methods.insert(name.clone(), (ps, expr, owner));
                        }
                    }
                }
            }
        }
    }
}

/// 常量初始化判定：字面量，或字面量数组（new T[]{…} / {…}）。
fn is_const_init(ast: &JavaAst, init: JavaId) -> bool {
    match ast.kind(init) {
        NodeKind::Literal => true,
        NodeKind::ArrayLit => ast.children(init).iter().all(|&e| ast.kind(e) == NodeKind::Literal),
        NodeKind::NewArray => {
            let ch = ast.children(init).to_vec();
            ch.len() == 1
                && ast.kind(ch[0]) == NodeKind::ArrayLit
                && ast.children(ch[0]).iter().all(|&e| ast.kind(e) == NodeKind::Literal)
        }
        _ => false,
    }
}

/// 递归收集类型体内（含嵌套类型）：方法/构造器体、初始化块、字段初始化
/// 表达式 → bodies；参数与局部声明名 → shadowed；字段声明名计数 →
/// field_decls。
fn collect_bodies_recursive(
    ty: &TypeDecl,
    bodies: &mut Vec<JavaId>,
    shadowed: &mut std::collections::HashSet<String>,
    field_decls: &mut std::collections::HashMap<String, u32>,
) {
    // 枚举常量是隐式 public static final 字段，参与名字遮蔽/唯一性
    // 计数：嵌套枚举的常量与外层同名字段撞名时（ddc weixin mapsdk hm
    // 复现：外层 `static final String b17 = "hm"` vs 枚举常量 b17），
    // 不计数会让外层字段被误判全单元唯一 → 收集进常量表 → 嵌套枚举
    // clinit 里裸名 b17（解析到枚举常量）被替换成 "hm"，产出
    // `new hm.b[] {a, "hm"}` 不可编译。计数后双见 → 外层字段按既有
    // 保守语义全弃。常量原文可带注解/实参/类体——取名字标识符。
    if ty.kind == TypeKind::Enum {
        for c in &ty.enum_constants {
            if c.trim() == "," {
                continue;
            }
            let last = c.split('(').next().unwrap_or(c)
                .split_whitespace()
                .next_back()
                .unwrap_or("");
            let name: String = last
                .chars()
                .take_while(|ch| ch.is_alphanumeric() || *ch == '_' || *ch == '$')
                .collect();
            if !name.is_empty() {
                *field_decls.entry(name).or_insert(0) += 1;
            }
        }
    }
    for m in &ty.members {
        match m {
            Member::Method { body: Some(b), params, .. }
            | Member::Constructor { body: Some(b), params, .. } => {
                bodies.push(*b);
                for p in params {
                    shadowed.insert(p.name.clone());
                }
            }
            Member::Initializer { body, .. } => bodies.push(*body),
            Member::Field { declarators, .. } => {
                for d in declarators {
                    *field_decls.entry(d.name.clone()).or_insert(0) += 1;
                    if let Some(init) = d.init {
                        bodies.push(init);
                    }
                }
            }
            Member::Type(t) => {
                collect_bodies_recursive(t, bodies, shadowed, field_decls);
            }
            _ => {}
        }
    }
}

/// 递归收集字段声明类型（名字 → JType）与 final 集合（同名二见移除）。
fn collect_field_types(
    ty: &TypeDecl,
    out: &mut std::collections::HashMap<String, JType>,
    finals: &mut std::collections::HashSet<String>,
) {
    for m in &ty.members {
        match m {
            Member::Field { mods, ty: fty, declarators } => {
                let is_final = mods.split_whitespace().any(|w| w == "final");
                for d in declarators {
                    if out.contains_key(&d.name) {
                        out.remove(&d.name);
                        finals.remove(&d.name);
                    } else {
                        out.insert(d.name.clone(), fty.clone());
                        if is_final {
                            finals.insert(d.name.clone());
                        }
                    }
                }
            }
            Member::Type(t) => collect_field_types(t, out, finals),
            _ => {}
        }
    }
}

/// 本类型静态初始化块顶层 `name = <常量>` 赋值收集（static_exec 材料
/// 化后的形态）。只看本类型自己的 clinit：嵌套类初始化块里的裸名赋值
/// 指向嵌套自己的静态字段（或外层字段——由写计数+唯一性守卫兜底），
/// 不能归因到外层声明。
fn collect_own_clinit_lits(
    ast: &JavaAst,
    ty: &TypeDecl,
    out: &mut std::collections::HashMap<String, JavaId>,
) {
    for m in &ty.members {
        if let Member::Initializer { is_static: true, body } = m {
            if ast.kind(*body) != NodeKind::Block {
                continue;
            }
            for &st in ast.children(*body) {
                let asg = match ast.kind(st) {
                    NodeKind::ExprStmt => {
                        // 防御：规则间中树删除可能留下空 ExprStmt 壳
                        //（self_assign 曾删 Assign 节点而非语句——weixin
                        // gp0.d1 复现）；空壳无赋值可收集，跳过
                        let Some(&c) = ast.children(st).first() else {
                            continue;
                        };
                        if ast.kind(c) == NodeKind::Assign {
                            c
                        } else {
                            continue;
                        }
                    }
                    NodeKind::Assign => st,
                    _ => continue,
                };
                let ch = ast.children(asg).to_vec();
                if ast.kind(ch[0]) != NodeKind::VarRef {
                    continue;
                }
                let Some(nm) = ast.var_name(ch[0]) else { continue };
                if is_const_init(ast, ch[1]) {
                    out.insert(nm.to_string(), ch[1]);
                }
            }
        }
    }
}

/// 标量字面量提取（数组/复合形式 → None：只走下标折叠，不整表复制）。
fn scalar_lit_of(ast: &JavaAst, init: JavaId) -> Option<cure_engine::kind::LitRef<'_>> {
    if ast.kind(init) == NodeKind::Literal {
        ast.literal(init)
    } else {
        None
    }
}

/// 字面量种类与字段声明类型**精确匹配**：VarRef 的静态类型是声明类型，
/// 字面量的类型是字面量种类——过载解析对此敏感（`final long L = 5` 的
/// 5 是 int 字面量：m(L) 绑定 m(long)，m(5) 绑定 m(int)）。不匹配 →
/// 拒绝传播（收集期一次性守卫，bd.java 的 String a/j/f 均精确匹配）。
fn lit_type_matches_decl(fty: &JType, lit: cure_engine::kind::LitRef) -> bool {
    use cure_engine::kind::LitRef;
    match (fty, lit) {
        (JType::Ref(r), LitRef::Str(_)) => {
            let base = r.split('<').next().unwrap_or(r).trim();
            base == "String" || base == "java.lang.String"
        }
        (JType::Char, LitRef::Char(_)) => true,
        (JType::Bool, LitRef::Bool(_)) => true,
        (JType::Int, LitRef::Int(_)) => true,
        (JType::Long, LitRef::Long(_)) => true,
        (JType::Float, LitRef::Float(_)) => true,
        (JType::Double, LitRef::Double(_)) => true,
        _ => false,
    }
}

/// 子树含类型敏感构造（switch / instanceof / Raw）：字面量替换形参
/// 会改变这些位置的静态类型 → 编译器拒绝（`match(42)` → `switch(42)`
/// 遭 javac 否决，Adv6 差分抓获）。这类方法不进内联候选。
fn subtree_has_type_sensitive(ast: &JavaAst, root: JavaId) -> bool {
    let mut stack = vec![root];
    while let Some(n) = stack.pop() {
        match ast.kind(n) {
            NodeKind::Switch | NodeKind::InstanceOf | NodeKind::Raw => return true,
            _ => {}
        }
        for &c in ast.children(n) {
            stack.push(c);
        }
    }
    false
}

fn subtree_has_anon(ast: &JavaAst, root: JavaId) -> bool {
    let mut stack = vec![root];
    while let Some(n) = stack.pop() {
        if let NodeData::New { anon_raw: Some(_), .. } = ast.data(n) {
            return true;
        }
        for &c in ast.children(n) {
            stack.push(c);
        }
    }
    false
}

fn subtree_calls_self(ast: &JavaAst, root: JavaId, name: &str) -> bool {
    let mut stack = vec![root];
    while let Some(n) = stack.pop() {
        if ast.kind(n) == NodeKind::Call {
            let callee = ast.children(n)[0];
            if ast.var_name(callee) == Some(name) {
                return true;
            }
            // 成员调用名也算（Boolean.getBoolean——jdk-sources TCPEndpoint
            // 抓获：库方法与本地方法恰好同名时，匹配器按
            // "大写接收方.方法名" 也会命中 → 自我乒乓无限克隆 → 爆栈；
            // 保守拒绝（误拒仅损失一次内联机会）
            if let NodeData::Member { name: m } = ast.data(callee) {
                if ast.sn(*m) == name {
                    return true;
                }
            }
        }
        for &c in ast.children(n) {
            stack.push(c);
        }
    }
    false
}

// ---------------------------------------------------------------------------
// 常量字段下标折叠：T[i]（T 为字面量数组常量字段）→ 元素字面量
// ---------------------------------------------------------------------------

pub struct StaticArrayIndexFold;

impl Rule<JavaAst> for StaticArrayIndexFold {
    fn name(&self) -> &'static str {
        "static_array_index_fold"
    }
    fn kinds(&self) -> &'static [NodeKind] {
        &[NodeKind::Index]
    }
    fn check(&self, ctx: RewriteCtx<'_, JavaAst>, id: JavaId) -> Option<Edit<JavaAst>> {
        let lang = ctx.lang;
        if lang.kind(id) != NodeKind::Index {
            return None;
        }
        let ch = lang.children(id).to_vec();
        if lang.kind(ch[0]) != NodeKind::VarRef {
            return None;
        }
        let name = lang.var_name(ch[0])?.to_string();
        let idx = lang.literal(ch[1]).and_then(|x| x.as_int())?;
        let init = *lang.const_fields.get(&name)?;
        let arr = match lang.kind(init) {
            NodeKind::ArrayLit => init,
            NodeKind::NewArray => {
                let ic = lang.children(init).to_vec();
                if ic.len() == 1 && lang.kind(ic[0]) == NodeKind::ArrayLit {
                    ic[0]
                } else {
                    return None;
                }
            }
            _ => return None,
        };
        let elems = lang.children(arr).to_vec();
        if idx < 0 || idx >= elems.len() as i64 {
            return None;
        }
        let elem = lang.copy_subtree(elems[idx as usize]);
        Some(Edit::Replace {
            target: id,
            with: elem,
        })
    }
}

// ---------------------------------------------------------------------------
// 常量字段标量传播：static final 字面量字段的 VarRef 读点 → 字面量。
// 跨方法/跨语句常量传播（bd.java：a="SHA-512" → getInstance(a) 处内联）。
// 守卫：
//   - assign 目标（含复合/++/--）跳过：clinit 的原赋值 lhs 不能替换；
//   - Call 的 callee 跳过：字段与方法是不同命名空间（bd.java 的字段 a
//     与静态方法 a 共存，a(c, b) 是调用不是字段读）；
//   - const_scalars 只收声明类型与字面量种类精确匹配的标量（收集期
//     已守卫过载解析；数组常量只走下标折叠）。
// 语义：intern() 常量（bd 的 a/j 即 new String(...).intern() 材料）
// 与同类字面量共享常量池实例 → == 身份比较亦保持。
// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------
// 空私有方法 no-op 调用删除：`e(c, b);` —— e 是空体 private 方法（收集
// 期元数隔离已守卫过载与 varargs）→ 调用唯一可观察效果是实参求值。
/// 实参效应 ≤ MayRead（VarRef/字面量/纯算术——字段读不抛不写；数组读
// （MayThrow）/调用（Unknown）/赋值（MayWrite）一律保留）。
// opt-in 生效：表由 simplify_unit 在 --dead-code 下填充。
// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------
// 常量字段标量传播：static final 字面量字段的 VarRef 读点 → 字面量。
// 跨方法/跨语句常量传播（bd.java：a="SHA-512" → getInstance(a) 处内联）。
// 守卫：
//   - assign 目标（含复合/++/--）跳过：clinit 的原赋值 lhs 不能替换；
//   - Call 的 callee 跳过：字段与方法是不同命名空间（bd.java 的字段 a
//     与静态方法 a 共存，a(c, b) 是调用不是字段读）；
//   - const_scalars 只收声明类型与字面量种类精确匹配的标量（收集期
//     已守卫过载解析；数组常量只走下标折叠）。
// 语义：intern() 常量（bd 的 a/j 即 new String(...).intern() 材料）
// 与同类字面量共享常量池实例 → == 身份比较亦保持。
// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------
// 尾随赋值即返回/抛出（P2 简化空间挖掘）：`v = expr; return v;` →
// `return expr;`（throw 变体同）。v 为局部（字段回写惯用形排除）；
// 相邻约束（赋值与 return 之间无语句）+ return 之后语句零 v 引用
//（死代码里的引用会因赋值消失而失定赋值）。RHS 自引用惯用形
// （result = result + x; return result;）安全：折叠读旧值。
// 相邻性同时排除捕获场景：合法 Java 中 lambda 捕获要求 effectively
// final——本赋值之后的捕获点要么违反相邻约束要么在死代码里。
// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------
// 循环体末尾的 `if (c) { continue; }` 是 no-op（continue 跳回循环步进/
// 条件——与体末尾落空同一位置）。仅当 if 是体的**最后一条**语句且无
// else（ba.java 形态：反编译 if 链的尾残留）。continue 无副作用，
// 删除整条 if 与落空等价。
// ---------------------------------------------------------------------------


// ---------------------------------------------------------------------------
// 构造器委托提升：R8/d8 的 Kotlin 默认参数桥（与 Java 缺省参桥接）在
// ddc 的 IR 值钻石折叠下把 `v = (p3 & 1) == 0 ? p1 : 0L; …; this(v…)`
// 直接折成 `this((p3 & 1) == 0 ? p1 : 0L, …)` 到达首位。源码层走完
// if_assign_ternary 后值已折成三元，但委托语句仍在纯赋值之后——
// 「对 this/super 的调用必须是构造器中的第一个语句」。
// 形状：根块 [纯前置…, this(args)/super(args), rest…] →
// [this(内联实参…), 前置…, rest…]。
// 前置全部 Effect::Pure（提升后重求值恒等；不纯的任何前置都让整条
// 放弃——副作用语句既不能删、也不能跨 this() 换序）。实参是 VarRef 且
// 前置恰有其（最后一次）赋值 → 该表达式内联进参数位；前置语句保留在
// 委托之后（rest 里的读取仍解析到同名声明，纯值晚求值恒等）。
// 嵌套块里的委托（R8 merged-ctor 每分支异参）是 Java 不可表 floor：
// 仅根块（方法/构造器体直级）触发。
// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------
// 纯调用语句删除：结果被丢弃的 `Long.compare(a, b);` /
// `Integer.compare(...)` / `Float.compare` / `Double.compare` /
// `Short/Byte/Character.compare` / `Objects.toString(x);`。来源：ddc 把
// dex 的 cmp-long/cmpg-float 指令渲染成 X.compare 语句 + 独立的原始比
// 较分支（结果用后者），前者是永不被读的纯函数调用；R8 删日志后遗留的
// Objects.toString 同族。全语料实测：三 APK 合计 ~6.3 万处。
// 守卫：语句位（结果弃置是构造性的）；X.compare 全重载收**基本类型**
// 形参（无装箱 NPE 语义）；Objects.toString(null) 返回 "null" 无副作用。
// ---------------------------------------------------------------------------

pub struct DeadPureCall;

impl Rule<JavaAst> for DeadPureCall {
    fn name(&self) -> &'static str {
        "dead_pure_call"
    }
    fn kinds(&self) -> &'static [NodeKind] {
        &[NodeKind::ExprStmt]
    }
    fn structural(&self) -> bool {
        true
    }
    fn check(&self, ctx: RewriteCtx<'_, JavaAst>, id: JavaId) -> Option<Edit<JavaAst>> {
        let lang = ctx.lang;
        if lang.kind(id) != NodeKind::ExprStmt {
            return None;
        }
        let Some(&call) = lang.children(id).first() else { return None };
        if lang.kind(call) != NodeKind::Call {
            return None;
        }
        let cch = lang.children(call).to_vec();
        let Some(&callee) = cch.first() else { return None };
        // 静态限定调用：Receiver 是简单类名（java.lang 箱类型/Objects——
        // 不经 this/实例接收者）
        let (recv, name) = match lang.data(callee) {
            NodeData::Member { name } => {
                let Some(&recv_expr) = lang.children(callee).first() else { return None };
                // 接收者取末段名：裸类名（VarRef Long）或限定链末段
                //（java.util.Objects 的 Member 末端）
                let recv_name = match lang.data(recv_expr) {
                    NodeData::VarRef { name } => lang.sn(*name).to_string(),
                    NodeData::Member { name } => lang.sn(*name).to_string(),
                    _ => return None,
                };
                if !recv_name
                    .chars()
                    .next()
                    .is_some_and(|c| c.is_uppercase())
                {
                    return None;
                }
                (recv_name, lang.sn(*name))
            }
            _ => return None,
        };
        let args = &cch[1..];
        let pure = match (recv.as_str(), name) {
            ("Long" | "Integer" | "Float" | "Double" | "Short" | "Byte" | "Character", "compare") => {
                // 基本类型重载：全部实参须为 int/long/float/double/char
                // 字面量或解析到基本类型局部（装箱实参走 valueOf 重载——
                // 拆箱可 NPE，保守放过）
                args.iter().all(|&a| match lang.data(a) {
                    NodeData::Literal(
                        Lit::Int(_) | Lit::Long(_) | Lit::Float(_) | Lit::Double(_),
                    ) => true,
                    // 数值字面量保留原文（0L / 0x1F）：NumVal 恒为数值
                    NodeData::Literal(Lit::NumRaw { .. }) => true,
                    NodeData::VarRef { .. } => {
                        let t = lang.var_type(a);
                        matches!(
                            t,
                            Some(JType::Int | JType::Long | JType::Float | JType::Double | JType::Char
                                | JType::Short | JType::Byte)
                        )
                    }
                    _ => false,
                })
            }
            ("Objects", "toString") => args.len() == 1,
            _ => false,
        };
        if !pure {
            return None;
        }
        Some(Edit::Delete { node: id })
    }
}

pub struct CtorDelegationHoist;

/// 递归实参解析：`v6 = v5 + 1; v5 = p1; this(v5, v6)` 的实参位要变成
/// `(p1, p1 + 1)`——被内联表达式里的**前置局部名**继续替换为其赋值表
/// 达式（只在这张表内递归；叶子恒为参数/表外名字，求值点保持 this()
/// 之前，顺序安全）。访问集防环。
fn hoist_resolve_arg(
    lang: &mut JavaAst,
    assign: &std::collections::HashMap<String, JavaId>,
    a: JavaId,
    visiting: &mut std::collections::HashSet<String>,
) -> Option<JavaId> {
    let name = match lang.data(a) {
        NodeData::VarRef { name } => lang.sn(*name).to_string(),
        _ => return Some(a), // 非变量实参原样
    };
    // 不在前置赋值表里的实参（参数/后置局部）保持原样——它不是失败
    let Some(&expr) = assign.get(&name) else {
        return Some(a);
    };
    if !visiting.insert(name.clone()) {
        return None; // 环（v = w; w = v）
    }
    let r = hoist_subst(lang, assign, expr, visiting);
    visiting.remove(&name);
    r
}

/// 拷贝 expr 并把其中出现在 assign 表里的 VarRef 递归替换。
fn hoist_subst(
    lang: &mut JavaAst,
    assign: &std::collections::HashMap<String, JavaId>,
    e: JavaId,
    visiting: &mut std::collections::HashSet<String>,
) -> Option<JavaId> {
    match lang.data(e) {
        NodeData::VarRef { name } => {
            let n = lang.sn(*name).to_string();
            if let Some(&src) = assign.get(&n) {
                if !visiting.insert(n.clone()) {
                    return None;
                }
                let r = hoist_subst(lang, assign, src, visiting);
                visiting.remove(&n);
                r
            } else {
                Some(e)
            }
        }
        _ => {
            let ch = lang.children(e).to_vec();
            let mut new_ch = Vec::with_capacity(ch.len());
            for c in ch {
                new_ch.push(hoist_subst(lang, assign, c, visiting)?);
            }
            Some(lang.clone_node(e, new_ch))
        }
    }
}

impl Rule<JavaAst> for CtorDelegationHoist {
    fn name(&self) -> &'static str {
        "ctor_delegation_hoist"
    }
    fn kinds(&self) -> &'static [NodeKind] {
        &[NodeKind::Block]
    }
    fn structural(&self) -> bool {
        true
    }
    fn check(&self, ctx: RewriteCtx<'_, JavaAst>, id: JavaId) -> Option<Edit<JavaAst>> {
        // 仅根块：嵌套块内的 this()/super()（每分支异参的合并构造器）
        // 无法靠提升产出合法 Java
        if ctx.parent(id).is_some() {
            return None;
        }
        let lang = ctx.lang;
        if lang.kind(id) != NodeKind::Block {
            return None;
        }
        let stmts = lang.children(id).to_vec();
        // 定位根级委托：ExprStmt{Call{This/Super callee}}
        let mut ctor_idx: Option<usize> = None;
        for (i, &st) in stmts.iter().enumerate() {
            if *lang.data(st) != NodeData::ExprStmt {
                continue;
            }
            let Some(&inner) = lang.children(st).first() else { continue };
            if lang.kind(inner) != NodeKind::Call {
                continue;
            }
            let Some(&callee) = lang.children(inner).first() else { continue };
            if matches!(lang.data(callee), NodeData::This | NodeData::Super) {
                ctor_idx = Some(i);
                break;
            }
        }
        let ci = ctor_idx?;
        if ci == 0 {
            return None; // 已在首位
        }
        // 前置：全为 纯白名单赋值 / 带白名单 init 的声明 / 裸声明；
        // 收集 名 → 最后赋值表达式
        let mut last_assign: std::collections::HashMap<String, JavaId> =
            std::collections::HashMap::new();
        for &st in &stmts[..ci] {
            let (name, value) = match lang.data(st) {
                NodeData::VarDecl { name, .. } => {
                    let init = lang.children(st).first().copied();
                    match init {
                        Some(e) => (name.clone(), e),
                        None => continue, // 裸声明：无效果，随前置后移
                    }
                }
                NodeData::ExprStmt => {
                    let Some(&a) = lang.children(st).first() else {
                        return None;
                    };
                    // 复合赋值有读语义 → 保守放弃（显式 trait 限定：具名类型
                    // 下 &mut 构建器 assign_op(op,t,v) 会遮蔽查询方法）
                    if lang.kind(a) != NodeKind::Assign
                        || <JavaAst as Lang>::assign_op(&*lang, a).is_some()
                    {
                        return None;
                    }
                    let ch = lang.children(a).to_vec();
                    let (t, v) = (*ch.first()?, *ch.get(1)?);
                    if lang.kind(t) != NodeKind::VarRef || !lang.is_local_var(t) {
                        return None; // 非局部目标（字段写等）→ 放弃
                    }
                    let vn = lang.var_name(t)?;
                    (vn.to_string(), v)
                }
                _ => return None, // if/try/调用等其他形态 → 整条放弃
            };
            // 值不设白名单：实参内联 = 原位再求值（ddc IR 折叠同款——
            // 基线把 new/调用臂内联进 this() 并保留原赋值在后，接受
            // 重复求值）；前置语句整体后移保持相对次序。前置**形态**仍
            // 限于赋值/声明——裸调用/控制流语句无法安全换位。
            last_assign.insert(name, value);
        }
        // 实参递归内联：VarRef 且前置有赋值 → 表内传递替换
        let call_stmt = stmts[ci];
        let call = *lang.children(call_stmt).first()?;
        let cch = lang.children(call).to_vec();
        let callee = *cch.first()?;
        let mut new_args: Vec<JavaId> = Vec::with_capacity(cch.len() - 1);
        for &a in &cch[1..] {
            new_args.push(hoist_resolve_arg(lang, &last_assign, a, &mut Default::default())?);
        }
        // 新块：[委托(内联实参)] ++ 前置 ++ rest（rest 原位不动）
        let callee_copy = lang.copy_subtree(callee);
        let new_call = lang.call(callee_copy, new_args);
        let new_stmt = lang.expr_stmt(new_call);
        let mut insert: Vec<JavaId> = Vec::with_capacity(ci + 1);
        insert.push(new_stmt);
        insert.extend(stmts[..ci].iter().copied());
        Some(Edit::Splice {
            node: id,
            index: 0,
            remove: ci + 1,
            insert,
        })
    }
}

// ---------------------------------------------------------------------------
// 尾随 else 展平：`if (c) { …; return/throw; } else { … }` →
// `if (c) { …; return/throw; }` + else 体直接续排。then 分支**终结**时
// else 关键字是纯控制流噪声（到达 else 体必须走 then 的非终结路径 =
// 条件为假——与展平后的顺序执行语义完全一致）。三语料实测：尾随 else
// 8,347（telegram）+ 19,992（chatglm）+ 13,145（cmb）= ~41k。
//
// 变体（一并处理）：
// 1. `if (c) { …; return; } else { …; return; }` — else 里的 return 也是
//    尾噪声：if-then-return + 续排（原 else 体含 return 保留——它已经
//    是顺序语义）
// 2. 展平后的 `return; }` + `return;` 尾随对（then/else 各一 return）：
//    else 体仅含一条 return 且 then 已终结 → 整条 else 删掉（外层
//    return 语义由顺序到达保证——但 return 值可能不同，保守只删
//    「else 仅一条裸 return 的 void 形态」）。
// ---------------------------------------------------------------------------

pub struct TrailingElseFlatten;

impl Rule<JavaAst> for TrailingElseFlatten {
    fn name(&self) -> &'static str {
        "trailing_else_flatten"
    }
    fn kinds(&self) -> &'static [NodeKind] {
        &[NodeKind::If]
    }
    fn structural(&self) -> bool {
        true
    }
    fn check(&self, ctx: RewriteCtx<'_, JavaAst>, id: JavaId) -> Option<Edit<JavaAst>> {
        let (parent, idx) = (ctx.parent(id), ctx.index(id));
        let lang = ctx.lang;
        if lang.kind(id) != NodeKind::If {
            return None;
        }
        let ch = lang.children(id).to_vec();
        if ch.len() != 3 {
            return None;
        }
        let (_cond, then, els) = (ch[0], ch[1], ch[2]);
        // then 必须是 Block 且终结（末语句 return/throw）
        if lang.kind(then) != NodeKind::Block {
            return None;
        }
        let then_stmts = lang.children(then).to_vec();
        let then_terminal = then_stmts
            .last()
            .is_some_and(|&s| matches!(lang.kind(s), NodeKind::Return | NodeKind::Throw));
        if !then_terminal {
            return None;
        }
        // else 体仅一条裸 return（void 形态）→ 整条 else 删除
        //（`if (c) { …; return; } else { return; }` 的 else 分支
        //  永远不会被到达——then 已终结，条件为假才能进 else，但
        //  else 里的 return 与后续代码衔接等价——保守只删 void 形态）
        if lang.kind(els) == NodeKind::Block {
            let else_stmts = lang.children(els).to_vec();
            if else_stmts.len() == 1 && lang.kind(else_stmts[0]) == NodeKind::Return {
                // 确认是无值 return（void）
                if lang.children(else_stmts[0]).is_empty() {
                    // 删掉 else：Splice 重构 if 为 2-child
                    return Some(Edit::Splice {
                        node: id,
                        index: 0,
                        remove: 3,
                        insert: vec![ch[0], then],
                    });
                }
            }
        }
        // 一般展平：构 2-child If 节点 + else 体语句追加到父 Block
        let parent = parent?;
        if lang.kind(parent) != NodeKind::Block {
            return None;
        }
        let idx = idx?;
        // 构新 If 节点（[cond, then]）——cond 是表达式不能裸插语句列表
        let new_if = lang.clone_node(id, vec![ch[0], then]);
        let mut insert: Vec<JavaId> = vec![new_if];
        // else 体语句追加（Block 展平或单语句直接加）
        if lang.kind(els) == NodeKind::Block {
            insert.extend(lang.children(els).to_vec());
        } else {
            insert.push(els);
        }
        Some(Edit::Splice {
            node: parent,
            index: idx,
            remove: 1,
            insert,
        })
    }
}

pub struct TrailingIfContinue;

impl Rule<JavaAst> for TrailingIfContinue {
    fn name(&self) -> &'static str {
        "trailing_if_continue"
    }
    fn kinds(&self) -> &'static [NodeKind] {
        &[NodeKind::If]
    }
    fn check(&self, ctx: RewriteCtx<'_, JavaAst>, id: JavaId) -> Option<Edit<JavaAst>> {
        let parent = ctx.parent(id);
        let grandparent = parent.and_then(|p| ctx.parent(p));
        let lang = ctx.lang;
        if lang.kind(id) != NodeKind::If {
            return None;
        }
        let ch = lang.children(id).to_vec();
        // 恰两分支（cond, then——无 else）
        if ch.len() != 2 {
            return None;
        }
        let then = ch[1];
        if lang.kind(then) != NodeKind::Block {
            return None;
        }
        let tbody = lang.children(then).to_vec();
        if tbody.len() != 1 || lang.kind(tbody[0]) != NodeKind::Continue {
            return None;
        }
        // 无标签 continue（带标签的跳法不同）
        if !matches!(lang.data(tbody[0]), NodeData::Continue { label: None }) {
            return None;
        }
        // 父是块且本 if 是最后一条语句；父块是循环体（While/For/ForEach
        // 的最后一个孩子）
        let p = parent?;
        if lang.kind(p) != NodeKind::Block {
            return None;
        }
        let pch = lang.children(p).to_vec();
        if pch.last() != Some(&id) {
            return None;
        }
        // 祖父是循环（While/For/ForEach 的体）
        let gp = grandparent?;
        match lang.kind(gp) {
            NodeKind::While | NodeKind::For | NodeKind::ForEach | NodeKind::DoWhile => {
                let gch = lang.children(gp).to_vec();
                if gch.last() == Some(&p) {
                    Some(Edit::Delete { node: id })
                } else {
                    None
                }
            }
            _ => None,
        }
    }
}

pub struct TrailingAssignReturn;

impl Rule<JavaAst> for TrailingAssignReturn {
    fn name(&self) -> &'static str {
        "trailing_assign_return"
    }
    fn kinds(&self) -> &'static [NodeKind] {
        &[NodeKind::Assign]
    }
    // 节点数持平（Assign+Return 2 语句 → 1 语句）——按节点计数不减，
    // 价值在行数与后续连锁（if_to_ternary 等以 return 形态收敛）
    fn structural(&self) -> bool {
        true
    }
    fn check(&self, ctx: RewriteCtx<'_, JavaAst>, id: JavaId) -> Option<Edit<JavaAst>> {
        let parent = ctx.parent(id);
        let grandparent = parent.and_then(|p| ctx.parent(p));
        let lang = ctx.lang;
        // 简单赋值（复合赋值不折）
        if !matches!(lang.data(id), NodeData::Assign { op: None }) {
            return None;
        }
        let ch = lang.children(id).to_vec();
        if ch.len() != 2 {
            return None;
        }
        let (target, value) = (ch[0], ch[1]);
        // 目标：局部（字段/参数回写惯用形排除——getter 回写是语义性的）
        if lang.kind(target) != NodeKind::VarRef || !lang.is_local_var(target) {
            return None;
        }
        let name = lang.var_name(target)?.to_string();
        // 赋值语句的父块（语句级：ExprStmt 包裹或裸 Assign）
        let parent = parent?;
        let stmt = if lang.kind(parent) == NodeKind::ExprStmt {
            parent
        } else if lang.kind(parent) == NodeKind::Block {
            id
        } else {
            return None;
        };
        let block = if lang.kind(parent) == NodeKind::ExprStmt {
            grandparent?
        } else {
            parent
        };
        if lang.kind(block) != NodeKind::Block {
            return None;
        }
        let stmts = lang.children(block).to_vec();
        let idx = stmts.iter().position(|&x| x == stmt)?;
        // 相邻下一条：return v / throw v
        let next = *stmts.get(idx + 1)?;
        let (flow_val, is_return) = match lang.kind(next) {
            NodeKind::Return => (lang.children(next).first().copied(), true),
            NodeKind::Throw => (lang.children(next).first().copied(), false),
            _ => return None,
        };
        let flow_val = flow_val?;
        if lang.kind(flow_val) != NodeKind::VarRef || lang.var_name(flow_val) != Some(name.as_str()) {
            return None;
        }
        // return 之后语句零 v 引用（死代码里的引用会因赋值消失失去
        // 定赋值而不可编译）
        for &s in &stmts[idx + 2..] {
            if cure_engine::analysis::subtree_contains(lang, s, |n| {
                lang.kind(n) == NodeKind::VarRef && lang.var_name(n) == Some(name.as_str())
            }) {
                return None;
            }
        }
        // 折叠：下一条流语句替换为 return/throw expr；赋值语句删除
        let new_flow = if is_return {
            lang.ret(Some(value))
        } else {
            lang.throw(value)
        };
        Some(Edit::Multi(vec![
            Edit::Replace { target: next, with: new_flow },
            Edit::Delete { node: stmt },
        ]))
    }
}

pub struct ConstFieldPropagate;

impl Rule<JavaAst> for ConstFieldPropagate {
    fn name(&self) -> &'static str {
        "const_field_propagate"
    }
    fn kinds(&self) -> &'static [NodeKind] {
        &[NodeKind::VarRef]
    }
    // 结构性规则：VarRef→Literal 节点数持平（成本模型不增不减）——
    // 价值在语义透明（读点直接可读），非节点缩减
    fn structural(&self) -> bool {
        true
    }
    fn check(&self, ctx: RewriteCtx<'_, JavaAst>, id: JavaId) -> Option<Edit<JavaAst>> {
        let parent = ctx.parent(id);
        let _grandparent = parent.and_then(|p| ctx.parent(p));
        let lang = ctx.lang;
        if lang.kind(id) != NodeKind::VarRef {
            return None;
        }
        let name = lang.var_name(id)?.to_string();
        if !lang.const_scalars.contains(&name) {
            return None;
        }
        if let Some(p) = parent {
            let is_first = lang.children(p).first() == Some(&id);
            match lang.kind(p) {
                // 赋值目标（含复合赋值）：保留原赋值
                NodeKind::Assign if is_first => return None,
                NodeKind::Unary if is_first => {
                    if let NodeData::Unary { op } = lang.data(p) {
                        if op.is_incdec() {
                            return None;
                        }
                    }
                }
                // 裸名调用 callee：方法名，不是字段读
                NodeKind::Call if is_first => return None,
                _ => {}
            }
        }
        let init = *lang.const_fields.get(&name)?;
        let lit = lang.copy_subtree(init);
        Some(Edit::Replace { target: id, with: lit })
    }
}

pub struct NoopPrivateCall;

impl Rule<JavaAst> for NoopPrivateCall {
    fn name(&self) -> &'static str {
        "noop_private_call"
    }
    fn kinds(&self) -> &'static [NodeKind] {
        &[NodeKind::ExprStmt]
    }
    fn check(&self, ctx: RewriteCtx<'_, JavaAst>, id: JavaId) -> Option<Edit<JavaAst>> {
        let lang = ctx.lang;
        if lang.kind(id) != NodeKind::ExprStmt {
            return None;
        }
        let ch = lang.children(id).to_vec();
        if ch.len() != 1 || lang.kind(ch[0]) != NodeKind::Call {
            return None;
        }
        let call = ch[0];
        let cch = lang.children(call).to_vec();
        if cch.is_empty() || lang.kind(cch[0]) != NodeKind::VarRef {
            return None; // 限定名调用（A.m / this.m）是别的方法解析域
        }
        let name = lang.var_name(cch[0])?.to_string();
        let arity = cch.len() - 1;
        let cands = lang.noop_private_methods.get(&name)?.get(&arity)?;
        if cands.is_empty() {
            return None;
        }
        // 类型适用性消解：实参静态类型（局部 var_type / 字段 field_types /
        // 字面量种类）对每个候选形参表判定；未知实参 → 该候选视为适用
        //（不能证不适用——保守）。唯一适用者且 noop → 删除语句。
        let arg_types: Vec<Option<JType>> =
            cch[1..].iter().map(|&a| static_arg_type(lang, a)).collect();
        let mut applicable_noop = false;
        let mut applicable_count = 0usize;
        for c in cands {
            let ok = c
                .params
                .iter()
                .zip(arg_types.iter())
                .all(|(pt, at)| arg_applicable(at.as_ref(), pt));
            if ok {
                applicable_count += 1;
                applicable_noop = c.noop;
            }
        }
        if applicable_count != 1 || !applicable_noop {
            return None;
        }
        // 实参效应 ≤ MayRead（VarRef/字面量/纯算术——字段读不抛不写）
        for &arg in &cch[1..] {
            if lang.effect(arg) > Effect::MayRead {
                return None;
            }
        }
        Some(Edit::Delete { node: id })
    }
}

/// 实参静态类型（判定过载适用性用）：局部/参数走 var_type 解析，字段
/// 走 field_types 表，字面量按种类。null → None（任何引用形参都可能——
/// 全候选适用，保守）。其余表达式 → None。
fn static_arg_type(lang: &JavaAst, arg: JavaId) -> Option<JType> {
    match lang.kind(arg) {
        NodeKind::Literal => match lang.literal(arg)? {
            LitRef::Str(_) => Some(JType::Ref("String".to_string())),
            LitRef::Char(_) => Some(JType::Char),
            LitRef::Bool(_) => Some(JType::Bool),
            LitRef::Int(_) => Some(JType::Int),
            LitRef::Long(_) => Some(JType::Long),
            LitRef::Float(_) => Some(JType::Float),
            LitRef::Double(_) => Some(JType::Double),
            LitRef::Null => None,
        },
        NodeKind::VarRef => {
            let nm = lang.var_name(arg)?;
            lang.var_type(arg)
                .cloned()
                .or_else(|| lang.field_types.get(nm).cloned())
        }
        _ => None,
    }
}

/// 实参类型对形参的适用性（保守方向：不能证不适用 → true）。
/// JLS 过载解析的保守近似：精确简单名匹配 + Object 通配；装箱/拓宽
/// 判不适用（配合「唯一适用」判定仍安全：装箱场景要么 0 适用要么
/// 精确者胜出）。
fn arg_applicable(at: Option<&JType>, pt: &JType) -> bool {
    let Some(a) = at else { return true };
    match pt {
        JType::Ref(p) => {
            let pbase = p.split('<').next().unwrap_or(p).trim();
            pbase == "Object"
                || pbase == "java.lang.Object"
                || match a {
                    JType::Ref(arend) => {
                        let abase = arend.split('<').next().unwrap_or(arend).trim();
                        abase == pbase
                    }
                    _ => false,
                }
        }
        JType::Array(_) => false, // 简单名/字面量实参不适用数组形参（null → None 已兜底）
        prim => match a {
            p2 => std::mem::discriminant(p2) == std::mem::discriminant(prim),
        },
    }
}

// ---------------------------------------------------------------------------
// 常量实参方法内联（解密 helper）：d(0) → 方法体（参数→实参字面量替换）。
// 语义恒安全：单 return 表达式在调用点求值一次，两种形态一致；
// 自递归方法拒绝；实参须全为字面量。
// 【结构性规则】豁免成本门槛：内联暂时变贵、由后续常量折叠回本。
// 终止性：守卫"体内不含任何内联名的裸调用"——每次内联严格消费一个
// 此类调用点且不引入新的同类节点。
// ---------------------------------------------------------------------------

pub struct ConstMethodInline;

impl Rule<JavaAst> for ConstMethodInline {
    fn name(&self) -> &'static str {
        "const_method_inline"
    }
    fn kinds(&self) -> &'static [NodeKind] {
        &[NodeKind::Call]
    }
    fn structural(&self) -> bool {
        true
    }
    fn check(&self, ctx: RewriteCtx<'_, JavaAst>, id: JavaId) -> Option<Edit<JavaAst>> {
        // 语句位标志先取（ctx.lang 借用后 ctx 部分移动——R13 教训）
        let at_stmt_pos = ctx
            .parent(id)
            .map(|p| ctx.lang.kind(p) == NodeKind::ExprStmt)
            .unwrap_or(false);
        let lang = ctx.lang;
        if lang.kind(id) != NodeKind::Call {
            return None;
        }
        let ch = lang.children(id).to_vec();
        // recv_class：静态限定调用的接收者名（Type.valueOf 形态）。
        // 归属守卫的输入——None = 裸名调用（valueOf(x)，隐式本类）或
        // this 前缀，不做归属判定。
        let (method_name, recv_class) = match lang.data(ch[0]) {
            NodeData::VarRef { name } => (*name, None),
            NodeData::Member { name } => {
                let recv = lang.children(ch[0])[0];
                match lang.var_name(recv) {
                    Some(r) if r == "this" => (*name, None),
                    Some(r) if r.chars().next().is_some_and(|c| c.is_uppercase()) => {
                        (*name, Some(r.to_string()))
                    }
                    _ => return None,
                }
            }
            _ => return None,
        };
        let entry = lang.inline_methods.get(lang.sn(method_name)).cloned()?;
        let (params, body_expr, owner) = entry;
        // **归属守卫**：限定调用的接收者类名必须等于声明类——此前名字
        // 匹配不判归属，把 JDK 的 `Integer.valueOf(-1)`（接收者大写即
        // 放行）误当本类 `valueOf(boolean)` 内联，代入 -1 产出
        // `!-1 ? Boolean.FALSE : Boolean.TRUE` 不可编译（ddc lark 语料
        // jna Function 复现）。裸名/this 调用在同一单元内由方法名唯一
        // 性计数守卫兜底。
        if let Some(recv) = recv_class {
            if recv != owner {
                return None;
            }
        }
        // 终止守卫：方法体内不得含任何【内联名】的裸调用
        {
            let names: Vec<String> = lang.inline_methods.keys().cloned().collect();
            for nm in &names {
                if subtree_calls_self(lang, body_expr, nm) {
                    return None;
                }
            }
        }
        let args = ch[1..].to_vec();
        if args.len() != params.len() || params.is_empty() {
            return None;
        }
        for &a in &args {
            lang.literal(a)?;
        }
        let map: std::collections::HashMap<String, JavaId> = params
            .iter()
            .zip(args.iter())
            .map(|(p, &a)| (p.clone(), a))
            .collect();
        let with = copy_subst(lang, body_expr, &map);
        // **语句位形态守卫**（ddc/deepseek cs8 抓获：`e("KType");` 的
        // 单 return 体内联成 `mk(...).a;`——字段访问不是合法表达式语句
        //（JLS 14.8 仅赋值/自增自减/调用/new），与 R12 foreach 的 e; 同
        // 族）。调用在裸 ExprStmt 位（结果弃置）时，替换表达式必须是
        // Call/New——否则保留原调用
        if at_stmt_pos {
            match lang.kind(with) {
                NodeKind::Call | NodeKind::New => {}
                _ => return None,
            }
        }
        Some(Edit::Replace {
            target: id,
            with,
        })
    }
}

/// 深拷贝 + VarRef 参数替换。
fn copy_subst(
    lang: &mut JavaAst,
    node: JavaId,
    map: &std::collections::HashMap<String, JavaId>,
) -> JavaId {
    if let NodeData::VarRef { name } = lang.data(node) {
        if let Some(&repl) = map.get(lang.sn(*name)) {
            return lang.copy_subtree(repl);
        }
    }
    let children: Vec<JavaId> = lang.children(node).to_vec();
    let new_children: Vec<JavaId> = children
        .iter()
        .map(|&c| copy_subst(lang, c, map))
        .collect();
    lang.clone_node(node, new_children)
}


// ---------------------------------------------------------------------------
// try-with-resources 还原（twr_recover）：两种反编译器直出形态。
//
// family B（ddc：javac→d8 字节码的紧凑渲染）：
//   R r = new R(...);            // 资源（new——无卫语句形态下唯一非空证明）
//   try { B }
//   catch (Throwable t) {
//       try { r.close(); }
//       catch (Throwable sup) { t.addSuppressed(sup); }
//       throw t;
//   }
//   r.close();                   // 正常路径尾部直调
//   → try (R r = new R(...)) { B }
//
// family A（javac 源级翻译；CFR/ProGuard 常见）：
//   R r = init; Throwable primary = null;
//   try { B }
//   catch (Throwable t) { primary = t; throw t; }
//   finally {
//       if (r != null) {
//           if (primary != null) {
//               try { r.close(); } catch (Throwable sup) { primary.addSuppressed(sup); }
//           } else { r.close(); }
//       }
//   }
//   → try (R r = init) { B }      // 含 null 资源跳过 close 的路径（卫语句保证）
//
// 多资源：嵌套形态由不动点逐层还原（内层先→外层 try 体含 try(res)——
// JLS 上嵌套 TWR ≡ 多资源 TWR，无需合并）。守卫：r/primary/t/sup 的全部
// 引用必须落在模式消费的子树内（否则不还原）；同名遮蔽一律拒绝。
// ---------------------------------------------------------------------------

pub struct TwrRecover;

fn twr_is_throwable(ty_raw: &str) -> bool {
    ty_raw == "Throwable" || ty_raw == "java.lang.Throwable"
}

/// 表达式语句解包：ExprStmt{e} → e（赋值/调用等语句位置）。
fn unwrap_expr_stmt(lang: &JavaAst, n: JavaId) -> JavaId {
    if lang.kind(n) == NodeKind::ExprStmt {
        if let Some(&e) = lang.children(n).first() {
            return e;
        }
    }
    n
}

/// 语句序列（Block 展开；单语句原样）。
fn twr_stmts(lang: &JavaAst, n: JavaId) -> Vec<JavaId> {
    if lang.kind(n) == NodeKind::Block {
        lang.children(n).to_vec()
    } else {
        vec![n]
    }
}

/// `r.close()` 调用表达式（ExprStmt 解包后）。
fn twr_is_close_call(lang: &JavaAst, e: JavaId, r: &str) -> bool {
    if lang.kind(e) != NodeKind::Call {
        return false;
    }
    let ch = lang.children(e);
    if ch.len() != 1 {
        return false;
    }
    match lang.data(ch[0]) {
        NodeData::Member { name } if lang.sn(*name) == "close" => {
            let Some(&recv) = lang.children(ch[0]).first() else {
                return false;
            };
            lang.kind(recv) == NodeKind::VarRef && lang.var_name(recv) == Some(r)
        }
        _ => false,
    }
}

fn twr_is_close_stmt(lang: &JavaAst, n: JavaId, r: &str) -> bool {
    if lang.kind(n) != NodeKind::ExprStmt {
        return false;
    }
    lang.children(n)
        .first()
        .is_some_and(|&e| twr_is_close_call(lang, e, r))
}

/// `primary.addSuppressed(sup)` 语句。
fn twr_is_add_suppressed(lang: &JavaAst, n: JavaId, primary: &str, sup: &str) -> bool {
    if lang.kind(n) != NodeKind::ExprStmt {
        return false;
    }
    let Some(&e) = lang.children(n).first() else {
        return false;
    };
    if lang.kind(e) != NodeKind::Call {
        return false;
    }
    let ch = lang.children(e);
    if ch.len() != 2 {
        return false;
    }
    match lang.data(ch[0]) {
        NodeData::Member { name } if lang.sn(*name) == "addSuppressed" => {
            let Some(&recv) = lang.children(ch[0]).first() else {
                return false;
            };
            lang.kind(recv) == NodeKind::VarRef
                && lang.var_name(recv) == Some(primary)
                && lang.kind(ch[1]) == NodeKind::VarRef
                && lang.var_name(ch[1]) == Some(sup)
        }
        _ => false,
    }
}

fn node_contains(lang: &JavaAst, root: JavaId, target: JavaId) -> bool {
    let mut stack = vec![root];
    while let Some(n) = stack.pop() {
        if n == target {
            return true;
        }
        stack.extend(lang.children(n).iter().copied());
    }
    false
}

/// root 内存在 name 的引用且不在任何 allowed 子树内（模式外的逃逸引用）。
fn refs_escape(lang: &JavaAst, root: JavaId, name: &str, allowed: &[JavaId]) -> bool {
    let mut stack = vec![root];
    while let Some(n) = stack.pop() {
        if lang.kind(n) == NodeKind::VarRef && lang.var_name(n) == Some(name) {
            let ok = allowed
                .iter()
                .any(|&a| a == n || node_contains(lang, a, n));
            if !ok {
                return true;
            }
        }
        if lang.kind(n) == NodeKind::VarDecl {
            if let Some(nm) = lang.var_name(n) {
                if nm == name && !allowed.contains(&n) {
                    // 同名再声明（遮蔽风险）→ 拒绝
                    return true;
                }
            }
        }
        stack.extend(lang.children(n).iter().copied());
    }
    false
}

/// Try{try 块, 单 catch(Throwable, sup), 无 finally} 且 catch 体 =
/// [addSuppressed(primary, sup)]、try 体 = [r.close()]。
/// 返回 (r 名, sup 名)。primary 传闭包外确定。
fn twr_close_with_suppressed(
    lang: &JavaAst,
    try_node: JavaId,
    primary: &str,
) -> Option<(String, String)> {
    let ch = lang.children(try_node).to_vec();
    if ch.len() != 2 || lang.kind(ch[0]) != NodeKind::Block {
        return None;
    }
    let NodeData::Catch { ty_raw, name: sup } = lang.data(ch[1]) else {
        return None;
    };
    if !twr_is_throwable(ty_raw) {
        return None;
    }
    let sup = sup.clone();
    let catch_stmts = twr_stmts(lang, *lang.children(ch[1]).first()?);
    if catch_stmts.len() != 1 || !twr_is_add_suppressed(lang, catch_stmts[0], primary, &sup) {
        return None;
    }
    let close_stmts = twr_stmts(lang, ch[0]);
    if close_stmts.len() != 1 {
        return None;
    }
    if lang.kind(close_stmts[0]) != NodeKind::ExprStmt {
        return None;
    }
    let e = *lang.children(close_stmts[0]).first()?;
    let cc = lang.children(e);
    if cc.len() != 1 {
        return None;
    }
    let NodeData::Member { name } = lang.data(cc[0]) else {
        return None;
    };
    if lang.sn(*name) != "close" {
        return None;
    }
    let recv = *lang.children(cc[0]).first()?;
    if lang.kind(recv) != NodeKind::VarRef {
        return None;
    }
    Some((lang.var_name(recv)?.to_string(), sup))
}

impl Rule<JavaAst> for TwrRecover {
    fn name(&self) -> &'static str {
        "twr_recover"
    }
    fn kinds(&self) -> &'static [NodeKind] {
        &[NodeKind::Try]
    }
    fn structural(&self) -> bool {
        true
    }
    fn check(&self, ctx: RewriteCtx<'_, JavaAst>, id: JavaId) -> Option<Edit<JavaAst>> {
        // 先取 ctx 查询（lang 的 &mut 移出后 ctx 不可再用）
        let (parent, idx, walk_root) = (ctx.parent(id)?, ctx.index(id)?, ctx.root());
        let lang = ctx.lang;
        if lang.kind(id) != NodeKind::Try {
            return None;
        }
        let ch = lang.children(id).to_vec();
        // 资源已存在的（嵌套已还原）不再匹配
        let try_idx = ch
            .iter()
            .position(|&c| lang.kind(c) == NodeKind::Block)?;
        if try_idx != 0 {
            return None;
        }
        let try_block = ch[0];
        if lang.kind(parent) != NodeKind::Block {
            return None;
        }
        let pch = lang.children(parent).to_vec();

        // ===== family B：[decl_r, try{B}catch, close] =====
        if ch.len() == 2 {
            if let NodeData::Catch { ty_raw, name: t } = lang.data(ch[1]) {
                if twr_is_throwable(ty_raw) {
                    let t = t.clone();
                    let catch_stmts = twr_stmts(lang, *lang.children(ch[1]).first()?);
                    if catch_stmts.len() == 2 {
                        // [Try{close,sup}, throw t]
                        let (inner_try, throw_stmt) = (catch_stmts[0], catch_stmts[1]);
                        let throw_ok = lang.kind(throw_stmt) == NodeKind::Throw
                            && lang
                                .children(throw_stmt)
                                .first()
                                .is_some_and(|&x| {
                                    lang.kind(x) == NodeKind::VarRef
                                        && lang.var_name(x) == Some(t.as_str())
                                });
                        if throw_ok && lang.kind(inner_try) == NodeKind::Try {
                            if let Some((r, sup)) =
                                twr_close_with_suppressed(lang, inner_try, t.as_str())
                            {
                                if idx >= 1 && idx + 1 < pch.len() {
                                    let decl_r = pch[idx - 1];
                                    let trailing = pch[idx + 1];
                                    if let NodeData::VarDecl { name, ty, .. } = lang.data(decl_r) {
                                        if name == &r {
                                            let (name, ty) = (name.clone(), ty.clone());
                                            let init =
                                                lang.children(decl_r).first().copied();
                                            if let Some(init) = init {
                                                // 无卫语句形态：init 须为 new（非空证明）
                                                let provably_new = lang.kind(init)
                                                    == NodeKind::New;
                                                let close_ok =
                                                    twr_is_close_stmt(lang, trailing, &r);
                                                if provably_new && close_ok {
                                                    // 引用逃逸扫描
                                                    let root = walk_root;
                                                    let r_ok = !refs_escape(
                                                        lang,
                                                        root,
                                                        &r,
                                                        &[
                                                            decl_r,
                                                            init,
                                                            *lang
                                                                .children(inner_try)
                                                                .first()
                                                                .unwrap_or(&inner_try),
                                                            trailing,
                                                            try_block,
                                                        ],
                                                    );
                                                    let t_ok = !refs_escape(
                                                        lang, root, &t,
                                                        &[throw_stmt, ch[1]],
                                                    );
                                                    let sup_ok = !refs_escape(
                                                        lang, root, &sup,
                                                        &[ch[1]],
                                                    );
                                                    if r_ok && t_ok && sup_ok {
                                                        let init_copy =
                                                            lang.copy_subtree(init);
                                                        let res = lang.var_decl(
                                                            &name, ty,
                                                            Some(init_copy),
                                                        );
                                                        let new_try = lang.try_(
                                                            vec![res],
                                                            try_block,
                                                            Vec::new(),
                                                            None,
                                                        );
                                                        return Some(Edit::Splice {
                                                            node: parent,
                                                            index: idx - 1,
                                                            remove: 3,
                                                            insert: vec![new_try],
                                                        });
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        // ===== family A：[decl_r, decl_primary, try{B}catch{primary=t;throw}finally{卫语句}] =====
        if ch.len() == 3 {
            let NodeData::Catch { ty_raw, name: t } = lang.data(ch[1]) else {
                return None;
            };
            if !twr_is_throwable(ty_raw) {
                return None;
            }
            let t = t.clone();
            // finally 块
            if lang.kind(ch[2]) != NodeKind::Block {
                return None;
            }
            let fin_stmts = twr_stmts(lang, ch[2]);
            if fin_stmts.len() != 1 || lang.kind(fin_stmts[0]) != NodeKind::If {
                return None;
            }
            // catch 体 = [primary = t, throw t]
            let catch_stmts = twr_stmts(lang, *lang.children(ch[1]).first()?);
            if catch_stmts.len() != 2 {
                return None;
            }
            let (assign_stmt, throw_stmt) = (catch_stmts[0], catch_stmts[1]);
            let assign_expr = unwrap_expr_stmt(lang, assign_stmt);
            let NodeData::Assign { op: None } = lang.data(assign_expr) else {
                return None;
            };
            let as_ch = lang.children(assign_expr);
            if as_ch.len() != 2 {
                return None;
            }
            let primary = match lang.data(as_ch[0]) {
                NodeData::VarRef { name } => lang.sn(*name).to_string(),
                _ => return None,
            };
            let assign_ok = lang.kind(as_ch[1]) == NodeKind::VarRef
                && lang.var_name(as_ch[1]) == Some(t.as_str())
                && lang.kind(as_ch[0]) == NodeKind::VarRef
                && lang.var_name(as_ch[0]) == Some(primary.as_str());
            let throw_ok = lang.kind(throw_stmt) == NodeKind::Throw
                && lang.children(throw_stmt)
                    .first()
                    .is_some_and(|&x| {
                        lang.kind(x) == NodeKind::VarRef
                            && lang.var_name(x) == Some(t.as_str())
                    });
            if !assign_ok || !throw_ok {
                return None;
            }
            // 卫语句：if (r != null) { if (primary != null) { try{r.close()}catch{sup} } else { r.close() } }
            let if1 = fin_stmts[0];
            let i1 = lang.children(if1).to_vec();
            if i1.len() < 2 {
                return None;
            }
            let cond1 = i1[0];
            let NodeData::Binary { op: BinOp::Ne } = lang.data(cond1) else {
                return None;
            };
            let c1 = lang.children(cond1);
            let r = match lang.data(c1[0]) {
                NodeData::VarRef { name } if lang.literal(c1[1]) == Some(LitRef::Null) => {
                    lang.sn(*name).to_string()
                }
                _ => {
                    return None;
                }
            };
            let then1 = i1[1];
            let inner_stmts = twr_stmts(lang, then1);
            if inner_stmts.len() != 1 || lang.kind(inner_stmts[0]) != NodeKind::If {
                return None;
            }
            let if2 = inner_stmts[0];
            let i2 = lang.children(if2).to_vec();
            if i2.len() != 3 {
                return None;
            }
            let NodeData::Binary { op: BinOp::Ne } = lang.data(i2[0]) else {
                return None;
            };
            let c2 = lang.children(i2[0]);
            let primary_ok = lang.kind(c2[0]) == NodeKind::VarRef
                && lang.var_name(c2[0]) == Some(primary.as_str())
                && lang.literal(c2[1]) == Some(LitRef::Null);
            if !primary_ok {
                return None;
            }
            let (then2, els2) = (i2[1], i2[2]);
            // then2: Try{[r.close()], catch{primary.addSuppressed(sup)}}
            let t2_stmts = twr_stmts(lang, then2);
            if t2_stmts.len() != 1 || lang.kind(t2_stmts[0]) != NodeKind::Try {
                return None;
            }
            let Some((r2, sup)) =
                twr_close_with_suppressed(lang, t2_stmts[0], primary.as_str())
            else {
                return None;
            };
            if r2 != r {
                return None;
            }
            // els2: [r.close()]
            let e2_stmts = twr_stmts(lang, els2);
            if e2_stmts.len() != 1 || !twr_is_close_stmt(lang, e2_stmts[0], &r) {
                return None;
            }
            // 父块三连：decl_r, decl_primary, try
            if idx < 2 {
                return None;
            }
            let decl_r = pch[idx - 2];
            let decl_primary = pch[idx - 1];
            let (r_decl, primary_decl) = match (lang.data(decl_r), lang.data(decl_primary)) {
                (
                    NodeData::VarDecl { name: rn, .. },
                    NodeData::VarDecl { name: pn, .. },
                ) => (rn.clone(), pn.clone()),
                _ => return None,
            };
            if r_decl != r || primary_decl != primary {
                return None;
            }
            // primary 初始化为 null
            let pinit_null = lang
                .children(decl_primary)
                .first()
                .is_some_and(|&n| lang.literal(n) == Some(LitRef::Null));
            if !pinit_null {
                return None;
            }
            let r_init = lang.children(decl_r).first().copied()?;
            let ty = match lang.data(decl_r) {
                NodeData::VarDecl { ty, .. } => ty.clone(),
                _ => return None,
            };
            // 引用逃逸扫描
            let root = walk_root;
            // finally 整体被消费：卫语句内的 r/primary 引用均合法
            let r_allowed = [decl_r, r_init, ch[2], try_block];
            let t_allowed = [throw_stmt, assign_stmt, ch[1], ch[2]];
            let p_allowed = [decl_primary, assign_stmt, ch[2]];
            if refs_escape(lang, root, &r, &r_allowed)
                || refs_escape(lang, root, &primary, &p_allowed)
                || refs_escape(lang, root, &t, &t_allowed)
                || refs_escape(lang, root, &sup, &[ch[2]])
            {
                return None;
            }
            let init_copy = lang.copy_subtree(r_init);
            let res = lang.var_decl(&r, ty, Some(init_copy));
            let new_try = lang.try_(vec![res], try_block, Vec::new(), None);
            return Some(Edit::Splice {
                node: parent,
                index: idx - 2,
                remove: 3,
                insert: vec![new_try],
            });
        }
        None
    }
}

// ---------------------------------------------------------------------------
// 字符串 switch 还原（string_switch_recover）：javac v7 索引二级 switch
// 形态（ddc 直出；javac 字节码本相——hashCode 定位 + equals 守卫 + 索引
// switch 分发）：
//   int v7 = 0;
//   switch (s.hashCode()) {
//       case H_i: {
//           boolean e = s.equals("L_i");
//           if (!e) { break; } else {
//               v7 = K_i;
//               switch (v7) { case K_1: BODY_1; ... default: BODY_DEF; }
//           }
//       } ...
//   }
//   v7 = -1;
//   switch (v7) { case K_1: BODY_1; ... default: BODY_DEF; }   // 无匹配路径
//   → switch (s) { case "L_1": BODY_1; ... default: BODY_DEF; }
//
// 守卫：选择器与 equals 接收方同为纯 VarRef（一次求值语义）；
// 各索引 switch（含尾部）签名全同；每个 BODY 以终止语句收尾（无落穿，
// 标签序无关）；v/e 引用全部落在被消费子树内；H_i ≡ "L_i".hashCode()。
// 哈希碰撞（同 case 双守卫）形态更复杂 → 整体不还原（负控锁定）。
// ---------------------------------------------------------------------------

pub struct StringSwitchRecover;

fn subtree_sig(lang: &JavaAst, n: JavaId, out: &mut String) {
    out.push_str(&format!("{:?} ", lang.data(n)));
    for &c in lang.children(n) {
        subtree_sig(lang, c, out);
    }
}

/// 从 v7 索引 switch 提取 case K → 语句、default → 语句。
fn ssw_bodies(lang: &JavaAst, sw: JavaId) -> Option<Vec<(Option<i64>, Vec<JavaId>)>> {
    let ch = lang.children(sw).to_vec();
    let mut out = Vec::new();
    for &c in &ch[1..] {
        let NodeData::Case { labels, is_default, .. } = lang.data(c) else {
            return None;
        };
        let is_default = *is_default;
        let cc = lang.children(c);
        let label = if is_default {
            None
        } else {
            if *labels != 1 {
                return None; // 多标签 → 复杂形态，不还原
            }
            let lab = cc[0];
            let lit = lang.literal(lab)?;
            let v = match lit {
                LitRef::Int(v) | LitRef::Long(v) => v,
                _ => return None, // 非整型标签（字符串 case 是还原产物/负控）
            };
            Some(v)
        };
        out.push((label, cc[*labels as usize..].to_vec()));
    }
    Some(out)
}

fn ssw_body_terminal(lang: &JavaAst, stmts: &[JavaId]) -> bool {
    let Some(&last) = stmts.last() else {
        return false; // 空体无终止
    };
    let last = if lang.kind(last) == NodeKind::Block {
        match lang.children(last).last() {
            Some(&l) => l,
            None => return false,
        }
    } else {
        last
    };
    matches!(
        lang.kind(last),
        NodeKind::Return | NodeKind::Break | NodeKind::Throw | NodeKind::Continue
    )
}

impl Rule<JavaAst> for StringSwitchRecover {
    fn name(&self) -> &'static str {
        "string_switch_recover"
    }
    fn kinds(&self) -> &'static [NodeKind] {
        &[NodeKind::Switch]
    }
    fn structural(&self) -> bool {
        true
    }
    fn check(&self, ctx: RewriteCtx<'_, JavaAst>, id: JavaId) -> Option<Edit<JavaAst>> {
        let (parent, idx, ctx_root) = (ctx.parent(id)?, ctx.index(id)?, ctx.root());
        let lang = ctx.lang;
        if lang.kind(id) != NodeKind::Switch {
            return None;
        }
        let ch = lang.children(id).to_vec();
        if ch.len() < 2 {
            return None;
        }
        // 选择器 x.hashCode()
        let x = match lang.data(ch[0]) {
            NodeData::Call => {
                let cc = lang.children(ch[0]);
                if cc.len() != 1 {
                    return None;
                }
                match lang.data(cc[0]) {
                    NodeData::Member { name } if lang.sn(*name) == "hashCode" => {
                        let recv = *lang.children(cc[0]).first()?;
                        if lang.kind(recv) != NodeKind::VarRef {
                            return None;
                        }
                        lang.var_name(recv)?.to_string()
                    }
                    _ => return None,
                }
            }
            _ => {
                return None;
            }
        };
        // 各 hash case：单整型标签 + [decl_e?, if(!guard) break else {v=K, switch(v)}]
        struct CaseInfo {
            lit: String,
            k: i64,
            inner_switch: JavaId,
        }
        let mut infos: Vec<CaseInfo> = Vec::new();
        let mut v_name: Option<String> = None;
        let mut v_nodes: Vec<JavaId> = Vec::new(); // v 的全部合法出现（供逃逸扫描）
        let mut guard_nodes: Vec<JavaId> = Vec::new();
        for &c in &ch[1..] {
            let NodeData::Case { labels, is_default, .. } = lang.data(c) else {
                return None;
            };
            let is_default = *is_default;
            if is_default {
                return None; // hash switch 不应有 default（无匹配由尾部处理）
            }
            if *labels != 1 {
                return None;
            }
            let cc = lang.children(c);
            let h = match lang.literal(cc[0])? {
                LitRef::Int(v) | LitRef::Long(v) => v as i32,
                _ => return None,
            };
            let body = cc[1..].to_vec();
            // 单 Block 解包
            let body = if body.len() == 1 && lang.kind(body[0]) == NodeKind::Block {
                lang.children(body[0]).to_vec()
            } else {
                body
            };
            let mut rest = body;
            // 可选物化 boolean
            let mut _e_decl: Option<(String, JavaId)> = None;
            if let Some(&first) = rest.first() {
                if let NodeData::VarDecl { name, .. } = lang.data(first) {
                    if let Some(&init) = lang.children(first).first() {
                        if is_x_equals(lang, init, &x) {
                            _e_decl = Some((name.clone(), first));
                            rest = rest[1..].to_vec();
                        }
                    }
                }
            }
            if rest.len() != 1 || lang.kind(rest[0]) != NodeKind::If {
                return None;
            }
            let ifn = rest[0];
            let ic = lang.children(ifn).to_vec();
            if ic.len() != 3 {
                return None;
            }
            // cond = !guard（guard = e 或 x.equals(L)）
            let NodeData::Unary { op: UnOp::Not } = lang.data(ic[0]) else {
                return None;
            };
            let guard = *lang.children(ic[0]).first()?;
            let lit = match lang.data(guard) {
                NodeData::VarRef { name } => {
                    // 物化 boolean：其唯一定义须是 x.equals("L")
                    let Some((en, decl)) = &_e_decl else {
                        return None;
                    };
                    if lang.sn(*name) != en {
                        return None;
                    }
                    let init = *lang.children(*decl).first()?;
                    equals_lit(lang, init, &x)?
                }
                NodeData::Call => equals_lit(lang, guard, &x)?,
                _ => return None,
            };
            guard_nodes.push(guard);
            if let Some((_, decl)) = &_e_decl {
                guard_nodes.push(*decl);
            }
            // then = break（无标签）
            let then_ok = twr_stmts(lang, ic[1]).len() == 1
                && matches!(lang.data(twr_stmts(lang, ic[1])[0]),
                    NodeData::Break { label: None });
            if !then_ok {
                return None;
            }
            // els = [v = K, switch(v)] 或 [switch(K)]
            let els = twr_stmts(lang, ic[2]);
            let (k, inner_switch, assign_node) = match els.len() {
                2 => {
                    let assign_expr = unwrap_expr_stmt(lang, els[0]);
                    let NodeData::Assign { op: None } = lang.data(assign_expr) else {
                        return None;
                    };
                    let a_ch = lang.children(assign_expr);
                    let vn = match lang.data(a_ch[0]) {
                        NodeData::VarRef { name } => lang.sn(*name).to_string(),
                        _ => return None,
                    };
                    let k = match lang.literal(a_ch[1])? {
                        LitRef::Int(v) | LitRef::Long(v) => v,
                        _ => return None,
                    };
                    if lang.kind(els[1]) != NodeKind::Switch {
                        return None;
                    }
                    // switch 选择器须为 v
                    let sel = *lang.children(els[1]).first()?;
                    if lang.kind(sel) != NodeKind::VarRef
                        || lang.var_name(sel) != Some(vn.as_str())
                    {
                        return None;
                    }
                    match &v_name {
                        Some(v) if *v != vn => return None,
                        _ => v_name = Some(vn),
                    }
                    (k, els[1], Some(els[0]))
                }
                1 => {
                    if lang.kind(els[0]) != NodeKind::Switch {
                        return None;
                    }
                    // 常量折叠后的形态：switch(K)
                    let sel = *lang.children(els[0]).first()?;
                    let k = match lang.literal(sel)? {
                        LitRef::Int(v) | LitRef::Long(v) => v,
                        _ => return None,
                    };
                    (k, els[0], None)
                }
                _ => return None,
            };
            if let Some(a) = assign_node {
                v_nodes.push(a);
            }
            v_nodes.push(*lang.children(inner_switch).first()?);
            // H ≡ hash(L)
            let hlit: i32 = lit
                .chars()
                .fold(0i32, |acc, ch| acc.wrapping_mul(31).wrapping_add(ch as i32));
            if hlit != h {
                return None;
            }
            let _ = assign_node;
            infos.push(CaseInfo {
                lit,
                k,
                inner_switch,
            });
        }
        if infos.is_empty() {
            return None;
        }
        // 父块 + 尾部
        if lang.kind(parent) != NodeKind::Block {
            return None;
        }
        let pch = lang.children(parent).to_vec();
        let mut k = idx + 1;
        // 可选 v = -1
        if k < pch.len() {
            let texpr = unwrap_expr_stmt(lang, pch[k]);
            if let NodeData::Assign { op: None } = lang.data(texpr) {
                let a_ch = lang.children(texpr);
                if a_ch.len() == 2
                    && lang.kind(a_ch[0]) == NodeKind::VarRef
                    && lang.var_name(a_ch[0]) == v_name.as_deref()
                    && lang.literal(a_ch[1]) == Some(LitRef::Int(-1))
                {
                    v_nodes.push(pch[k]);
                    k += 1;
                }
            }
        }
        if k >= pch.len() || lang.kind(pch[k]) != NodeKind::Switch {
            return None;
        }
        let trailing = pch[k];
        // 尾部选择器：VarRef v 或常量
        let tsel = *lang.children(trailing).first()?;
        match lang.data(tsel) {
            NodeData::VarRef { name } if Some(lang.sn(*name)) == v_name.as_deref() => {
                v_nodes.push(tsel);
            }
            NodeData::Literal(Lit::Int(_)) | NodeData::Literal(Lit::Long(_)) => {}
            _ => {
                lang.literal(tsel)?;
            }
        }
        // 签名一致性：所有 inner switch + trailing 的**case 体**全同
        //（选择器除外——尾部的 v 常被赋值传播折叠成字面量）
        fn switch_cases_sig(lang: &JavaAst, sw: JavaId, out: &mut String) {
            for &c in &lang.children(sw)[1..] {
                subtree_sig(lang, c, out);
            }
        }
        let mut sig0 = String::new();
        switch_cases_sig(lang, infos[0].inner_switch, &mut sig0);
        for info in &infos[1..] {
            let mut sig = String::new();
            switch_cases_sig(lang, info.inner_switch, &mut sig);
            if sig != sig0 {
                return None;
            }
        }
        {
            let mut sig = String::new();
            switch_cases_sig(lang, trailing, &mut sig);
            if sig != sig0 {
                return None;
            }
        }
        // 提取 body（用第一个 inner switch）
        let bodies = ssw_bodies(lang, infos[0].inner_switch)?;
        let mut body_map: std::collections::HashMap<i64, Vec<JavaId>> =
            std::collections::HashMap::new();
        let mut default_body: Option<Vec<JavaId>> = None;
        for (lab, stmts) in &bodies {
            match lab {
                Some(v) => {
                    body_map.insert(*v, stmts.clone());
                }
                None => default_body = Some(stmts.clone()),
            }
        }
        let Some(default_body) = default_body else {
            return None;
        };
        // 终止性
        for stmts in body_map.values().chain(std::iter::once(&default_body)) {
            if !ssw_body_terminal(lang, stmts) {
                return None;
            }
        }
        // v/e 逃逸扫描（v 的声明本身合法——索引变量；其引用全在消费子树内）
        let root = ctx_root;
        if let Some(vn) = &v_name {
            let mut allowed: Vec<JavaId> = v_nodes.clone();
            allowed.push(trailing);
            if idx >= 1 {
                let cand = pch[idx - 1];
                if let NodeData::VarDecl { name, .. } = lang.data(cand) {
                    if name == vn {
                        allowed.push(cand);
                        // 声明位置紧邻（ddc 形态）；隔开的声明仍拒绝
                        if idx != 1 {
                            allowed.pop();
                        }
                    }
                }
            }
            if refs_escape(lang, root, vn, &allowed) {
                return None;
            }
        }
        // 构建 switch (x) { case "L": BODY_K; ... default: BODY_DEF }
        let mut new_cases: Vec<JavaId> = Vec::new();
        for info in &infos {
            let Some(body) = body_map.get(&info.k) else {
                return None;
            };
            let lab = lang.lit(Lit::Str(info.lit.clone()));
            let case = lang.case_(vec![lab], false, false, body.clone());
            new_cases.push(case);
        }
        let def_case = lang.case_(Vec::new(), true, false, default_body);
        new_cases.push(def_case);
        let sel = lang.var(&x);
        let new_switch = lang.switch_(sel, new_cases);
        // 消费 [hash switch, (v=-1)?, trailing switch]
        let remove = k - idx + 1;
        Some(Edit::Splice {
            node: parent,
            index: idx,
            remove,
            insert: vec![new_switch],
        })
    }
}

/// Call{x.equals("L")} → L
fn equals_lit(lang: &JavaAst, e: JavaId, x: &str) -> Option<String> {
    if lang.kind(e) != NodeKind::Call {
        return None;
    }
    let cc = lang.children(e);
    if cc.len() != 2 {
        return None;
    }
    match lang.data(cc[0]) {
        NodeData::Member { name } if lang.sn(*name) == "equals" => {
            let recv = *lang.children(cc[0]).first()?;
            if lang.kind(recv) != NodeKind::VarRef || lang.var_name(recv) != Some(x) {
                return None;
            }
            match lang.literal(cc[1])? {
                LitRef::Str(s) => Some(s.to_string()),
                _ => None,
            }
        }
        _ => None,
    }
}

fn is_x_equals(lang: &JavaAst, e: JavaId, x: &str) -> bool {
    lang.kind(e) == NodeKind::Call && equals_lit(lang, e, x).is_some()
}

// ---------------------------------------------------------------------------
// 门面
// ---------------------------------------------------------------------------


/// Java 默认规则集（引擎通用规则 + Java 特有规则；保守集，不含 DCE 类）。
pub fn default_java_rules() -> Vec<Box<dyn Rule<JavaAst>>> {
    let mut rules: Vec<Box<dyn Rule<JavaAst>>> = cure_engine::rules::default_rules();
    rules.push(Box::new(CastSimplify));
    rules.push(Box::new(SelfCompare));
    rules.push(Box::new(StringBuilderFold));
    rules.push(Box::new(BoxUnboxChain));
    rules.push(Box::new(IteratorToForEach));
    rules.push(Box::new(NewStringFold));
    rules.push(Box::new(NewStringCharArrayFold));
    rules.push(Box::new(EmptyFinallyStrip));
    rules.push(Box::new(TryUnwrapNoCatch));
    rules.push(Box::new(TryUnwrapRethrow));
    rules.push(Box::new(StaticExec));
    rules.push(Box::new(LoopHeadBreak));
    rules.push(Box::new(WhileIteratorToForEach));
    rules.push(Box::new(ConcatValueOfDrop));
    rules.push(Box::new(StringBuilderStatements));
    rules.push(Box::new(TrailingContinueJava));
    rules.push(Box::new(XorNoise));
    rules.push(Box::new(StrLenFold));
    rules.push(Box::new(LiteralEval));
    rules.push(Box::new(Base64NewStringFold));
    rules.push(Box::new(UrlDecodeFold));
    rules.push(Box::new(CffRecover));
    rules.push(Box::new(StaticArrayIndexFold));
    rules.push(Box::new(TrailingAssignReturn));
    rules.push(Box::new(DeadPureCall));
    rules.push(Box::new(CtorDelegationHoist));
    rules.push(Box::new(TrailingElseFlatten));
    rules.push(Box::new(TrailingIfContinue));
    rules.push(Box::new(ConstFieldPropagate));
    rules.push(Box::new(NoopPrivateCall));
    rules.push(Box::new(ConstMethodInline));
    rules.push(Box::new(TwrRecover));
    rules.push(Box::new(StringSwitchRecover));
    rules
}

/// 全量规则（含 DCE 类选配项：不可达语句删除等）。
pub fn all_java_rules() -> Vec<Box<dyn Rule<JavaAst>>> {
    let mut rules = default_java_rules();
    let mut engine_all = cure_engine::rules::all_rules();
    rules.append(&mut engine_all);
    rules
}

/// 对方法体（或任意语句 Block）运行 Java 规则集直到 fixed point。
pub fn simplify(ast: &mut JavaAst, root: JavaId, cfg: &Config) -> Report {
    let rules = default_java_rules();
    cure_engine::simplify(ast, root, &rules, cfg)
}

/// 整个编译单元：逐个方法体/初始化块/字段初始化器优化，签名不动。
/// 带外部事实的单元简化：前端 IR 权威陈述（单定义/单使用/布尔性/
/// 调用副作用）注入后运行常规管线——事实只放宽守卫，不改变规则集。
/// 单元结束自动清空（JavaFacts 生命周期 = 编译单元）。
pub fn simplify_unit_with_facts(
    ast: &mut JavaAst,
    unit: &mut CompilationUnit,
    cfg: &Config,
    facts: &cure_java_ast::JavaFacts,
) -> Report {
    ast.set_facts(facts.clone());
    let r = simplify_unit(ast, unit, cfg);
    ast.clear_facts();
    r
}

pub fn simplify_unit(ast: &mut JavaAst, unit: &mut CompilationUnit, cfg: &Config) -> Report {
    let mut total = Report::default();
    // 收敛外循环：引擎单次调用跑至"本轮无应用"即停，但末轮被丢弃的结构
    // 提案（目标父在搬移后过期，需新鲜 walk 复活）会漏到下一次调用——
    // 外层重跑到不动点（上限防乒乓；真实语料 1-2 轮清零，javaparser 6 个
    // 幂等失败文件抓获：const_method_inline/if_else_empty 二轮仍有编辑）
    for _cycle in 0..6 {
        let mut round = Report::default();
        collect_unit_consts(ast, unit);
        // no-op 调用清理表（--dead-code 门控）：off 时清空——规则查询
        // 空表自然不触发
        if cfg.remove_dead_methods {
            collect_noop_private_methods(ast, unit);
        } else {
            ast.noop_private_methods.clear();
        }
        for ty in &mut unit.types {
            simplify_type(ast, ty, cfg, &mut round);
        }
        if cfg.remove_dead_methods {
            round.edits += remove_dead_private_fields(ast, unit);
            round.edits += remove_dead_private_methods(ast, unit);
            round.edits += remove_unused_imports(ast, unit);
        }
        total.edits += round.edits;
        total.iterations += round.iterations;
        total.discarded += round.discarded;
        for (k, v) in round.by_rule {
            *total.by_rule.entry(k).or_insert(0) += v;
        }
        // 注：确认轮不可省——mega 实测驳回过"零丢弃即不动点"短路：跨轮
        // 编辑的主来源是 collect 表过期（内联/折叠后新常量/新单 return 方法
        // 涌现，重建表后才可见），非引擎丢弃提案的复活。RSS +2-3MB 是
        // 收敛正确性的价格。
        if round.edits == 0 {
            break;
        }
    }
    total
}

// ---------------------------------------------------------------------------
/// 匿名类体（NodeData::New{anon_raw} 原文）里的标识符全集 + 字符串字面量
/// 简单名全集（反射按名查找：MethodHandles.findStatic(X, "putByte", …)）。
/// 死码分析的引用扫描对二者均不可见——IteratorWildcard 抓获：匿名体内
/// 调用的 sideCast/adaptSelf 被删（cannot find symbol）、DomainCombiner
/// import 被删、findStatic("putByte") 目标被删（ExceptionInInitializerError）。
fn collect_anon_and_string_names(
    ast: &JavaAst,
    unit: &CompilationUnit,
) -> std::collections::HashSet<String> {
    let mut out: std::collections::HashSet<String> = Default::default();
    let mut bodies: Vec<JavaId> = Vec::new();
    for_each_type(unit, &mut |ty| collect_member_roots(ty, &mut bodies));
    for root in bodies {
        let mut stack = vec![root];
        while let Some(n) = stack.pop() {
            match ast.data(n) {
                NodeData::New { anon_raw: Some(raw), .. } => {
                    for id in raw.split(|c: char| !c.is_alphanumeric() && c != '_' && c != '$') {
                        if !id.is_empty() {
                            out.insert(id.to_string());
                        }
                    }
                }
                NodeData::Literal(Lit::Str(text)) => {
                    for id in text.split(|c: char| !c.is_alphanumeric() && c != '_' && c != '$') {
                        if !id.is_empty() {
                            out.insert(id.to_string());
                        }
                    }
                }
                _ => {}
            }
            for &c in ast.children(n) {
                stack.push(c);
            }
        }
    }
    out
}

// 死私有方法删除（opt-in，Config::remove_dead_methods）：
// const_method_inline / 解密器还原后残留的 helper 清理。
// 安全域：
//   - 仅 private（private 不可能被外部调用或被子类覆盖）；
//   - 全单元零引用：Call 的 callee 名（Member 名/裸名）与 MethodRef 名，
//     名字匹配不判签名——匹配只会导致"保留"，方向保守；
//     （引用扫描是方法命名空间的完整覆盖：字段名与方法名解析域不相交
//     （bd.java 字段 b 与方法 b 共存）；方法重载撞名但零调用 = 同名
//     任何方法都未被调用，private 者可删——旧字段计数守卫曾误留
//     bd 的 8 个空方法））；
//   - 修饰符串含 @（注解方法，可能是框架入口）→ 保留；
//   - 构造器不删（单例模式 private ctor 是活的）。
// 反射调用无法静态排除 → opt-in 而非默认。
// 传递性死代码：迭代到不动点（删一层后重收集引用）。
// ---------------------------------------------------------------------------

/// **死码分析统一超集扫描**：单元内对「引用扫描不可见域」的全量兜底。
/// 覆盖（第 9 轮 dead-code 全审 761 处悬空的 6 类根因）：
///   - NodeData::Raw 文本（语句级注解 → Raw：guava TypeToken 34 个
///     悬空方法主因）
///   - New{anon_raw} 匿名类体（局部类调用：grpc 15 个方法）
///   - 成员 mods 注解实参（@Method("name") 按名反射 / @MethodSource）
///   - 枚举常量原文（guava CaseFormat 等调用在枚举体）
///   - ForEach 元素类型（import 悬空 383 例）
///   - NewArray 数组类型（import 悬空）
///   - 方法级 ty_params 泛型界（jspecify @Nullable 90 例）
///   - 字符串字面量（反射按名查找）
/// 返回：名字出现集（保守超集——名字出现在任何不可见域即视作引用）
fn collect_all_blind_refs(
    ast: &JavaAst,
    unit: &CompilationUnit,
) -> std::collections::HashSet<String> {
    let mut out: std::collections::HashSet<String> = Default::default();
    let split_into = |text: &str, out: &mut std::collections::HashSet<String>| {
        for id in text.split(|c: char| !c.is_alphanumeric() && c != '_' && c != '$') {
            if !id.is_empty() {
                out.insert(id.to_string());
            }
        }
    };
    // 1) AST 节点层：Raw / anon_raw / 字符串字面量 / ForEach ty / NewArray ty
    let mut bodies: Vec<JavaId> = Vec::new();
    for_each_type(unit, &mut |ty| collect_member_roots(ty, &mut bodies));
    for root in bodies {
        let mut stack = vec![root];
        while let Some(n) = stack.pop() {
            match ast.data(n) {
                NodeData::Raw { text } => split_into(text, &mut out),
                NodeData::New { anon_raw: Some(raw), .. } => split_into(raw, &mut out),
                NodeData::Literal(Lit::Str(text)) => split_into(text, &mut out),
                // ForEach 元素类型（类型名在节点数据不在孩子）
                NodeData::ForEach { ty, .. } => {
                    collect_ty_idents(ty, &mut out);
                }
                // NewArray 数组创建类型
                NodeData::NewArray { ty, .. } => {
                    collect_ty_idents(ty, &mut out);
                }
                // Lambda 显式参数类型（(Map.Entry<K, V> entry) -> ——params_raw
                // 是载荷字符串孩子不走）：auto MoreStreams 抓获——
                // `import java.util.Map` 曾因 lambda 参数类型不可见被误删
                NodeData::Lambda { params_raw } => {
                    split_into(params_raw, &mut out);
                }
                _ => {}
            }
            for &c in ast.children(n) {
                stack.push(c);
            }
        }
    }
    // 1.6) 顶层 raw 区（unit.raws——破损输入的保真残段）：其文本中的
    // 类型/名字引用对一切句法扫描不可见（BuilderSimpleOnRecord 抓获：
    // `<T> {…List<T> l…}` 残段内的 List 曾不可见 → import 误删悬空）
    for r in &unit.raws {
        split_into(r, &mut out);
    }
    // 2) 结构层：成员 mods 注解实参 / 枚举常量原文 / 方法级 ty_params /
    //    record 组件头
    for_each_type(unit, &mut |ty: &TypeDecl| {
        collect_mods_idents_all(&ty.mods, &mut out);
        for e in &ty.enum_constants {
            split_into(e, &mut out);
        }
        split_into(&ty.ty_params, &mut out);
        split_into(&ty.header, &mut out);
        for m in &ty.members {
            match m {
                Member::Method { mods, name, ty_params, params, .. }
                | Member::Constructor { mods, name, ty_params, params, .. } => {
                    collect_mods_idents_all(mods, &mut out);
                    split_into(ty_params, &mut out);
                    for p in params {
                        collect_mods_idents_all(&p.mods, &mut out);
                        collect_ty_idents(&p.ty, &mut out);
                    }
                    // 裸 @MethodSource（无实参）——JUnit5 约定：测试方法自身
                    // 名字即工厂方法名（junit5 BeforeAndAfterSuiteTests /
                    // commons-io IOUtilsTest 抓获：工厂误删运行时
                    // MethodSource 解析失败）
                    if has_bare_methodsource(mods) {
                        out.insert(name.clone());
                    }
                }
                Member::Field { mods, declarators, .. } => {
                    collect_mods_idents_all(mods, &mut out);
                    // 注意：字段**声明名**不进 blind 集（自己删自己永真）
                    let _ = declarators;
                }
                Member::Type(t) => {
                    let _ = t; // for_each_type 已递归
                }
                // @interface 成员整段 Raw（annotation 成员无专用节点）：
                // 其中的类型/常量/方法引用对一切句法扫描不可见
                //（junit5 Timeout 抓获：`TimeUnit unit() default TimeUnit
                // .SECONDS;` 曾使 import java.util.concurrent.TimeUnit
                // 误删悬空 28 文件；AnnoCaller 复现：Raw 体内调用的
                // 私有方法/字段曾误删）
                Member::Raw(text) => {
                    split_into(text, &mut out);
                }
                _ => {}
            }
        }
    });
    out
}

/// mods 全文本切分（含注解实参——@Method(METHOD_NAME) 常量引用 /
/// @MethodSource("name") 按名反射——dubbo MethodConfigTest 34 个
/// 悬空字段主因）。
fn collect_mods_idents_all(mods: &str, out: &mut std::collections::HashSet<String>) {
    for id in mods.split(|c: char| !c.is_alphanumeric() && c != '_' && c != '$') {
        if !id.is_empty() {
            out.insert(id.to_string());
        }
    }
}

/// mods 中是否出现**裸** `@MethodSource`（注解名后不接 `(`——简单名或
/// 全限定名均可：`@MethodSource` / `@org.junit.jupiter.params.provider
/// .MethodSource`）。
/// JUnit5 约定：无实参的 @MethodSource 按测试方法自身名字解析工厂——
/// 该名字必须按「已引用」处理（具名实参 `@MethodSource("name")` 的
/// 名字已由 mods 切分覆盖）。
fn has_bare_methodsource(mods: &str) -> bool {
    let hay = mods.as_bytes();
    const NEEDLE: &[u8] = b"MethodSource";
    let mut i = 0usize;
    while let Some(p) = mods[i..].find("MethodSource") {
        let at = i + p;
        let end = at + NEEDLE.len();
        // 前驱须为 @ 或 .（排除 MyMethodSource 类内嵌匹配）；
        // 后继不得是标识符续字符（排除后缀内嵌）
        let prev_ok = at == 0
            || !(hay[at - 1].is_ascii_alphanumeric()
                || hay[at - 1] == b'_'
                || hay[at - 1] == b'$');
        let next_ident =
            end < hay.len() && (hay[end].is_ascii_alphanumeric() || hay[end] == b'_' || hay[end] == b'$');
        if prev_ok && !next_ident {
            let mut j = end;
            while j < hay.len() && hay[j].is_ascii_whitespace() {
                j += 1;
            }
            if j >= hay.len() || hay[j] != b'(' {
                return true;
            }
        }
        i = end;
    }
    false
}

/// JVM/库按名反射调用的回调方法（序列化机制等）——零句法调用者是
/// 正常形态，删除即语义破坏（IteratorWildcard 抓获：writeObject 删除
/// 失去串行化同步与权限预检）。
const REFLECTIVE_MAGIC_METHODS: &[&str] = &[
    "writeObject",
    "readObject",
    "readObjectNoData",
    "writeReplace",
    "readResolve",
    "validateObject",
];

fn remove_dead_private_methods(ast: &JavaAst, unit: &mut CompilationUnit) -> usize {
    use std::collections::HashSet;
    let mut removed = 0usize;
    // 匿名类体/字符串字面量中出现的名字（引用扫描不可见域）
    let anon_names = collect_anon_and_string_names(ast, unit);
    // **超集盲扫**：Raw 文本/枚举体/注解实参/局部类等对句法引用扫描
    // 不可见的域（第 9 轮全审 34 个悬空方法的 6 类根因——guava
    // TypeToken 的 @SuppressWarnings 局部声明、grpc 局部类体、
    // rocketmq record 变量名、guava 枚举常量体调用）
    let blind = collect_all_blind_refs(ast, unit);
    loop {
        // 1) 全单元引用（不可变借用阶段）：(名字, 实参个数) 精确到元数
        //    （非 varargs 下元数=形参数是过载解析的硬约束——bd.java 的
        //    public b(String)/b(String,Class,Class[]) 与 private 空
        //    b(Hashtable,MessageDigest) 同名不同元数可分离）；
        //    MethodRef（this::m）与同名 varargs 方法 → 元数不可判定，
        //    名字整体否决。
        let mut referenced: HashSet<(String, usize)> = HashSet::new();
        let mut veto: HashSet<String> = HashSet::new();
        let mut roots: Vec<JavaId> = Vec::new();
        for_each_type(unit, &mut |ty| collect_member_roots(ty, &mut roots));
        for body in roots {
            collect_call_arity_refs(ast, body, &mut referenced, &mut veto);
        }
        for_each_type(unit, &mut |ty| {
            for m in &ty.members {
                if let Member::Method { name, params, .. } = m {
                    if params.iter().any(|p| p.varargs) {
                        veto.insert(name.clone());
                    }
                }
            }
        });
        // 2) 删除（可变借用阶段）
        let mut changed = false;
        for_each_type_mut(unit, &mut |ty: &mut TypeDecl| {
            let before = ty.members.len();
            ty.members.retain(|m| {
                if let Member::Method { mods, name, params, .. } = m {
                    let is_private = mods.split_whitespace().any(|w| w == "private");
                    let annotated = mods.contains('@');
                    let keep = !is_private
                        || annotated
                        // 自身 varargs：元数匹配不可靠 → 保留
                        || params.iter().any(|p| p.varargs)
                        || veto.contains(name)
                        // 序列化等机制按名反射调用（无句法调用者是正常
                        // 形态）；名字出现在字符串字面量（findStatic/
                        // getMethod 按名查找）或匿名类体 → 保守保留
                        || REFLECTIVE_MAGIC_METHODS.contains(&name.as_str())
                        || anon_names.contains(name)
                        || blind.contains(name)
                        || referenced.contains(&(name.clone(), params.len()));
                    keep
                } else {
                    true
                }
            });
            if ty.members.len() != before {
                removed += before - ty.members.len();
                changed = true;
            }
        });
        if !changed {
            return removed;
        }
    }
}

/// 剥离 callee/MethodRef 名里的前导类型实参（witness 保留把
/// `<String>pick` 整体并入 Member 名——第 11 轮攻击抓获：死码裸名
/// 精确匹配失明 → 私有方法误删输出不可编译）。名字以 `<` 开头必为
/// TA 前缀（标识符/`class`/`new` 等形态不可能以 `<` 开头）。
fn strip_ta_prefix(name: &str) -> &str {
    if !name.starts_with('<') {
        return name;
    }
    let b = name.as_bytes();
    let mut depth = 0i32;
    for (i, &c) in b.iter().enumerate() {
        match c {
            b'<' => depth += 1,
            b'>' => {
                depth -= 1;
                if depth == 0 {
                    return &name[i + 1..];
                }
            }
            _ => {}
        }
    }
    name // 不平衡（病态）——原样保守
}

/// (名字, 实参元数) 引用 + MethodRef/未知元数名字否决。
fn collect_call_arity_refs(
    ast: &JavaAst,
    root: JavaId,
    out: &mut std::collections::HashSet<(String, usize)>,
    veto: &mut std::collections::HashSet<String>,
) {
    let mut stack = vec![root];
    while let Some(id) = stack.pop() {
        match ast.data(id) {
            NodeData::Call => {
                let ch = ast.children(id).to_vec();
                if let Some(&callee) = ch.first() {
                    let name = match ast.data(callee) {
                        NodeData::Member { name } | NodeData::VarRef { name } => {
                            ast.sn(*name).to_string()
                        }
                        _ => String::new(),
                    };
                    if !name.is_empty() {
                        out.insert((strip_ta_prefix(&name).to_string(), ch.len() - 1));
                    }
                }
            }
            NodeData::MethodRef { name } => {
                if let Some(short) = ast.sn(*name).rsplit("::").next() {
                    veto.insert(strip_ta_prefix(short).to_string());
                }
            }
            _ => {}
        }
        for &c in ast.children(id) {
            stack.push(c);
        }
    }
}

/// 递归访问（含嵌套类型），只读。
fn for_each_type(unit: &CompilationUnit, f: &mut dyn FnMut(&TypeDecl)) {
    for ty in &unit.types {
        for_each_type_inner(ty, f);
    }
}
fn for_each_type_inner(ty: &TypeDecl, f: &mut dyn FnMut(&TypeDecl)) {
    f(ty);
    for m in &ty.members {
        if let Member::Type(t) = m {
            for_each_type_inner(t, f);
        }
    }
}

/// 递归访问（含嵌套类型），可变。
fn for_each_type_mut(unit: &mut CompilationUnit, f: &mut dyn FnMut(&mut TypeDecl)) {
    for ty in &mut unit.types {
        for_each_type_mut_inner(ty, f);
    }
}
fn for_each_type_mut_inner(ty: &mut TypeDecl, f: &mut dyn FnMut(&mut TypeDecl)) {
    f(ty);
    for m in &mut ty.members {
        if let Member::Type(t) = m {
            for_each_type_mut_inner(t, f);
        }
    }
}

/// 汇集一个类型所有可走子树的根（方法体/初始化块/字段初始化器）。
fn collect_member_roots(ty: &TypeDecl, out: &mut Vec<JavaId>) {
    for m in &ty.members {
        match m {
            Member::Method { body: Some(b), .. }
            | Member::Constructor { body: Some(b), .. } => out.push(*b),
            Member::Initializer { body, .. } => out.push(*body),
            Member::Field { declarators, .. } => {
                for d in declarators {
                    if let Some(init) = d.init {
                        out.push(init);
                    }
                }
            }
            Member::Type(t) => collect_member_roots(t, out),
            _ => {}
        }
    }
}

/// 子树内收集所有"被调用"的名字：Call 的 callee（Member 名 / 裸 VarRef 名）
/// 与 MethodRef 名（`recv::name`）。名字匹配，不判签名。
// ---------------------------------------------------------------------------
// 空私有方法 no-op 调用清理 + 死私有字段删除（均 opt-in，--dead-code）
// 与 remove_dead_private_methods 同一风险域（反射无法静态排除）。
// ---------------------------------------------------------------------------

/// 收集同名同元数方法候选（名字 → 元数 → 候选表）。
/// 资格（全单元递归）：
///   - 修饰符串含 @（注解框架入口）→ 名字一票否决；
///   - varargs（可吸收任意元数调用）→ 名字一票否决；
///   - 候选按 (private && 空体) 标记 noop——调用点做类型适用性消解后
///     唯一适用且 noop 才删（bd.java：public c(Class, String) 与
///     private c(Hashtable, MessageDigest) 同元数，实参类型消解分离）。
fn collect_noop_private_methods(ast: &mut JavaAst, unit: &CompilationUnit) {
    use std::collections::{HashMap, HashSet};
    ast.noop_private_methods.clear();
    let mut by_name: HashMap<String, HashMap<usize, Vec<NoopCandidate>>> = HashMap::new();
    let mut veto: HashSet<String> = HashSet::new();
    for_each_type(unit, &mut |ty: &TypeDecl| {
        for m in &ty.members {
            if let Member::Method { mods, name, params, body, throws, .. } = m {
                if mods.contains('@') || params.iter().any(|p| p.varargs) {
                    veto.insert(name.clone());
                    continue;
                }
                let is_private = mods.split_whitespace().any(|w| w == "private");
                let empty = match body {
                    Some(b) => ast.kind(*b) == NodeKind::Block && ast.children(*b).is_empty(),
                    None => false,
                };
                // throws 非空：删除调用会使外层 catch 失去「异常可在 try
                // 体内抛出」的编译依据（InputAstRegressionManyAlternatives
                // 抓获：删 foo1() 后 catch(SQLException) 变编译错误）
                let no_throws = throws.is_empty();
                let cand = NoopCandidate {
                    params: params.iter().map(|p| p.ty.clone()).collect(),
                    noop: is_private && empty && no_throws,
                };
                by_name
                    .entry(name.clone())
                    .or_default()
                    .entry(params.len())
                    .or_default()
                    .push(cand);
            }
        }
    });
    // 超集盲扫否决（Raw 文本/枚举体/注解实参里的方法名引用——
    // no-op 删除后这些域的调用会悬空）
    let blind = collect_all_blind_refs(ast, unit);
    // MethodRef（this::m / A::m）：绑定元数不可判定 → 名字否决
    //（否则 no-op 调用删除先行，引用悬空）
    let mut roots: Vec<JavaId> = Vec::new();
    for_each_type(unit, &mut |ty| collect_member_roots(ty, &mut roots));
    for root in roots {
        let mut stack = vec![root];
        while let Some(n) = stack.pop() {
            if let NodeData::MethodRef { name } = ast.data(n) {
                if let Some(short) = ast.sn(*name).rsplit("::").next() {
                    veto.insert(strip_ta_prefix(short).to_string());
                }
            }
            for &c in ast.children(n) {
                stack.push(c);
            }
        }
    }
    for (name, arities) in by_name {
        if veto.contains(&name) || blind.contains(&name) {
            continue;
        }
        ast.noop_private_methods.insert(name, arities);
    }
}

/// 未用单类型 import 清理（--dead-code 收尾）：简单名在全单元标识符
/// 集合（AST 名字/类型 + 结构字符串含泛型实参）中零出现 → 删。
/// on-demand（.*）/ static import 保守保留；误删只会在标识符收集
/// 漏形式时发生——方向上宁可多保留。
fn remove_unused_imports(ast: &JavaAst, unit: &mut CompilationUnit) -> usize {
    use std::collections::HashSet;
    let mut idents: HashSet<String> = HashSet::new();
    // 1) AST 载荷标识符（名字 + 类型 + Raw 原文）
    let mut roots: Vec<JavaId> = Vec::new();
    for_each_type(unit, &mut |ty| collect_member_roots(ty, &mut roots));
    for root in roots {
        let mut stack = vec![root];
        while let Some(n) = stack.pop() {
            match ast.data(n) {
                NodeData::VarDecl { name, ty, .. } => {
                    idents.insert(name.clone());
                    collect_ty_idents(ty, &mut idents);
                }
                NodeData::VarRef { name } => {
                    // 表达式里的 Foo.class 是单个 VarRef（名字="Foo.class"
                    // 整串）——按分隔符切出类型名（v.java List.class 抓获：
                    // import 误删）
                    let n = ast.sn(*name);
                    for id in n.split(|c: char| !c.is_alphanumeric() && c != '_' && c != '$') {
                        if !id.is_empty() {
                            idents.insert(id.to_string());
                        }
                    }
                }
                NodeData::Member { name } => {
                    idents.insert(ast.sn(*name).to_string());
                }
                NodeData::MethodRef { name } => {
                    let n = ast.sn(*name);
                    for id in n.split(|c: char| !c.is_alphanumeric() && c != '_' && c != '$') {
                        if !id.is_empty() {
                            idents.insert(id.to_string());
                        }
                    }
                }
                NodeData::Label { name } => {
                    idents.insert(name.clone());
                }
                NodeData::New { ty, anon_raw, .. } => {
                    collect_ty_idents(ty, &mut idents);
                    // 匿名类体原文：其中的类型/名字引用对 AST 扫描不可见
                    //（IteratorWildcard 抓获：DomainCombiner import 误删）
                    if let Some(raw) = anon_raw {
                        for id in
                            raw.split(|c: char| !c.is_alphanumeric() && c != '_' && c != '$')
                        {
                            if !id.is_empty() {
                                idents.insert(id.to_string());
                            }
                        }
                    }
                }
                NodeData::Cast { ty } => {
                    collect_ty_idents(ty, &mut idents);
                }
                NodeData::InstanceOf { ty, .. } => {
                    collect_ty_idents(ty, &mut idents);
                }
                NodeData::Catch { ty_raw, .. } => {
                    // catch (Type name)——异常类型原文
                    for id in
                        ty_raw.split(|c: char| !c.is_alphanumeric() && c != '_' && c != '$')
                    {
                        if !id.is_empty() {
                            idents.insert(id.to_string());
                        }
                    }
                }
                NodeData::Raw { text } => {
                    for id in text.split(|c: char| !c.is_alphanumeric() && c != '_' && c != '$') {
                        if !id.is_empty() {
                            idents.insert(id.to_string());
                        }
                    }
                }
                _ => {}
            }
            for &c in ast.children(n) {
                stack.push(c);
            }
        }
    }
    // 1.5) 超集盲扫（Raw/枚举体/注解实参/ForEach ty/NewArray ty/
    //      方法级 ty_params——657 个悬空 import 的根因。idents 是
    //      「使用的名字」超集方向，直接并入）
    for name in collect_all_blind_refs(ast, unit) {
        idents.insert(name);
    }
    // 1.6) 顶层 raw 区（unit.raws）：残段文本中的类型引用（同上——
    // 曾不可见使 List 误删）
    for r in &unit.raws {
        for id in r.split(|c: char| !c.is_alphanumeric() && c != '_' && c != '$') {
            if !id.is_empty() {
                idents.insert(id.to_string());
            }
        }
    }
    // 2) 结构字符串（mods/注解原文、泛型参数、extends/implements/throws、
    //    方法/类型名——字段/参数/返回类型）
    for_each_type(unit, &mut |ty| {
        collect_mods_idents(&ty.mods, &mut idents);
        idents.insert(ty.name.clone());
        for id in ty.ty_params.split(|c: char| !c.is_alphanumeric() && c != '_' && c != '$') {
            if !id.is_empty() {
                idents.insert(id.to_string());
            }
        }
        // record 组件头原文 `(MouseEvent e, @Anno Comparator<X> c)`——
        // 组件类型对 AST 扫描不可见（InputJavadocMethodScopeAnonInner
        // 抓获：MouseEvent import 误删）
        for id in ty.header.split(|c: char| !c.is_alphanumeric() && c != '_' && c != '$') {
            if !id.is_empty() {
                idents.insert(id.to_string());
            }
        }
        for e in ty.extends.iter().chain(ty.implements.iter()) {
            for id in e.split(|c: char| !c.is_alphanumeric() && c != '_' && c != '$') {
                if !id.is_empty() {
                    idents.insert(id.to_string());
                }
            }
        }
        for m in &ty.members {
            match m {
                Member::Field { mods, ty, declarators } => {
                    collect_mods_idents(mods, &mut idents);
                    collect_ty_idents(ty, &mut idents);
                    for d in declarators {
                        idents.insert(d.name.clone());
                    }
                }
                Member::Method { mods, ret, name, params, throws, .. } => {
                    collect_mods_idents(mods, &mut idents);
                    collect_ty_idents(ret, &mut idents);
                    idents.insert(name.clone());
                    for p in params {
                        collect_mods_idents(&p.mods, &mut idents);
                        collect_ty_idents(&p.ty, &mut idents);
                        idents.insert(p.name.clone());
                    }
                    for t in throws {
                        for id in t.split(|c: char| !c.is_alphanumeric() && c != '_' && c != '$') {
                            if !id.is_empty() {
                                idents.insert(id.to_string());
                            }
                        }
                    }
                }
                Member::Constructor { mods, name, params, throws, .. } => {
                    collect_mods_idents(mods, &mut idents);
                    idents.insert(name.clone());
                    for p in params {
                        collect_mods_idents(&p.mods, &mut idents);
                        collect_ty_idents(&p.ty, &mut idents);
                        idents.insert(p.name.clone());
                    }
                    for t in throws {
                        for id in t.split(|c: char| !c.is_alphanumeric() && c != '_' && c != '$') {
                            if !id.is_empty() {
                                idents.insert(id.to_string());
                            }
                        }
                    }
                }
                Member::Type(t) => {
                    // 嵌套类型递归（for_each_type 已递归——这里不重复）
                    let _ = t;
                }
                _ => {}
            }
        }
    });
    // 3) 保留判定
    let before = unit.imports.len();
    unit.imports.retain(|imp| {
        if imp.contains('*') {
            return true; // on-demand 无法证明
        }
        // static import 的简单名可能是方法名（VarRef 收集覆盖），同规则处理
        let path = imp.trim_start_matches("static ").trim();
        let simple = path.rsplit('.').next().unwrap_or(path).trim();
        if simple.is_empty() || !simple.chars().next().is_some_and(|c| c.is_uppercase()) {
            return true; // 非类型形态（方法/常量 static import 简单名小写起）→ 保守保留
        }
        idents.contains(simple)
    });
    before - unit.imports.len()
}

fn collect_ty_idents(t: &JType, out: &mut std::collections::HashSet<String>) {
    match t {
        JType::Ref(r) => {
            for id in r.split(|c: char| !c.is_alphanumeric() && c != '_' && c != '$') {
                if !id.is_empty() {
                    out.insert(id.to_string());
                }
            }
        }
        JType::Array(inner) => collect_ty_idents(inner, out),
        _ => {}
    }
}

fn collect_mods_idents(mods: &str, out: &mut std::collections::HashSet<String>) {
    // 注解原文（@SuppressWarnings(...)）——含参数里的类名引用
    if mods.contains('@') {
        for id in mods.split(|c: char| !c.is_alphanumeric() && c != '_' && c != '$') {
            if !id.is_empty() {
                out.insert(id.to_string());
            }
        }
    }
}

/// 死私有字段删除：名字在全单元所有体内零值引用（VarRef 非 callee 位置
/// + Member 名）→ 删声明符；字段的声明符 init 必须是字面量/字面量数组
/// 或缺省（有副作用的 init 删不得——静态初始化顺序是可观察行为）。
/// 命名空间隔离：Call 的 callee VarRef 是方法名不是字段名（bd.java 的
/// 字段 e 与空方法 e 共存）；this.e / A.e 的成员名也计入引用。
fn remove_dead_private_fields(ast: &JavaAst, unit: &mut CompilationUnit) -> usize {
    use std::collections::HashSet;
    let mut removed = 0usize;
    // 匿名类体/字符串字面量名字（引用扫描不可见）
    let anon_names = collect_anon_and_string_names(ast, unit);
    // 超集盲扫（68 个悬空字段根因：mods 注解实参 @Method(METHOD_NAME)、
    // 枚举体 .add(SHORT_NAME)、Raw 文本局部类）
    let blind = collect_all_blind_refs(ast, unit);
    // 1) 全单元字段名引用（值位置）
    let mut referenced: HashSet<String> = HashSet::new();
    let mut bodies: Vec<JavaId> = Vec::new();
    for_each_type(unit, &mut |ty: &TypeDecl| {
        for m in &ty.members {
            match m {
                Member::Method { body: Some(b), .. }
                | Member::Constructor { body: Some(b), .. }
                | Member::Initializer { body: b, .. } => bodies.push(*b),
                Member::Field { declarators, .. } => {
                    for d in declarators {
                        if let Some(init) = d.init {
                            bodies.push(init);
                        }
                    }
                }
                _ => {}
            }
        }
    });
    for root in bodies {
        // 栈携带 (节点, 是否为 Call 的 callee——方法命名空间，跳过)
        let mut stack: Vec<(JavaId, bool)> = vec![(root, false)];
        while let Some((n, is_callee)) = stack.pop() {
            match ast.kind(n) {
                NodeKind::VarRef if !is_callee => {
                    if let Some(nm) = ast.var_name(n) {
                        referenced.insert(nm.to_string());
                    }
                }
                NodeKind::Member => {
                    if let NodeData::Member { name: sym } = ast.data(n) {
                        referenced.insert(ast.sn(*sym).to_string());
                    }
                }
                _ => {}
            }
            if ast.kind(n) == NodeKind::Call {
                let ch = ast.children(n).to_vec();
                if let Some(&first) = ch.first() {
                    stack.push((first, true));
                }
                for &c in &ch[1..] {
                    stack.push((c, false));
                }
                continue;
            }
            for &c in ast.children(n) {
                stack.push((c, false));
            }
        }
    }
    // 2) 删除（可变借用阶段；嵌套类型递归）：
    //    先逐成员清理声明符（字面量 init 或无 init 且零引用），再删空成员。
    //    serialVersionUID / serialPersistentFields 是 JVM 序列化按名反射
    //    读取的契约字段——「零源码引用」判据不适用（a9/a_ 抓获：删除后
    //    SUID 退化为结构计算值，旧流反序列化 InvalidClassException）
    for_each_type_mut(unit, &mut |ty: &mut TypeDecl| {
        for m in ty.members.iter_mut() {
            if let Member::Field { mods, declarators, .. } = m {
                let is_private = mods.split_whitespace().any(|w| w == "private");
                let annotated = mods.contains('@');
                if !is_private || annotated {
                    continue;
                }
                let dead: Vec<bool> = declarators
                    .iter()
                    .map(|d| {
                        let reflective =
                            d.name == "serialVersionUID" || d.name == "serialPersistentFields";
                        let init_ok =
                            d.init.map(|i| is_const_init(ast, i)).unwrap_or(true);
                        !reflective
                            && init_ok
                            && !referenced.contains(&d.name)
                            && !anon_names.contains(&d.name)
                            && !blind.contains(&d.name)
                    })
                    .collect();
                let before = declarators.len();
                let mut idx = 0usize;
                declarators.retain(|_| {
                    let keep = !dead[idx];
                    idx += 1;
                    keep
                });
                removed += before - declarators.len();
            }
        }
        let before = ty.members.len();
        ty.members
            .retain(|m| !matches!(m, Member::Field { declarators, .. } if declarators.is_empty()));
        removed += before - ty.members.len();
    });
    removed
}

fn simplify_type(ast: &mut JavaAst, ty: &mut TypeDecl, cfg: &Config, total: &mut Report) {
    for m in &mut ty.members {
        simplify_member(ast, m, cfg, total);
    }
}

fn simplify_member(ast: &mut JavaAst, m: &mut Member, cfg: &Config, total: &mut Report) {
    // 方法参数进入作用域基表，供类型解析使用
    let params: Vec<(String, JType)> = match m {
        Member::Method { params, .. } | Member::Constructor { params, .. } => params
            .iter()
            .map(|p| (p.name.clone(), p.ty.clone()))
            .collect(),
        _ => Vec::new(),
    };
    ast.set_param_scope(&params);
    match m {
        Member::Method { body: Some(b), .. }
        | Member::Constructor { body: Some(b), .. } => {
            let r = simplify(ast, *b, cfg);
            merge_report(total, r);
        }
        Member::Initializer { body, .. } => {
            let r = simplify(ast, *body, cfg);
            merge_report(total, r);
        }
        Member::Field { declarators, .. } => {
            for d in declarators.iter_mut() {
                if let Some(init) = d.init {
                    let r = simplify(ast, init, cfg);
                    merge_report(total, r);
                    // 根折叠：字段 init 节点就是 walk 根——Replace 无父
                    // 槽可写（引擎既有边界），由本侧拿到新根回写声明
                    //（static int x=1+2 曾永不折——本轮修复）
                    let rules = default_java_rules();
                    let mut cur: JavaId = init;
                    for _ in 0..8 {
                        match cure_engine::fold_root(ast, cur, &rules, cfg) {
                            Some((new_root, name)) => {
                                d.init = Some(new_root);
                                cur = new_root;
                                *total.by_rule.entry(name).or_insert(0) += 1;
                                total.edits += 1;
                                // 新根内部可能再折
                                let r = simplify(ast, new_root, cfg);
                                merge_report(total, r);
                            }
                            None => break,
                        }
                    }
                }
            }
        }
        Member::Type(t) => simplify_type(ast, t, cfg, total),
        Member::Raw(_) => {}
        _ => {}
    }
}

fn merge_report(total: &mut Report, r: Report) {
    total.edits += r.edits;
    total.iterations += r.iterations;
    for (k, v) in r.by_rule {
        *total.by_rule.entry(k).or_insert(0) += v;
    }
}

/// 默认配置。
pub fn default_config() -> Config {
    Config::default()
}