scripts/rustdoc_test_builder.rs

   1 // SPDX-License-Identifier: GPL-2.0
   2
   3 //! Test builder for `rustdoc`-generated tests.
   4 //!
   5 //! This script is a hack to extract the test from `rustdoc`'s output. Ideally, `rustdoc` would
   6 //! have an option to generate this information instead, e.g. as JSON output.
   7 //!
   8 //! The `rustdoc`-generated test names look like `{file}_{line}_{number}`, e.g.
   9 //! `...path_rust_kernel_sync_arc_rs_42_0`. `number` is the "test number", needed in cases like
  10 //! a macro that expands into items with doctests is invoked several times within the same line.
  11 //!
  12 //! However, since these names are used for bisection in CI, the line number makes it not stable
  13 //! at all. In the future, we would like `rustdoc` to give us the Rust item path associated with
  14 //! the test, plus a "test number" (for cases with several examples per item) and generate a name
  15 //! from that. For the moment, we generate ourselves a new name, `{file}_{number}` instead, in
  16 //! the `gen` script (done there since we need to be aware of all the tests in a given file).
  17
  18 use std::io::Read;
  19
  20 fn main() {
  21     let mut stdin = std::io::stdin().lock();
  22     let mut body = String::new();
  23     stdin.read_to_string(&mut body).unwrap();
  24
  25     // Find the generated function name looking for the inner function inside `main()`.
  26     //
  27     // The line we are looking for looks like one of the following:
  28     //
  29     // ```
  30     // fn main() { #[allow(non_snake_case)] fn _doctest_main_rust_kernel_file_rs_28_0() {
  31     // fn main() { #[allow(non_snake_case)] fn _doctest_main_rust_kernel_file_rs_37_0() -> Result<(), impl core::fmt::Debug> {
  32     // ```
  33     //
  34     // It should be unlikely that doctest code matches such lines (when code is formatted properly).
  35     let rustdoc_function_name = body
  36         .lines()
  37         .find_map(|line| {
  38             Some(
  39                 line.split_once("fn main() {")?
  40                     .1
  41                     .split_once("fn ")?
  42                     .1
  43                     .split_once("()")?
  44                     .0,
  45             )
  46             .filter(|x| x.chars().all(|c| c.is_alphanumeric() || c == '_'))
  47         })
  48         .expect("No test function found in `rustdoc`'s output.");
  49
  50     // Qualify `Result` to avoid the collision with our own `Result` coming from the prelude.
  51     let body = body.replace(
  52         &format!("{rustdoc_function_name}() -> Result<(), impl core::fmt::Debug> {{"),
  53         &format!("{rustdoc_function_name}() -> core::result::Result<(), impl core::fmt::Debug> {{"),
  54     );
  55
  56     // For tests that get generated with `Result`, like above, `rustdoc` generates an `unwrap()` on
  57     // the return value to check there were no returned errors. Instead, we use our assert macro
  58     // since we want to just fail the test, not panic the kernel.
  59     //
  60     // We save the result in a variable so that the failed assertion message looks nicer.
  61     let body = body.replace(
  62         &format!("}} {rustdoc_function_name}().unwrap() }}"),
  63         &format!("}} let test_return_value = {rustdoc_function_name}(); assert!(test_return_value.is_ok()); }}"),
  64     );
  65
  66     // Figure out a smaller test name based on the generated function name.
  67     let name = rustdoc_function_name.split_once("_rust_kernel_").unwrap().1;
  68
  69     let path = format!("rust/test/doctests/kernel/{name}");
  70
  71     std::fs::write(path, body.as_bytes()).unwrap();
  72 }