Inner function call only printed if the declaration of the inner function is made after the outer function

[ArturAssisComp]

Bug Description

We have a function called factors, which, from an u64 input, returns its prime factors as a Vec<u64>. From the body of the factors we may call multiple times another function called extract_all_p_factors, which was defined/declared in the same file.

We have some unit tests for the factors function. Thus, from the unit tests, we call factors, which calls extract_all_p_factors. The following calling tree would be expected for any input greater than 1:
test-->factors-(+)->extract_all_p_factors
OBS.: -(+)-> indicates at least one call
However, for some reason, depending on the order in which they are declared (factors and extract_all_p_factors), the VS code FireDBG GUI will not print either extract_all_p_factors calls or factors call.

1. The following configuration does not print the factors call:

pub fn factors(...){
  //....
  extract_all_p_factors();
}
fn extract_all_p_factors(...){
  //...
}

2. The following configuration does not print the extract_all_p_factors calls:

fn extract_all_p_factors(...){
 //...
}
pub fn factors(...){
 //....
 extract_all_p_factors();
}

The test which was used for the previous example is:

    #[test]
    fn product_of_primes() {
        let factors = factors(901_255);
        let expected = [5, 17, 23, 461];
        assert_eq!(factors, expected);
    }

Trying to reproduce the bug

I am trying to reproduce the previous behavior but I could not yet. The following example works properly independent of the order in which the inner_function is declared:

Code used to try to reproduce the bug:

pub fn outer_function() {
    inner_function();
}
fn inner_function() {
    println!("Hello Inner function");
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn it_works() {
        assert_eq!(outer_function(), ());
    }
}

System Configuration

My system configuration is:

• VS Code:
  ´´´
  Version: 1.98.0 (user setup)
  Commit: 6609ac3d66f4eade5cf376d1cb76f13985724bcb
  Date: 2025-03-04T21:06:18.612Z
  Electron: 34.2.0
  ElectronBuildId: 11044223
  Chromium: 132.0.6834.196
  Node.js: 20.18.2
  V8: 13.2.152.36-electron.0
  OS: Windows_NT x64 10.0.26100
  ´´´
• Windows 11
• Rust toolchain: 1.81-x86_64-unknown-linux-gnu

Complete Code

fn extract_all_p_factors(n: &mut u64, p: u64, factors: &mut Vec<u64>) {
    if *n % p != 0 {
        return;
    }
    let mut max_factor;
    let mut total_num_of_factors = 0_usize;
    let mut current_num_of_factors;
    // Loop invariant: n*max_factor = constant
    loop {
        // Reset loop variables
        max_factor = p;
        current_num_of_factors = 1_usize;
        // add squares loop
        while let Some(squared_max_factor) = max_factor.checked_mul(max_factor) {
            if *n % squared_max_factor != 0 {
                break;
            }
            max_factor = squared_max_factor;
            current_num_of_factors *= 2;
        }
        // Update n
        *n /= max_factor;
        total_num_of_factors += current_num_of_factors;

        // Is there any p factor remaining?
        if *n % p != 0 {
            break;
        }
    }
    // add the factors
    factors.resize(factors.len() + total_num_of_factors, p);
}

pub fn factors(n: u64) -> Vec<u64> {
    if n < 2 {
        return vec![];
    }
    // The maximum number of factors is probably 63 (2^63). But one more for making it sure.
    let mut result: Vec<u64> = Vec::with_capacity(63 + 1);
    let mut n = n;
    // Extract 2 alone to make it possible to check only for odd numbers later
    if n % 2 == 0 {
        extract_all_p_factors(&mut n, 2, &mut result);
    }

    let mut factor_candidate = 3;
    // Loop invariant: result[0]*...*result[i]*n == constant
    while factor_candidate <= n {
        if n % factor_candidate == 0 {
            extract_all_p_factors(&mut n, factor_candidate, &mut result);
        }
        factor_candidate += 2;
    }
    // If n>1 is remaining, it is a prime factor itself.
    if n != 1 {
        result.push(n);
    }
    result
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn no_factors() {
        let factors = factors(1);
        let expected = [];
        assert_eq!(factors, expected);
    }

    #[test]
    fn prime_number() {
        let factors = factors(2);
        let expected = [2];
        assert_eq!(factors, expected);
    }

    #[test]
    fn another_prime_number() {
        let factors = factors(3);
        let expected = [3];
        assert_eq!(factors, expected);
    }

    #[test]
    fn square_of_a_prime() {
        let factors = factors(9);
        let expected = [3, 3];
        assert_eq!(factors, expected);
    }

    #[test]
    fn product_of_first_prime() {
        let factors = factors(4);
        let expected = [2, 2];
        assert_eq!(factors, expected);
    }

    #[test]
    fn cube_of_a_prime() {
        let factors = factors(8);
        let expected = [2, 2, 2];
        assert_eq!(factors, expected);
    }

    #[test]
    fn product_of_second_prime() {
        let factors = factors(27);
        let expected = [3, 3, 3];
        assert_eq!(factors, expected);
    }

    #[test]
    fn product_of_third_prime() {
        let factors = factors(625);
        let expected = [5, 5, 5, 5];
        assert_eq!(factors, expected);
    }

    #[test]
    fn product_of_first_and_second_prime() {
        let factors = factors(6);
        let expected = [2, 3];
        assert_eq!(factors, expected);
    }

    #[test]
    fn product_of_primes_and_non_primes() {
        let factors = factors(12);
        let expected = [2, 2, 3];
        assert_eq!(factors, expected);
    }

    #[test]
    fn product_of_primes() {
        let factors = factors(901_255);
        let expected = [5, 17, 23, 461];
        assert_eq!(factors, expected);
    }

    #[test]
    fn factors_include_a_large_prime() {
        let factors = factors(93_819_012_551);
        let expected = [11, 9_539, 894_119];
        assert_eq!(factors, expected);
    }
}