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?