fix(recursive_callees): insert visited outside calls_in_body

$ cargo r -- --json=false tests/standard_proof_simple.rs
[top_level] fn FnDef(DefId { id: 1, name: "top_level" })() -> () {
    let mut _0: ();
    let  _1: ();
    bb0: {
        _1 = m::func1() -> [return: bb1, unwind continue];
    }
    bb1: {
        return;
    }
}

[m::func1] fn FnDef(DefId { id: 2, name: "m::func1" })() -> () {
    let mut _0: ();
    let  _1: &str;
    let mut _2: &str;
    debug _a => _1;
    bb0: {
        StorageLive(_1);
        StorageLive(_2);
        _2 = "";
        _1 = core::str::<impl str>::trim(move _2) -> [return: bb1, unwind continue];
    }
    bb1: {
        StorageDead(_2);
        StorageDead(_1);
        return;
    }
}

[core::str::<impl str>::trim] fn FnDef(DefId { id: 3, name: "core::str::<impl str>::trim" })(_1: &str) -> &str {
    let mut _0: &str;
    debug self => _1;
    bb0: {
        _0 = core::str::<impl str>::trim_matches::<{closure@core::str::<impl str>::trim::{closure#0}}>(_1, ZeroSized: {closure@core::str::<impl str>::trim::{closure#0}}) -> [return: bb1, unwind unreachable];
    }
    bb1: {
        return;
    }
}

[core::str::<impl str>::trim_matches] fn FnDef(DefId { id: 4, name: "core::str::<impl str>::trim_matches" })(_1: &str, _2: P) -> &str {
    let mut _0: &str;
    let mut _3: usize;
    let mut _4: usize;
    let mut _5: <P as std::str::pattern::Pattern>::Searcher<'_>;
    let mut _6: std::option::Option<(usize, usize)>;
    let mut _7: &mut <P as std::str::pattern::Pattern>::Searcher<'_>;
    let mut _8: isize;
    let  _9: usize;
    let  _10: usize;
    let mut _11: std::option::Option<(usize, usize)>;
    let mut _12: &mut <P as std::str::pattern::Pattern>::Searcher<'_>;
    let mut _13: isize;
    let  _14: usize;
    let mut _15: std::ops::Range<usize>;
    let mut _16: usize;
    let mut _17: usize;
    debug self => _1;
    debug pat => _2;
    debug i => _3;
    debug j => _4;
    debug matcher => _5;
    debug a => _9;
    debug b => _10;
    debug b => _14;
    bb0: {
        StorageLive(_3);
        _3 = 0_usize;
        StorageLive(_4);
        _4 = 0_usize;
        StorageLive(_5);
        _5 = <P as std::str::pattern::Pattern>::into_searcher(move _2, _1) -> [return: bb1, unwind unreachable];
    }
    bb1: {
        StorageLive(_6);
        StorageLive(_7);
        _7 = &mut _5;
        _6 = <<P as std::str::pattern::Pattern>::Searcher<'_> as std::str::pattern::Searcher<'_>>::next_reject(move _7) -> [return: bb2, unwind unreachable];
    }
    bb2: {
        StorageDead(_7);
        _8 = discriminant(_6);
        switchInt(move _8) -> [1: bb3, 0: bb4, otherwise: bb12];
    }
    bb3: {
        _9 = (((_6 as variant#1).0: (usize, usize)).0: usize);
        _10 = (((_6 as variant#1).0: (usize, usize)).1: usize);
        _3 = _9;
        _4 = _10;
        StorageDead(_6);
        goto -> bb5;
    }
    bb4: {
        StorageDead(_6);
        goto -> bb5;
    }
    bb5: {
        StorageLive(_11);
        StorageLive(_12);
        _12 = &mut _5;
        _11 = <<P as std::str::pattern::Pattern>::Searcher<'_> as std::str::pattern::ReverseSearcher<'_>>::next_reject_back(move _12) -> [return: bb6, unwind unreachable];
    }
    bb6: {
        StorageDead(_12);
        _13 = discriminant(_11);
        switchInt(move _13) -> [1: bb7, 0: bb8, otherwise: bb12];
    }
    bb7: {
        _14 = (((_11 as variant#1).0: (usize, usize)).1: usize);
        _4 = _14;
        StorageDead(_11);
        goto -> bb9;
    }
    bb8: {
        StorageDead(_11);
        goto -> bb9;
    }
    bb9: {
        StorageLive(_15);
        StorageLive(_16);
        _16 = _3;
        StorageLive(_17);
        _17 = _4;
        _15 = Range(move _16, move _17);
        StorageDead(_17);
        StorageDead(_16);
        _0 = core::str::<impl str>::get_unchecked::<std::ops::Range<usize>>(_1, move _15) -> [return: bb10, unwind unreachable];
    }
    bb10: {
        StorageDead(_15);
        drop(_5) -> [return: bb11, unwind unreachable];
    }
    bb11: {
        StorageDead(_5);
        StorageDead(_4);
        StorageDead(_3);
        return;
    }
    bb12: {
        unreachable;
    }
}

[core::str::<impl str>::get_unchecked] fn FnDef(DefId { id: 10, name: "core::str::<impl str>::get_unchecked" })(_1: &str, _2: I) -> &<I as std::slice::SliceIndex<str>>::Output {
    let mut _0: &<I as std::slice::SliceIndex<str>>::Output;
    let  _3: *const <I as std::slice::SliceIndex<str>>::Output;
    let mut _4: *const str;
    debug self => _1;
    debug i => _2;
    bb0: {
        StorageLive(_3);
        StorageLive(_4);
        _4 = &raw const (*_1);
        _3 = <I as std::slice::SliceIndex<str>>::get_unchecked(move _2, move _4) -> [return: bb1, unwind unreachable];
    }
    bb1: {
        StorageDead(_4);
        _0 = &(*_3);
        StorageDead(_3);
        return;
    }
}

[std::slice::SliceIndex::get_unchecked] [std::str::pattern::ReverseSearcher::next_reject_back] fn FnDef(DefId { id: 9, name: "std::str::pattern::ReverseSearcher::next_reject_back" })(_1: &mut Self) -> std::option::Option<(usize, usize)> {
    let mut _0: std::option::Option<(usize, usize)>;
    let mut _2: std::str::pattern::SearchStep;
    let mut _3: isize;
    let  _4: usize;
    let  _5: usize;
    let mut _6: (usize, usize);
    debug self => _1;
    debug a => _4;
    debug b => _5;
    bb0: {
        goto -> bb1;
    }
    bb1: {
        StorageLive(_2);
        _2 = <Self as std::str::pattern::ReverseSearcher<'_>>::next_back(_1) -> [return: bb2, unwind unreachable];
    }
    bb2: {
        _3 = discriminant(_2);
        switchInt(move _3) -> [1: bb4, 2: bb3, 0: bb5, otherwise: bb7];
    }
    bb3: {
        _0 = std::option::Option::None;
        goto -> bb6;
    }
    bb4: {
        _4 = ((_2 as variant#1).0: usize);
        _5 = ((_2 as variant#1).1: usize);
        StorageLive(_6);
        _6 = (_4, _5);
        _0 = std::option::Option::Some(move _6);
        StorageDead(_6);
        goto -> bb6;
    }
    bb5: {
        StorageDead(_2);
        goto -> bb1;
    }
    bb6: {
        StorageDead(_2);
        return;
    }
    bb7: {
        unreachable;
    }
}

[std::str::pattern::ReverseSearcher::next_back] [std::str::pattern::Searcher::next_reject] fn FnDef(DefId { id: 8, name: "std::str::pattern::Searcher::next_reject" })(_1: &mut Self) -> std::option::Option<(usize, usize)> {
    let mut _0: std::option::Option<(usize, usize)>;
    let mut _2: std::str::pattern::SearchStep;
    let mut _3: isize;
    let  _4: usize;
    let  _5: usize;
    let mut _6: (usize, usize);
    debug self => _1;
    debug a => _4;
    debug b => _5;
    bb0: {
        goto -> bb1;
    }
    bb1: {
        StorageLive(_2);
        _2 = <Self as std::str::pattern::Searcher<'_>>::next(_1) -> [return: bb2, unwind unreachable];
    }
    bb2: {
        _3 = discriminant(_2);
        switchInt(move _3) -> [1: bb4, 2: bb3, 0: bb5, otherwise: bb7];
    }
    bb3: {
        _0 = std::option::Option::None;
        goto -> bb6;
    }
    bb4: {
        _4 = ((_2 as variant#1).0: usize);
        _5 = ((_2 as variant#1).1: usize);
        StorageLive(_6);
        _6 = (_4, _5);
        _0 = std::option::Option::Some(move _6);
        StorageDead(_6);
        goto -> bb6;
    }
    bb5: {
        StorageDead(_2);
        goto -> bb1;
    }
    bb6: {
        StorageDead(_2);
        return;
    }
    bb7: {
        unreachable;
    }
}

[std::str::pattern::Searcher::next] [std::str::pattern::Pattern::into_searcher] [m::func1] fn FnDef(DefId { id: 2, name: "m::func1" })() -> () {
    let mut _0: ();
    let  _1: &str;
    let mut _2: &str;
    debug _a => _1;
    bb0: {
        StorageLive(_1);
        StorageLive(_2);
        _2 = "";
        _1 = core::str::<impl str>::trim(move _2) -> [return: bb1, unwind continue];
    }
    bb1: {
        StorageDead(_2);
        StorageDead(_1);
        return;
    }
}

[core::str::<impl str>::trim] fn FnDef(DefId { id: 3, name: "core::str::<impl str>::trim" })(_1: &str) -> &str {
    let mut _0: &str;
    debug self => _1;
    bb0: {
        _0 = core::str::<impl str>::trim_matches::<{closure@core::str::<impl str>::trim::{closure#0}}>(_1, ZeroSized: {closure@core::str::<impl str>::trim::{closure#0}}) -> [return: bb1, unwind unreachable];
    }
    bb1: {
        return;
    }
}

[core::str::<impl str>::trim_matches] fn FnDef(DefId { id: 4, name: "core::str::<impl str>::trim_matches" })(_1: &str, _2: P) -> &str {
    let mut _0: &str;
    let mut _3: usize;
    let mut _4: usize;
    let mut _5: <P as std::str::pattern::Pattern>::Searcher<'_>;
    let mut _6: std::option::Option<(usize, usize)>;
    let mut _7: &mut <P as std::str::pattern::Pattern>::Searcher<'_>;
    let mut _8: isize;
    let  _9: usize;
    let  _10: usize;
    let mut _11: std::option::Option<(usize, usize)>;
    let mut _12: &mut <P as std::str::pattern::Pattern>::Searcher<'_>;
    let mut _13: isize;
    let  _14: usize;
    let mut _15: std::ops::Range<usize>;
    let mut _16: usize;
    let mut _17: usize;
    debug self => _1;
    debug pat => _2;
    debug i => _3;
    debug j => _4;
    debug matcher => _5;
    debug a => _9;
    debug b => _10;
    debug b => _14;
    bb0: {
        StorageLive(_3);
        _3 = 0_usize;
        StorageLive(_4);
        _4 = 0_usize;
        StorageLive(_5);
        _5 = <P as std::str::pattern::Pattern>::into_searcher(move _2, _1) -> [return: bb1, unwind unreachable];
    }
    bb1: {
        StorageLive(_6);
        StorageLive(_7);
        _7 = &mut _5;
        _6 = <<P as std::str::pattern::Pattern>::Searcher<'_> as std::str::pattern::Searcher<'_>>::next_reject(move _7) -> [return: bb2, unwind unreachable];
    }
    bb2: {
        StorageDead(_7);
        _8 = discriminant(_6);
        switchInt(move _8) -> [1: bb3, 0: bb4, otherwise: bb12];
    }
    bb3: {
        _9 = (((_6 as variant#1).0: (usize, usize)).0: usize);
        _10 = (((_6 as variant#1).0: (usize, usize)).1: usize);
        _3 = _9;
        _4 = _10;
        StorageDead(_6);
        goto -> bb5;
    }
    bb4: {
        StorageDead(_6);
        goto -> bb5;
    }
    bb5: {
        StorageLive(_11);
        StorageLive(_12);
        _12 = &mut _5;
        _11 = <<P as std::str::pattern::Pattern>::Searcher<'_> as std::str::pattern::ReverseSearcher<'_>>::next_reject_back(move _12) -> [return: bb6, unwind unreachable];
    }
    bb6: {
        StorageDead(_12);
        _13 = discriminant(_11);
        switchInt(move _13) -> [1: bb7, 0: bb8, otherwise: bb12];
    }
    bb7: {
        _14 = (((_11 as variant#1).0: (usize, usize)).1: usize);
        _4 = _14;
        StorageDead(_11);
        goto -> bb9;
    }
    bb8: {
        StorageDead(_11);
        goto -> bb9;
    }
    bb9: {
        StorageLive(_15);
        StorageLive(_16);
        _16 = _3;
        StorageLive(_17);
        _17 = _4;
        _15 = Range(move _16, move _17);
        StorageDead(_17);
        StorageDead(_16);
        _0 = core::str::<impl str>::get_unchecked::<std::ops::Range<usize>>(_1, move _15) -> [return: bb10, unwind unreachable];
    }
    bb10: {
        StorageDead(_15);
        drop(_5) -> [return: bb11, unwind unreachable];
    }
    bb11: {
        StorageDead(_5);
        StorageDead(_4);
        StorageDead(_3);
        return;
    }
    bb12: {
        unreachable;
    }
}

[core::str::<impl str>::get_unchecked] fn FnDef(DefId { id: 10, name: "core::str::<impl str>::get_unchecked" })(_1: &str, _2: I) -> &<I as std::slice::SliceIndex<str>>::Output {
    let mut _0: &<I as std::slice::SliceIndex<str>>::Output;
    let  _3: *const <I as std::slice::SliceIndex<str>>::Output;
    let mut _4: *const str;
    debug self => _1;
    debug i => _2;
    bb0: {
        StorageLive(_3);
        StorageLive(_4);
        _4 = &raw const (*_1);
        _3 = <I as std::slice::SliceIndex<str>>::get_unchecked(move _2, move _4) -> [return: bb1, unwind unreachable];
    }
    bb1: {
        StorageDead(_4);
        _0 = &(*_3);
        StorageDead(_3);
        return;
    }
}

[std::slice::SliceIndex::get_unchecked] [std::str::pattern::ReverseSearcher::next_reject_back] fn FnDef(DefId { id: 9, name: "std::str::pattern::ReverseSearcher::next_reject_back" })(_1: &mut Self) -> std::option::Option<(usize, usize)> {
    let mut _0: std::option::Option<(usize, usize)>;
    let mut _2: std::str::pattern::SearchStep;
    let mut _3: isize;
    let  _4: usize;
    let  _5: usize;
    let mut _6: (usize, usize);
    debug self => _1;
    debug a => _4;
    debug b => _5;
    bb0: {
        goto -> bb1;
    }
    bb1: {
        StorageLive(_2);
        _2 = <Self as std::str::pattern::ReverseSearcher<'_>>::next_back(_1) -> [return: bb2, unwind unreachable];
    }
    bb2: {
        _3 = discriminant(_2);
        switchInt(move _3) -> [1: bb4, 2: bb3, 0: bb5, otherwise: bb7];
    }
    bb3: {
        _0 = std::option::Option::None;
        goto -> bb6;
    }
    bb4: {
        _4 = ((_2 as variant#1).0: usize);
        _5 = ((_2 as variant#1).1: usize);
        StorageLive(_6);
        _6 = (_4, _5);
        _0 = std::option::Option::Some(move _6);
        StorageDead(_6);
        goto -> bb6;
    }
    bb5: {
        StorageDead(_2);
        goto -> bb1;
    }
    bb6: {
        StorageDead(_2);
        return;
    }
    bb7: {
        unreachable;
    }
}

[std::str::pattern::ReverseSearcher::next_back] [std::str::pattern::Searcher::next_reject] fn FnDef(DefId { id: 8, name: "std::str::pattern::Searcher::next_reject" })(_1: &mut Self) -> std::option::Option<(usize, usize)> {
    let mut _0: std::option::Option<(usize, usize)>;
    let mut _2: std::str::pattern::SearchStep;
    let mut _3: isize;
    let  _4: usize;
    let  _5: usize;
    let mut _6: (usize, usize);
    debug self => _1;
    debug a => _4;
    debug b => _5;
    bb0: {
        goto -> bb1;
    }
    bb1: {
        StorageLive(_2);
        _2 = <Self as std::str::pattern::Searcher<'_>>::next(_1) -> [return: bb2, unwind unreachable];
    }
    bb2: {
        _3 = discriminant(_2);
        switchInt(move _3) -> [1: bb4, 2: bb3, 0: bb5, otherwise: bb7];
    }
    bb3: {
        _0 = std::option::Option::None;
        goto -> bb6;
    }
    bb4: {
        _4 = ((_2 as variant#1).0: usize);
        _5 = ((_2 as variant#1).1: usize);
        StorageLive(_6);
        _6 = (_4, _5);
        _0 = std::option::Option::Some(move _6);
        StorageDead(_6);
        goto -> bb6;
    }
    bb5: {
        StorageDead(_2);
        goto -> bb1;
    }
    bb6: {
        StorageDead(_2);
        return;
    }
    bb7: {
        unreachable;
    }
}

[std::str::pattern::Searcher::next] [std::str::pattern::Pattern::into_searcher] [core::str::<impl str>::trim] fn FnDef(DefId { id: 3, name: "core::str::<impl str>::trim" })(_1: &str) -> &str {
    let mut _0: &str;
    debug self => _1;
    bb0: {
        _0 = core::str::<impl str>::trim_matches::<{closure@core::str::<impl str>::trim::{closure#0}}>(_1, ZeroSized: {closure@core::str::<impl str>::trim::{closure#0}}) -> [return: bb1, unwind unreachable];
    }
    bb1: {
        return;
    }
}

[core::str::<impl str>::trim_matches] fn FnDef(DefId { id: 4, name: "core::str::<impl str>::trim_matches" })(_1: &str, _2: P) -> &str {
    let mut _0: &str;
    let mut _3: usize;
    let mut _4: usize;
    let mut _5: <P as std::str::pattern::Pattern>::Searcher<'_>;
    let mut _6: std::option::Option<(usize, usize)>;
    let mut _7: &mut <P as std::str::pattern::Pattern>::Searcher<'_>;
    let mut _8: isize;
    let  _9: usize;
    let  _10: usize;
    let mut _11: std::option::Option<(usize, usize)>;
    let mut _12: &mut <P as std::str::pattern::Pattern>::Searcher<'_>;
    let mut _13: isize;
    let  _14: usize;
    let mut _15: std::ops::Range<usize>;
    let mut _16: usize;
    let mut _17: usize;
    debug self => _1;
    debug pat => _2;
    debug i => _3;
    debug j => _4;
    debug matcher => _5;
    debug a => _9;
    debug b => _10;
    debug b => _14;
    bb0: {
        StorageLive(_3);
        _3 = 0_usize;
        StorageLive(_4);
        _4 = 0_usize;
        StorageLive(_5);
        _5 = <P as std::str::pattern::Pattern>::into_searcher(move _2, _1) -> [return: bb1, unwind unreachable];
    }
    bb1: {
        StorageLive(_6);
        StorageLive(_7);
        _7 = &mut _5;
        _6 = <<P as std::str::pattern::Pattern>::Searcher<'_> as std::str::pattern::Searcher<'_>>::next_reject(move _7) -> [return: bb2, unwind unreachable];
    }
    bb2: {
        StorageDead(_7);
        _8 = discriminant(_6);
        switchInt(move _8) -> [1: bb3, 0: bb4, otherwise: bb12];
    }
    bb3: {
        _9 = (((_6 as variant#1).0: (usize, usize)).0: usize);
        _10 = (((_6 as variant#1).0: (usize, usize)).1: usize);
        _3 = _9;
        _4 = _10;
        StorageDead(_6);
        goto -> bb5;
    }
    bb4: {
        StorageDead(_6);
        goto -> bb5;
    }
    bb5: {
        StorageLive(_11);
        StorageLive(_12);
        _12 = &mut _5;
        _11 = <<P as std::str::pattern::Pattern>::Searcher<'_> as std::str::pattern::ReverseSearcher<'_>>::next_reject_back(move _12) -> [return: bb6, unwind unreachable];
    }
    bb6: {
        StorageDead(_12);
        _13 = discriminant(_11);
        switchInt(move _13) -> [1: bb7, 0: bb8, otherwise: bb12];
    }
    bb7: {
        _14 = (((_11 as variant#1).0: (usize, usize)).1: usize);
        _4 = _14;
        StorageDead(_11);
        goto -> bb9;
    }
    bb8: {
        StorageDead(_11);
        goto -> bb9;
    }
    bb9: {
        StorageLive(_15);
        StorageLive(_16);
        _16 = _3;
        StorageLive(_17);
        _17 = _4;
        _15 = Range(move _16, move _17);
        StorageDead(_17);
        StorageDead(_16);
        _0 = core::str::<impl str>::get_unchecked::<std::ops::Range<usize>>(_1, move _15) -> [return: bb10, unwind unreachable];
    }
    bb10: {
        StorageDead(_15);
        drop(_5) -> [return: bb11, unwind unreachable];
    }
    bb11: {
        StorageDead(_5);
        StorageDead(_4);
        StorageDead(_3);
        return;
    }
    bb12: {
        unreachable;
    }
}

[core::str::<impl str>::get_unchecked] fn FnDef(DefId { id: 10, name: "core::str::<impl str>::get_unchecked" })(_1: &str, _2: I) -> &<I as std::slice::SliceIndex<str>>::Output {
    let mut _0: &<I as std::slice::SliceIndex<str>>::Output;
    let  _3: *const <I as std::slice::SliceIndex<str>>::Output;
    let mut _4: *const str;
    debug self => _1;
    debug i => _2;
    bb0: {
        StorageLive(_3);
        StorageLive(_4);
        _4 = &raw const (*_1);
        _3 = <I as std::slice::SliceIndex<str>>::get_unchecked(move _2, move _4) -> [return: bb1, unwind unreachable];
    }
    bb1: {
        StorageDead(_4);
        _0 = &(*_3);
        StorageDead(_3);
        return;
    }
}

[std::slice::SliceIndex::get_unchecked] [std::str::pattern::ReverseSearcher::next_reject_back] fn FnDef(DefId { id: 9, name: "std::str::pattern::ReverseSearcher::next_reject_back" })(_1: &mut Self) -> std::option::Option<(usize, usize)> {
    let mut _0: std::option::Option<(usize, usize)>;
    let mut _2: std::str::pattern::SearchStep;
    let mut _3: isize;
    let  _4: usize;
    let  _5: usize;
    let mut _6: (usize, usize);
    debug self => _1;
    debug a => _4;
    debug b => _5;
    bb0: {
        goto -> bb1;
    }
    bb1: {
        StorageLive(_2);
        _2 = <Self as std::str::pattern::ReverseSearcher<'_>>::next_back(_1) -> [return: bb2, unwind unreachable];
    }
    bb2: {
        _3 = discriminant(_2);
        switchInt(move _3) -> [1: bb4, 2: bb3, 0: bb5, otherwise: bb7];
    }
    bb3: {
        _0 = std::option::Option::None;
        goto -> bb6;
    }
    bb4: {
        _4 = ((_2 as variant#1).0: usize);
        _5 = ((_2 as variant#1).1: usize);
        StorageLive(_6);
        _6 = (_4, _5);
        _0 = std::option::Option::Some(move _6);
        StorageDead(_6);
        goto -> bb6;
    }
    bb5: {
        StorageDead(_2);
        goto -> bb1;
    }
    bb6: {
        StorageDead(_2);
        return;
    }
    bb7: {
        unreachable;
    }
}

[std::str::pattern::ReverseSearcher::next_back] [std::str::pattern::Searcher::next_reject] fn FnDef(DefId { id: 8, name: "std::str::pattern::Searcher::next_reject" })(_1: &mut Self) -> std::option::Option<(usize, usize)> {
    let mut _0: std::option::Option<(usize, usize)>;
    let mut _2: std::str::pattern::SearchStep;
    let mut _3: isize;
    let  _4: usize;
    let  _5: usize;
    let mut _6: (usize, usize);
    debug self => _1;
    debug a => _4;
    debug b => _5;
    bb0: {
        goto -> bb1;
    }
    bb1: {
        StorageLive(_2);
        _2 = <Self as std::str::pattern::Searcher<'_>>::next(_1) -> [return: bb2, unwind unreachable];
    }
    bb2: {
        _3 = discriminant(_2);
        switchInt(move _3) -> [1: bb4, 2: bb3, 0: bb5, otherwise: bb7];
    }
    bb3: {
        _0 = std::option::Option::None;
        goto -> bb6;
    }
    bb4: {
        _4 = ((_2 as variant#1).0: usize);
        _5 = ((_2 as variant#1).1: usize);
        StorageLive(_6);
        _6 = (_4, _5);
        _0 = std::option::Option::Some(move _6);
        StorageDead(_6);
        goto -> bb6;
    }
    bb5: {
        StorageDead(_2);
        goto -> bb1;
    }
    bb6: {
        StorageDead(_2);
        return;
    }
    bb7: {
        unreachable;
    }
}

[std::str::pattern::Searcher::next] [std::str::pattern::Pattern::into_searcher] ⏎

Author: zjp-CN

src/functions/callees.rs

@@ -1,62 +1,55 @@
 use super::ty_to_fndef;
 use indexmap::IndexSet;
-use stable_mir::{mir::*, ty::FnDef};
+use stable_mir::{CrateDef, mir::*, ty::FnDef};
 
-pub fn calls_in_body(body: &Body, visited: &mut IndexSet<FnDef>) -> Vec<FnDef> {
+pub fn calls_in_body(body: &Body) -> Vec<FnDef> {
     let locals = body.locals();
     let mut direct = Vec::new();
     for basic_block in &body.blocks {
-        terminator_to_fn_def(&basic_block.terminator, locals, visited, &mut direct);
+        terminator_to_fn_def(&basic_block.terminator, locals, &mut direct);
     }
     // all direct calls in a body
     direct
 }
 
 /// Extract fn call from the terminator.
-fn terminator_to_fn_def(
-    terminator: &Terminator,
-    locals: &[LocalDecl],
-    visited: &mut IndexSet<FnDef>,
-    direct: &mut Vec<FnDef>,
-) {
+fn terminator_to_fn_def(terminator: &Terminator, locals: &[LocalDecl], direct: &mut Vec<FnDef>) {
     let TerminatorKind::Call { func, args, .. } = &terminator.kind else { return };
 
-    push_fn_def(func, visited, locals, direct);
+    push_fn_def(func, locals, direct);
 
     // FIXME: Will there be a FnDef in an arg in MIR? Probably no?
     // Anyway, need find a test for this. But now assume yes.
     // Maybe a function pointer or raw pointer cast to fn pointer suit?
     for arg in args {
-        push_fn_def(arg, visited, locals, direct);
+        push_fn_def(arg, locals, direct);
     }
 
     // Will there ever be a FnDef in destination? Skip destination for now.
 }
 
 /// Push a FnDef Operand if any.
-fn push_fn_def(
-    func: &Operand,
-    visited: &mut IndexSet<FnDef>,
-    locals: &[LocalDecl],
-    direct: &mut Vec<FnDef>,
-) {
+fn push_fn_def(func: &Operand, locals: &[LocalDecl], direct: &mut Vec<FnDef>) {
     let ty = func.ty(locals).expect("malformed operand or incompatible locals list");
     if let Some(fn_def) = ty_to_fndef(ty) {
         direct.push(fn_def);
-        visited.insert(fn_def);
     }
 }
 
 /// Recursively retrieve calls for a call.
 pub fn recursive_callees(fn_def: FnDef, visited: &mut IndexSet<FnDef>) {
+    // print!("[{}] ", fn_def.name());
+
     let Some(body) = fn_def.body() else { return };
-    let mut buf = Vec::with_capacity(1024);
-    body.dump(&mut buf, &format!("{fn_def:?}")).unwrap();
-    println!("{}", String::from_utf8(buf).unwrap());
-    let mut direct = calls_in_body(&body, visited);
+
+    // let mut buf = Vec::with_capacity(1024);
+    // body.dump(&mut buf, &format!("{fn_def:?}")).unwrap();
+    // println!("{}", String::from_utf8(buf).unwrap());
+
+    let mut direct = calls_in_body(&body);
     while let Some(call) = direct.pop() {
         // the call hasn't been reached, traverse
-        if !visited.contains(&call) {
+        if visited.insert(call) {
             recursive_callees(call, visited);
         }
     }

src/functions/mod.rs

@@ -40,7 +40,7 @@ impl Function {
 
         let mut callees = IndexSet::new();
         // retrieve direct calls
-        callees::calls_in_body(&body, &mut callees);
+        callees.extend(callees::calls_in_body(&body));
         // recursive calls
         let direct_calls: Vec<_> = callees.iter().copied().collect();
         for call in direct_calls {

tests/snapshots.rs

@@ -44,7 +44,16 @@ fn standard_proof() {
             "func": "fn recursive_callees() {\n        crate::top_level();\n    }",
             "callees": [
               "FnDef(DefId { id: 3, name: \"top_level\" })",
-              "FnDef(DefId { id: 4, name: \"m::func1\" })"
+              "FnDef(DefId { id: 4, name: \"m::func1\" })",
+              "FnDef(DefId { id: 8, name: \"core::str::<impl str>::trim\" })",
+              "FnDef(DefId { id: 9, name: \"core::str::<impl str>::trim_matches\" })",
+              "FnDef(DefId { id: 15, name: \"core::str::<impl str>::get_unchecked\" })",
+              "FnDef(DefId { id: 16, name: \"std::slice::SliceIndex::get_unchecked\" })",
+              "FnDef(DefId { id: 14, name: \"std::str::pattern::ReverseSearcher::next_reject_back\" })",
+              "FnDef(DefId { id: 18, name: \"std::str::pattern::ReverseSearcher::next_back\" })",
+              "FnDef(DefId { id: 13, name: \"std::str::pattern::Searcher::next_reject\" })",
+              "FnDef(DefId { id: 19, name: \"std::str::pattern::Searcher::next\" })",
+              "FnDef(DefId { id: 12, name: \"std::str::pattern::Pattern::into_searcher\" })"
             ]
           },
           {
@@ -53,7 +62,15 @@ fn standard_proof() {
             "func": "pub fn top_level() {\n    m::func1();\n}",
             "callees": [
               "FnDef(DefId { id: 4, name: \"m::func1\" })",
-              "FnDef(DefId { id: 8, name: \"core::str::<impl str>::trim\" })"
+              "FnDef(DefId { id: 8, name: \"core::str::<impl str>::trim\" })",
+              "FnDef(DefId { id: 9, name: \"core::str::<impl str>::trim_matches\" })",
+              "FnDef(DefId { id: 15, name: \"core::str::<impl str>::get_unchecked\" })",
+              "FnDef(DefId { id: 16, name: \"std::slice::SliceIndex::get_unchecked\" })",
+              "FnDef(DefId { id: 14, name: \"std::str::pattern::ReverseSearcher::next_reject_back\" })",
+              "FnDef(DefId { id: 18, name: \"std::str::pattern::ReverseSearcher::next_back\" })",
+              "FnDef(DefId { id: 13, name: \"std::str::pattern::Searcher::next_reject\" })",
+              "FnDef(DefId { id: 19, name: \"std::str::pattern::Searcher::next\" })",
+              "FnDef(DefId { id: 12, name: \"std::str::pattern::Pattern::into_searcher\" })"
             ]
           },
           {
@@ -62,7 +79,14 @@ fn standard_proof() {
             "func": "pub fn func1() {\n        let _a = \"\".trim();\n    }",
             "callees": [
               "FnDef(DefId { id: 8, name: \"core::str::<impl str>::trim\" })",
-              "FnDef(DefId { id: 9, name: \"core::str::<impl str>::trim_matches\" })"
+              "FnDef(DefId { id: 9, name: \"core::str::<impl str>::trim_matches\" })",
+              "FnDef(DefId { id: 15, name: \"core::str::<impl str>::get_unchecked\" })",
+              "FnDef(DefId { id: 16, name: \"std::slice::SliceIndex::get_unchecked\" })",
+              "FnDef(DefId { id: 14, name: \"std::str::pattern::ReverseSearcher::next_reject_back\" })",
+              "FnDef(DefId { id: 18, name: \"std::str::pattern::ReverseSearcher::next_back\" })",
+              "FnDef(DefId { id: 13, name: \"std::str::pattern::Searcher::next_reject\" })",
+              "FnDef(DefId { id: 19, name: \"std::str::pattern::Searcher::next\" })",
+              "FnDef(DefId { id: 12, name: \"std::str::pattern::Pattern::into_searcher\" })"
             ]
           }
         ]"##]].assert_eq(&stdout);