Is there some control flow graphing tool for Rust?

I'm sutdying to make my code better, and I'd like to analyze its possible branches.

This is a question I wrote on Computer Science Stack Exchange: algorithm analysis - Is there a branch of CS about studying function calls branching? - Computer Science Stack Exchange

this is a code I'd like to analzye better:

my_func(&mut self, request: Request, retry_count: i32) -> Result<(), FuncError> {
   let response = self.send(request);
   let response = match response {
       Ok(_) => return Ok(()),
       Err(Error::Unauthorized(unauthorized)) => Err(FuncError::Unauthorized(unauthorized)),
       Err(Error::ConnectionClosed) => Err(FuncError::ConnectionClosed{}),
       Err(_) => Err(FuncError::UnknownError{})
   }
   match response {
      Ok(()) => Ok(()),
      Err(Error::Unauthorized(unauthorized)) => {
           self.authorize();
           return self.my_func(request, retry_count -1),
      }
      Err(Error::ConnectionClosed) => {
           self.connect();
           return self.my_func(request, retry_count -1),
      }
      Err(_) => Err(FuncError::UnknownError)
   }
}

I'd like to view a graph of all possible branches of this function for a small value of retry_count like 3.

Are there other tools you know that can help me analyze the behaviour of my code?

This topic was automatically closed 90 days after the last reply. We invite you to open a new topic if you have further questions or comments.