neo-decompiler 0.10.1

use super::*;

use crate::decompiler::analysis::call_graph::CallTarget;
use crate::instruction::OpCode;

#[test]
fn call_graph_includes_direct_calla_targets_as_methods() {
    let nef_bytes = build_nef(&[
        OpCode::PushA.byte(),
        0x07,
        0x00,
        0x00,
        0x00,                 // PUSHA +7 -> target at 0x0007
        OpCode::CallA.byte(), // CALLA
        OpCode::Ret.byte(),   // RET
        OpCode::Syscall.byte(),
        0xB7,
        0xC3,
        0x88,
        0x03,               // SYSCALL System.Runtime.GetTime
        OpCode::Ret.byte(), // RET
    ]);
    let decompilation = Decompiler::new()
        .decompile_bytes_with_manifest(&nef_bytes, None, OutputFormat::Pseudocode)
        .expect("decompile succeeds");

    assert!(
        decompilation
            .call_graph
            .methods
            .iter()
            .any(|method| method.offset == 0x0007),
        "resolved CALLA target must be listed as a method: {:?}",
        decompilation.call_graph.methods
    );

    let calla = decompilation
        .call_graph
        .edges
        .iter()
        .find(|edge| edge.opcode == "CALLA")
        .expect("CALLA edge present");
    match &calla.target {
        CallTarget::Internal { method } => assert_eq!(method.offset, 0x0007),
        other => panic!("CALLA target should be internal, got {other:?}"),
    }

    let syscall = decompilation
        .call_graph
        .edges
        .iter()
        .find(|edge| edge.opcode == "SYSCALL")
        .expect("SYSCALL edge present");
    assert_eq!(syscall.caller.offset, 0x0007);
}

#[test]
fn call_graph_attributes_helper_syscall_to_inferred_helper_method() {
    // Script layout:
    // 0x0000: CALL +4 (target=0x0004)
    // 0x0002: RET
    // 0x0003: NOP
    // 0x0004: SYSCALL System.Runtime.GetTime
    // 0x0009: RET
    let script = [
        OpCode::Call.byte(),
        0x04,               // CALL +4
        OpCode::Ret.byte(), // RET
        OpCode::Nop.byte(), // NOP
        OpCode::Syscall.byte(),
        0xB7,
        0xC3,
        0x88,
        0x03,               // SYSCALL 0x0388C3B7
        OpCode::Ret.byte(), // RET
    ];
    let nef_bytes = build_nef(&script);
    let decompilation = Decompiler::new()
        .decompile_bytes_with_manifest(&nef_bytes, None, OutputFormat::Pseudocode)
        .expect("decompile succeeds");

    assert_eq!(decompilation.call_graph.edges.len(), 2);
    let helper_edge = decompilation
        .call_graph
        .edges
        .iter()
        .find(|edge| edge.opcode == "SYSCALL")
        .expect("helper syscall edge");
    assert_eq!(helper_edge.call_offset, 4);
    assert_eq!(helper_edge.caller.offset, 4);
    assert_eq!(helper_edge.caller.name, "sub_0x0004");
}

#[test]
fn call_graph_attributes_pusha_calla_helper_syscall_to_inferred_helper_method() {
    // Script layout:
    // 0x0000: PUSHA +8 (target=0x0008)
    // 0x0005: CALLA
    // 0x0006: RET
    // 0x0007: NOP
    // 0x0008: SYSCALL System.Runtime.GetTime
    // 0x000D: RET
    let script = [
        OpCode::PushA.byte(),
        0x08,
        0x00,
        0x00,
        0x00,                 // PUSHA +8
        OpCode::CallA.byte(), // CALLA
        OpCode::Ret.byte(),   // RET
        OpCode::Nop.byte(),   // NOP
        OpCode::Syscall.byte(),
        0xB7,
        0xC3,
        0x88,
        0x03,               // SYSCALL 0x0388C3B7
        OpCode::Ret.byte(), // RET
    ];
    let nef_bytes = build_nef(&script);
    let decompilation = Decompiler::new()
        .decompile_bytes_with_manifest(&nef_bytes, None, OutputFormat::Pseudocode)
        .expect("decompile succeeds");

    let helper_edge = decompilation
        .call_graph
        .edges
        .iter()
        .find(|edge| edge.opcode == "SYSCALL")
        .expect("helper syscall edge");
    assert_eq!(helper_edge.call_offset, 8);
    assert_eq!(helper_edge.caller.offset, 8);
    assert_eq!(helper_edge.caller.name, "sub_0x0008");
}

#[test]
fn call_graph_attributes_ldarg_calla_helper_syscall_to_inferred_helper_method() {
    // Script layout:
    // 0x0000: PUSHA +15 (target=0x000F)
    // 0x0005: CALL +4 (target=0x0009)
    // 0x0007: RET
    // 0x0008: NOP
    // 0x0009: INITSLOT 0,1
    // 0x000C: LDARG0
    // 0x000D: CALLA
    // 0x000E: RET
    // 0x000F: SYSCALL System.Runtime.GetTime
    // 0x0014: RET
    let script = [
        OpCode::PushA.byte(),
        0x0F,
        0x00,
        0x00,
        0x00, // PUSHA +15
        OpCode::Call.byte(),
        0x04,               // CALL +4
        OpCode::Ret.byte(), // RET
        OpCode::Nop.byte(), // NOP
        OpCode::Initslot.byte(),
        0x00,
        0x01,                  // INITSLOT 0,1
        OpCode::Ldarg0.byte(), // LDARG0
        OpCode::CallA.byte(),  // CALLA
        OpCode::Ret.byte(),    // RET
        OpCode::Syscall.byte(),
        0xB7,
        0xC3,
        0x88,
        0x03,               // SYSCALL 0x0388C3B7
        OpCode::Ret.byte(), // RET
    ];
    let nef_bytes = build_nef(&script);
    let decompilation = Decompiler::new()
        .decompile_bytes_with_manifest(&nef_bytes, None, OutputFormat::Pseudocode)
        .expect("decompile succeeds");

    let helper_edge = decompilation
        .call_graph
        .edges
        .iter()
        .find(|edge| edge.opcode == "SYSCALL")
        .expect("helper syscall edge");
    assert_eq!(helper_edge.call_offset, 0x000F);
    assert_eq!(helper_edge.caller.offset, 0x000F);
    assert_eq!(helper_edge.caller.name, "sub_0x000F");
}

#[test]
fn call_graph_attributes_ldloc_from_argument_calla_helper_syscall_to_inferred_helper_method() {
    // Script layout:
    // 0x0000: PUSHA +17 (target=0x0011)
    // 0x0005: CALL +4 (target=0x0009)
    // 0x0007: RET
    // 0x0008: NOP
    // 0x0009: INITSLOT 1,1
    // 0x000C: LDARG0
    // 0x000D: STLOC0
    // 0x000E: LDLOC0
    // 0x000F: CALLA
    // 0x0010: RET
    // 0x0011: SYSCALL System.Runtime.GetTime
    // 0x0016: RET
    let script = [
        OpCode::PushA.byte(),
        0x11,
        0x00,
        0x00,
        0x00, // PUSHA +17
        OpCode::Call.byte(),
        0x04,               // CALL +4
        OpCode::Ret.byte(), // RET
        OpCode::Nop.byte(), // NOP
        OpCode::Initslot.byte(),
        0x01,
        0x01,                  // INITSLOT 1,1
        OpCode::Ldarg0.byte(), // LDARG0
        OpCode::Stloc0.byte(), // STLOC0
        OpCode::Ldloc0.byte(), // LDLOC0
        OpCode::CallA.byte(),  // CALLA
        OpCode::Ret.byte(),    // RET
        OpCode::Syscall.byte(),
        0xB7,
        0xC3,
        0x88,
        0x03,               // SYSCALL 0x0388C3B7
        OpCode::Ret.byte(), // RET
    ];
    let nef_bytes = build_nef(&script);
    let decompilation = Decompiler::new()
        .decompile_bytes_with_manifest(&nef_bytes, None, OutputFormat::Pseudocode)
        .expect("decompile succeeds");

    let helper_edge = decompilation
        .call_graph
        .edges
        .iter()
        .find(|edge| edge.opcode == "SYSCALL")
        .expect("helper syscall edge");
    assert_eq!(helper_edge.call_offset, 0x0011);
    assert_eq!(helper_edge.caller.offset, 0x0011);
    assert_eq!(helper_edge.caller.name, "sub_0x0011");
}

#[test]
fn call_graph_resolves_nested_pusha_argument_through_calla_helper() {
    // Script layout:
    // 0x0000: PUSHA +18 (target = 0x0012)  // helper2 pointer argument
    // 0x0005: PUSHA +7  (target = 0x000C)  // helper1 callee
    // 0x000A: CALLA
    // 0x000B: RET
    // 0x000C: INITSLOT 0,1
    // 0x000F: LDARG0
    // 0x0010: CALLA
    // 0x0011: RET
    // 0x0012: SYSCALL System.Runtime.GetTime
    // 0x0017: RET
    let script = [
        OpCode::PushA.byte(),
        0x12,
        0x00,
        0x00,
        0x00, // PUSHA +18
        OpCode::PushA.byte(),
        0x07,
        0x00,
        0x00,
        0x00,                 // PUSHA +7
        OpCode::CallA.byte(), // CALLA
        OpCode::Ret.byte(),   // RET
        OpCode::Initslot.byte(),
        0x00,
        0x01,                  // INITSLOT 0,1
        OpCode::Ldarg0.byte(), // LDARG0
        OpCode::CallA.byte(),  // CALLA
        OpCode::Ret.byte(),    // RET
        OpCode::Syscall.byte(),
        0xB7,
        0xC3,
        0x88,
        0x03,               // SYSCALL 0x0388C3B7
        OpCode::Ret.byte(), // RET
    ];
    let nef_bytes = build_nef(&script);
    let decompilation = Decompiler::new()
        .decompile_bytes_with_manifest(&nef_bytes, None, OutputFormat::Pseudocode)
        .expect("decompile succeeds");

    let nested_calla = decompilation
        .call_graph
        .edges
        .iter()
        .find(|edge| edge.opcode == "CALLA" && edge.call_offset == 0x0010)
        .expect("nested CALLA edge present");
    match &nested_calla.target {
        CallTarget::Internal { method } => {
            assert_eq!(method.offset, 0x0012);
            assert_eq!(method.name, "sub_0x0012");
        }
        other => panic!("expected nested CALLA to resolve helper target, got: {other:?}"),
    }

    let helper_edge = decompilation
        .call_graph
        .edges
        .iter()
        .find(|edge| edge.opcode == "SYSCALL")
        .expect("helper syscall edge");
    assert_eq!(helper_edge.call_offset, 0x0012);
    assert_eq!(helper_edge.caller.offset, 0x0012);
    assert_eq!(helper_edge.caller.name, "sub_0x0012");
}

#[test]
fn call_graph_resolves_nested_pusha_argument_through_calla_helper_without_initslot() {
    // Script layout:
    // 0x0000: PUSHA +11 (target = 0x000B) // helper2 pointer argument
    // 0x0005: CALL +3  (target = 0x0008) // helper1 callee, no INITSLOT
    // 0x0007: RET
    // 0x0008: LDARG0
    // 0x0009: CALLA
    // 0x000A: RET
    // 0x000B: SYSCALL System.Runtime.GetTime
    // 0x0010: RET
    let script = [
        OpCode::PushA.byte(),
        0x0B,
        0x00,
        0x00,
        0x00, // PUSHA +11
        OpCode::Call.byte(),
        0x03,                  // CALL +3
        OpCode::Ret.byte(),    // RET
        OpCode::Ldarg0.byte(), // LDARG0
        OpCode::CallA.byte(),  // CALLA
        OpCode::Ret.byte(),    // RET
        OpCode::Syscall.byte(),
        0xB7,
        0xC3,
        0x88,
        0x03,               // SYSCALL 0x0388C3B7
        OpCode::Ret.byte(), // RET
    ];
    let nef_bytes = build_nef(&script);
    let decompilation = Decompiler::new()
        .decompile_bytes_with_manifest(&nef_bytes, None, OutputFormat::Pseudocode)
        .expect("decompile succeeds");

    let nested_calla = decompilation
        .call_graph
        .edges
        .iter()
        .find(|edge| edge.opcode == "CALLA" && edge.call_offset == 0x0009)
        .expect("nested CALLA edge present");
    match &nested_calla.target {
        CallTarget::Internal { method } => {
            assert_eq!(method.offset, 0x000B);
            assert_eq!(method.name, "sub_0x000B");
        }
        other => panic!("expected CALLA without INITSLOT helper to resolve target, got: {other:?}"),
    }
}

#[test]
fn call_graph_resolves_two_level_nested_calla_argument_chain() {
    // Script layout:
    // 0x0000: PUSHA +20 (target = 0x0014) // helper2 pointer
    // 0x0005: PUSHA +21 (target = 0x001A) // helper3 pointer
    // 0x000A: CALL +3  (target = 0x000D) // helper1
    // 0x000C: RET
    // 0x000D: INITSLOT 0,2
    // 0x0010: LDARG0   // helper3
    // 0x0011: LDARG1   // helper2
    // 0x0012: CALLA    // helper2(helper3)
    // 0x0013: RET
    // 0x0014: INITSLOT 0,1
    // 0x0017: LDARG0   // helper3
    // 0x0018: CALLA    // helper3()
    // 0x0019: RET
    // 0x001A: SYSCALL System.Runtime.GetTime
    // 0x001F: RET
    let script = [
        OpCode::PushA.byte(),
        0x14,
        0x00,
        0x00,
        0x00, // PUSHA +20
        OpCode::PushA.byte(),
        0x15,
        0x00,
        0x00,
        0x00, // PUSHA +21
        OpCode::Call.byte(),
        0x03,               // CALL +3
        OpCode::Ret.byte(), // RET
        OpCode::Initslot.byte(),
        0x00,
        0x02,                  // INITSLOT 0,2
        OpCode::Ldarg0.byte(), // LDARG0
        OpCode::Ldarg1.byte(), // LDARG1
        OpCode::CallA.byte(),  // CALLA
        OpCode::Ret.byte(),    // RET
        OpCode::Initslot.byte(),
        0x00,
        0x01,                  // INITSLOT 0,1
        OpCode::Ldarg0.byte(), // LDARG0
        OpCode::CallA.byte(),  // CALLA
        OpCode::Ret.byte(),    // RET
        OpCode::Syscall.byte(),
        0xB7,
        0xC3,
        0x88,
        0x03,               // SYSCALL 0x0388C3B7
        OpCode::Ret.byte(), // RET
    ];
    let nef_bytes = build_nef(&script);
    let decompilation = Decompiler::new()
        .decompile_bytes_with_manifest(&nef_bytes, None, OutputFormat::Pseudocode)
        .expect("decompile succeeds");

    let nested_calla = decompilation
        .call_graph
        .edges
        .iter()
        .find(|edge| edge.opcode == "CALLA" && edge.call_offset == 0x0018)
        .expect("second-level CALLA edge present");
    match &nested_calla.target {
        CallTarget::Internal { method } => {
            assert_eq!(method.offset, 0x001A);
            assert_eq!(method.name, "sub_0x001A");
        }
        other => panic!("expected second-level CALLA to resolve helper target, got: {other:?}"),
    }

    let helper_edge = decompilation
        .call_graph
        .edges
        .iter()
        .find(|edge| edge.opcode == "SYSCALL")
        .expect("helper syscall edge");
    assert_eq!(helper_edge.call_offset, 0x001A);
    assert_eq!(helper_edge.caller.offset, 0x001A);
    assert_eq!(helper_edge.caller.name, "sub_0x001A");
}

#[test]
fn inferred_method_starts_tolerate_malformed_tryl_operand() {
    use crate::instruction::{Instruction, OpCode, Operand};

    let instructions = vec![
        Instruction::new(
            0,
            OpCode::TryL,
            Some(Operand::Bytes(vec![0x01, 0x02, 0x03])),
        ),
        Instruction::new(1, OpCode::Ret, None),
    ];

    let inferred = crate::decompiler::helpers::inferred_method_starts(&instructions, None);
    assert_eq!(inferred, vec![0]);
}

#[test]
fn decompilation_resolves_pickitem_delegate_array_into_calla_edge() {
    // Script layout:
    // 0x0000: NEWARRAY0
    // 0x0001: STLOC0
    // 0x0002: LDLOC0
    // 0x0003: PUSHA +11 (target = 0x000E)
    // 0x0008: APPEND
    // 0x0009: LDLOC0
    // 0x000A: PUSH0
    // 0x000B: PICKITEM
    // 0x000C: CALLA
    // 0x000D: RET
    // 0x000E: INITSLOT 0,0
    // 0x0011: RET
    let script = [
        OpCode::Newarray0.byte(), // NEWARRAY0
        OpCode::Stloc0.byte(),    // STLOC0
        OpCode::Ldloc0.byte(),    // LDLOC0
        OpCode::PushA.byte(),
        0x0B,
        0x00,
        0x00,
        0x00,                    // PUSHA +11
        OpCode::Append.byte(),   // APPEND
        OpCode::Ldloc0.byte(),   // LDLOC0
        OpCode::Push0.byte(),    // PUSH0
        OpCode::Pickitem.byte(), // PICKITEM
        OpCode::CallA.byte(),    // CALLA
        OpCode::Ret.byte(),      // RET
        OpCode::Initslot.byte(),
        0x00,
        0x00,               // INITSLOT 0,0
        OpCode::Ret.byte(), // RET
    ];

    let nef_bytes = build_nef(&script);
    let decompilation = Decompiler::new()
        .decompile_bytes_with_manifest(&nef_bytes, None, OutputFormat::Pseudocode)
        .expect("decompile succeeds");

    let edge = decompilation
        .call_graph
        .edges
        .iter()
        .find(|edge| edge.opcode == "CALLA")
        .expect("CALLA edge present");

    match &edge.target {
        CallTarget::Internal { method } => {
            assert_eq!(method.offset, 0x000E);
            assert_eq!(method.name, "sub_0x000E");
        }
        other => {
            panic!("expected PICKITEM delegate CALLA to resolve helper target, got: {other:?}")
        }
    }
}

#[test]
fn decompilation_resolves_pickitem_delegate_array_through_local_alias() {
    // Script layout:
    // NEWARRAY0; STLOC0
    // LDLOC0; DUP; STLOC1
    // PUSHA +13 (target=0x0012, the INITSLOT helper); APPEND
    // LDLOC1; PUSH0; PICKITEM; STLOC2
    // LDLOC2; CALLA; RET
    // target: INITSLOT 0,0; RET
    let script = [
        OpCode::Newarray0.byte(), // NEWARRAY0
        OpCode::Stloc0.byte(),    // STLOC0
        OpCode::Ldloc0.byte(),    // LDLOC0
        OpCode::Dup.byte(),       // DUP
        OpCode::Stloc1.byte(),    // STLOC1
        OpCode::PushA.byte(),
        0x0D,
        0x00,
        0x00,
        0x00,                    // PUSHA +13 (target=0x0012, a valid in-range helper)
        OpCode::Append.byte(),   // APPEND
        OpCode::Ldloc1.byte(),   // LDLOC1
        OpCode::Push0.byte(),    // PUSH0
        OpCode::Pickitem.byte(), // PICKITEM
        OpCode::Stloc2.byte(),   // STLOC2
        OpCode::Ldloc2.byte(),   // LDLOC2
        OpCode::CallA.byte(),    // CALLA
        OpCode::Ret.byte(),      // RET
        OpCode::Initslot.byte(),
        0x00,
        0x00,               // INITSLOT 0,0
        OpCode::Ret.byte(), // RET
    ];

    let nef_bytes = build_nef(&script);
    let decompilation = Decompiler::new()
        .decompile_bytes_with_manifest(&nef_bytes, None, OutputFormat::Pseudocode)
        .expect("decompile succeeds");

    let edge = decompilation
        .call_graph
        .edges
        .iter()
        .find(|edge| edge.opcode == "CALLA")
        .expect("CALLA edge present");

    match &edge.target {
        CallTarget::Internal { method } => {
            assert_eq!(method.offset, 0x0012);
            assert_eq!(method.name, "sub_0x0012");
        }
        other => {
            panic!("expected aliased delegate-array CALLA to resolve helper target, got: {other:?}")
        }
    }
}

#[test]
fn decompilation_resolves_duplicated_pointer_into_calla_edge() {
    // Script layout:
    // 0x0000: PUSHA +8 (target = 0x0008)
    // 0x0005: DUP
    // 0x0006: CALLA
    // 0x0007: RET
    // 0x0008: INITSLOT 0,0
    // 0x000B: RET
    let script = [
        OpCode::PushA.byte(),
        0x08,
        0x00,
        0x00,
        0x00,                 // PUSHA +8
        OpCode::Dup.byte(),   // DUP
        OpCode::CallA.byte(), // CALLA
        OpCode::Ret.byte(),   // RET
        OpCode::Initslot.byte(),
        0x00,
        0x00,               // INITSLOT 0,0
        OpCode::Ret.byte(), // RET
    ];

    let nef_bytes = build_nef(&script);
    let decompilation = Decompiler::new()
        .decompile_bytes_with_manifest(&nef_bytes, None, OutputFormat::Pseudocode)
        .expect("decompile succeeds");

    let edge = decompilation
        .call_graph
        .edges
        .iter()
        .find(|edge| edge.opcode == "CALLA")
        .expect("CALLA edge present");

    match &edge.target {
        CallTarget::Internal { method } => {
            assert_eq!(method.offset, 0x0008);
            assert_eq!(method.name, "sub_0x0008");
        }
        other => panic!("expected DUP-fed CALLA target to resolve, got: {other:?}"),
    }
}