Enable --deny-warnings for cargo shear (#21616)

## Summary

In https://github.com/openai/codex/pull/21584, we disabled doctests for
crates that lack any doctests. We can enforce that property via `cargo
shear --deny-warnings`: crates that lack doctests will be flagged if
doctests are enabled, and crates with doctests will be flagged if
doctests are disabled.

A few additional notes:

- By adding `--deny-warnings`, `cargo shear` also flagged a number of
modules that were not reachable at all. Some of those have been removed.
- This PR removes a usage of `windows_modules!` (since `cargo shear` and
`rustfmt` couldn't see through it) in favor of simple `#[cfg(target_os =
"windows")]` macros. As a consequence, many of these files exhibit churn
in this PR, since they weren't being formatted by `rustfmt` at all on
main.
- Again, to make the code more analyzable, this PR also removes some
usages of `#[path = "cwd_junction.rs"]` in favor of a more standard
module structure. The bin sidecar structure is still retained, but,
e.g., `windows-sandbox-rs/src/bin/command_runner.rs‎` was moved to
`windows-sandbox-rs/src/bin/command_runner/main.rs`, and so on.

---------

Co-authored-by: Codex <noreply@openai.com>

codex-rs/core/src/tools/code_mode/execute_handler_tests.rs

@@ -1,41 +0,0 @@
-use super::parse_freeform_args;
-use pretty_assertions::assert_eq;
-
-#[test]
-fn parse_freeform_args_without_pragma() {
-    let args = parse_freeform_args("output_text('ok');").expect("parse args");
-    assert_eq!(args.code, "output_text('ok');");
-    assert_eq!(args.yield_time_ms, None);
-    assert_eq!(args.max_output_tokens, None);
-}
-
-#[test]
-fn parse_freeform_args_with_pragma() {
-    let input = concat!(
-        "// @exec: {\"yield_time_ms\": 15000, \"max_output_tokens\": 2000}\n",
-        "output_text('ok');",
-    );
-    let args = parse_freeform_args(input).expect("parse args");
-    assert_eq!(args.code, "output_text('ok');");
-    assert_eq!(args.yield_time_ms, Some(15_000));
-    assert_eq!(args.max_output_tokens, Some(2_000));
-}
-
-#[test]
-fn parse_freeform_args_rejects_unknown_key() {
-    let err = parse_freeform_args("// @exec: {\"nope\": 1}\noutput_text('ok');")
-        .expect_err("expected error");
-    assert_eq!(
-        err.to_string(),
-        "exec pragma only supports `yield_time_ms` and `max_output_tokens`; got `nope`"
-    );
-}
-
-#[test]
-fn parse_freeform_args_rejects_missing_source() {
-    let err = parse_freeform_args("// @exec: {\"yield_time_ms\": 10}").expect_err("expected error");
-    assert_eq!(
-        err.to_string(),
-        "exec pragma must be followed by JavaScript source on subsequent lines"
-    );
-}

codex-rs/core/src/tools/handlers/grep_files_tests.rs

@@ -1,95 +0,0 @@
-use super::*;
-use std::process::Command as StdCommand;
-use tempfile::tempdir;
-
-#[test]
-fn parses_basic_results() {
-    let stdout = b"/tmp/file_a.rs\n/tmp/file_b.rs\n";
-    let parsed = parse_results(stdout, 10);
-    assert_eq!(
-        parsed,
-        vec!["/tmp/file_a.rs".to_string(), "/tmp/file_b.rs".to_string()]
-    );
-}
-
-#[test]
-fn parse_truncates_after_limit() {
-    let stdout = b"/tmp/file_a.rs\n/tmp/file_b.rs\n/tmp/file_c.rs\n";
-    let parsed = parse_results(stdout, 2);
-    assert_eq!(
-        parsed,
-        vec!["/tmp/file_a.rs".to_string(), "/tmp/file_b.rs".to_string()]
-    );
-}
-
-#[tokio::test]
-async fn run_search_returns_results() -> anyhow::Result<()> {
-    if !rg_available() {
-        return Ok(());
-    }
-    let temp = tempdir().expect("create temp dir");
-    let dir = temp.path();
-    std::fs::write(dir.join("match_one.txt"), "alpha beta gamma").unwrap();
-    std::fs::write(dir.join("match_two.txt"), "alpha delta").unwrap();
-    std::fs::write(dir.join("other.txt"), "omega").unwrap();
-
-    let results = run_rg_search("alpha", None, dir, 10, dir).await?;
-    assert_eq!(results.len(), 2);
-    assert!(results.iter().any(|path| path.ends_with("match_one.txt")));
-    assert!(results.iter().any(|path| path.ends_with("match_two.txt")));
-    Ok(())
-}
-
-#[tokio::test]
-async fn run_search_with_glob_filter() -> anyhow::Result<()> {
-    if !rg_available() {
-        return Ok(());
-    }
-    let temp = tempdir().expect("create temp dir");
-    let dir = temp.path();
-    std::fs::write(dir.join("match_one.rs"), "alpha beta gamma").unwrap();
-    std::fs::write(dir.join("match_two.txt"), "alpha delta").unwrap();
-
-    let results = run_rg_search("alpha", Some("*.rs"), dir, 10, dir).await?;
-    assert_eq!(results.len(), 1);
-    assert!(results.iter().all(|path| path.ends_with("match_one.rs")));
-    Ok(())
-}
-
-#[tokio::test]
-async fn run_search_respects_limit() -> anyhow::Result<()> {
-    if !rg_available() {
-        return Ok(());
-    }
-    let temp = tempdir().expect("create temp dir");
-    let dir = temp.path();
-    std::fs::write(dir.join("one.txt"), "alpha one").unwrap();
-    std::fs::write(dir.join("two.txt"), "alpha two").unwrap();
-    std::fs::write(dir.join("three.txt"), "alpha three").unwrap();
-
-    let results = run_rg_search("alpha", None, dir, 2, dir).await?;
-    assert_eq!(results.len(), 2);
-    Ok(())
-}
-
-#[tokio::test]
-async fn run_search_handles_no_matches() -> anyhow::Result<()> {
-    if !rg_available() {
-        return Ok(());
-    }
-    let temp = tempdir().expect("create temp dir");
-    let dir = temp.path();
-    std::fs::write(dir.join("one.txt"), "omega").unwrap();
-
-    let results = run_rg_search("alpha", None, dir, 5, dir).await?;
-    assert!(results.is_empty());
-    Ok(())
-}
-
-fn rg_available() -> bool {
-    StdCommand::new("rg")
-        .arg("--version")
-        .output()
-        .map(|output| output.status.success())
-        .unwrap_or(false)
-}

codex-rs/core/src/tools/handlers/read_file_tests.rs

@@ -1,503 +0,0 @@
-use super::indentation::read_block;
-use super::slice::read;
-use super::*;
-use pretty_assertions::assert_eq;
-use tempfile::NamedTempFile;
-
-#[tokio::test]
-async fn reads_requested_range() -> anyhow::Result<()> {
-    let mut temp = NamedTempFile::new()?;
-    use std::io::Write as _;
-    write!(
-        temp,
-        "alpha
-beta
-gamma
-"
-    )?;
-
-    let lines = read(temp.path(), 2, 2).await?;
-    assert_eq!(lines, vec!["L2: beta".to_string(), "L3: gamma".to_string()]);
-    Ok(())
-}
-
-#[tokio::test]
-async fn errors_when_offset_exceeds_length() -> anyhow::Result<()> {
-    let mut temp = NamedTempFile::new()?;
-    use std::io::Write as _;
-    writeln!(temp, "only")?;
-
-    let err = read(temp.path(), 3, 1)
-        .await
-        .expect_err("offset exceeds length");
-    assert_eq!(
-        err,
-        FunctionCallError::RespondToModel("offset exceeds file length".to_string())
-    );
-    Ok(())
-}
-
-#[tokio::test]
-async fn reads_non_utf8_lines() -> anyhow::Result<()> {
-    let mut temp = NamedTempFile::new()?;
-    use std::io::Write as _;
-    temp.as_file_mut().write_all(b"\xff\xfe\nplain\n")?;
-
-    let lines = read(temp.path(), 1, 2).await?;
-    let expected_first = format!("L1: {}{}", '\u{FFFD}', '\u{FFFD}');
-    assert_eq!(lines, vec![expected_first, "L2: plain".to_string()]);
-    Ok(())
-}
-
-#[tokio::test]
-async fn trims_crlf_endings() -> anyhow::Result<()> {
-    let mut temp = NamedTempFile::new()?;
-    use std::io::Write as _;
-    write!(temp, "one\r\ntwo\r\n")?;
-
-    let lines = read(temp.path(), 1, 2).await?;
-    assert_eq!(lines, vec!["L1: one".to_string(), "L2: two".to_string()]);
-    Ok(())
-}
-
-#[tokio::test]
-async fn respects_limit_even_with_more_lines() -> anyhow::Result<()> {
-    let mut temp = NamedTempFile::new()?;
-    use std::io::Write as _;
-    write!(
-        temp,
-        "first
-second
-third
-"
-    )?;
-
-    let lines = read(temp.path(), 1, 2).await?;
-    assert_eq!(
-        lines,
-        vec!["L1: first".to_string(), "L2: second".to_string()]
-    );
-    Ok(())
-}
-
-#[tokio::test]
-async fn truncates_lines_longer_than_max_length() -> anyhow::Result<()> {
-    let mut temp = NamedTempFile::new()?;
-    use std::io::Write as _;
-    let long_line = "x".repeat(MAX_LINE_LENGTH + 50);
-    writeln!(temp, "{long_line}")?;
-
-    let lines = read(temp.path(), 1, 1).await?;
-    let expected = "x".repeat(MAX_LINE_LENGTH);
-    assert_eq!(lines, vec![format!("L1: {expected}")]);
-    Ok(())
-}
-
-#[tokio::test]
-async fn indentation_mode_captures_block() -> anyhow::Result<()> {
-    let mut temp = NamedTempFile::new()?;
-    use std::io::Write as _;
-    write!(
-        temp,
-        "fn outer() {{
-    if cond {{
-        inner();
-    }}
-    tail();
-}}
-"
-    )?;
-
-    let options = IndentationArgs {
-        anchor_line: Some(3),
-        include_siblings: false,
-        max_levels: 1,
-        ..Default::default()
-    };
-
-    let lines = read_block(temp.path(), 3, 10, options).await?;
-
-    assert_eq!(
-        lines,
-        vec![
-            "L2:     if cond {".to_string(),
-            "L3:         inner();".to_string(),
-            "L4:     }".to_string()
-        ]
-    );
-    Ok(())
-}
-
-#[tokio::test]
-async fn indentation_mode_expands_parents() -> anyhow::Result<()> {
-    let mut temp = NamedTempFile::new()?;
-    use std::io::Write as _;
-    write!(
-        temp,
-        "mod root {{
-    fn outer() {{
-        if cond {{
-            inner();
-        }}
-    }}
-}}
-"
-    )?;
-
-    let mut options = IndentationArgs {
-        anchor_line: Some(4),
-        max_levels: 2,
-        ..Default::default()
-    };
-
-    let lines = read_block(temp.path(), 4, 50, options.clone()).await?;
-    assert_eq!(
-        lines,
-        vec![
-            "L2:     fn outer() {".to_string(),
-            "L3:         if cond {".to_string(),
-            "L4:             inner();".to_string(),
-            "L5:         }".to_string(),
-            "L6:     }".to_string(),
-        ]
-    );
-
-    options.max_levels = 3;
-    let expanded = read_block(temp.path(), 4, 50, options).await?;
-    assert_eq!(
-        expanded,
-        vec![
-            "L1: mod root {".to_string(),
-            "L2:     fn outer() {".to_string(),
-            "L3:         if cond {".to_string(),
-            "L4:             inner();".to_string(),
-            "L5:         }".to_string(),
-            "L6:     }".to_string(),
-            "L7: }".to_string(),
-        ]
-    );
-    Ok(())
-}
-
-#[tokio::test]
-async fn indentation_mode_respects_sibling_flag() -> anyhow::Result<()> {
-    let mut temp = NamedTempFile::new()?;
-    use std::io::Write as _;
-    write!(
-        temp,
-        "fn wrapper() {{
-    if first {{
-        do_first();
-    }}
-    if second {{
-        do_second();
-    }}
-}}
-"
-    )?;
-
-    let mut options = IndentationArgs {
-        anchor_line: Some(3),
-        include_siblings: false,
-        max_levels: 1,
-        ..Default::default()
-    };
-
-    let lines = read_block(temp.path(), 3, 50, options.clone()).await?;
-    assert_eq!(
-        lines,
-        vec![
-            "L2:     if first {".to_string(),
-            "L3:         do_first();".to_string(),
-            "L4:     }".to_string(),
-        ]
-    );
-
-    options.include_siblings = true;
-    let with_siblings = read_block(temp.path(), 3, 50, options).await?;
-    assert_eq!(
-        with_siblings,
-        vec![
-            "L2:     if first {".to_string(),
-            "L3:         do_first();".to_string(),
-            "L4:     }".to_string(),
-            "L5:     if second {".to_string(),
-            "L6:         do_second();".to_string(),
-            "L7:     }".to_string(),
-        ]
-    );
-    Ok(())
-}
-
-#[tokio::test]
-async fn indentation_mode_handles_python_sample() -> anyhow::Result<()> {
-    let mut temp = NamedTempFile::new()?;
-    use std::io::Write as _;
-    write!(
-        temp,
-        "class Foo:
-    def __init__(self, size):
-        self.size = size
-    def double(self, value):
-        if value is None:
-            return 0
-        result = value * self.size
-        return result
-class Bar:
-    def compute(self):
-        helper = Foo(2)
-        return helper.double(5)
-"
-    )?;
-
-    let options = IndentationArgs {
-        anchor_line: Some(7),
-        include_siblings: true,
-        max_levels: 1,
-        ..Default::default()
-    };
-
-    let lines = read_block(temp.path(), 1, 200, options).await?;
-    assert_eq!(
-        lines,
-        vec![
-            "L2:     def __init__(self, size):".to_string(),
-            "L3:         self.size = size".to_string(),
-            "L4:     def double(self, value):".to_string(),
-            "L5:         if value is None:".to_string(),
-            "L6:             return 0".to_string(),
-            "L7:         result = value * self.size".to_string(),
-            "L8:         return result".to_string(),
-        ]
-    );
-    Ok(())
-}
-
-#[tokio::test]
-#[ignore]
-async fn indentation_mode_handles_javascript_sample() -> anyhow::Result<()> {
-    let mut temp = NamedTempFile::new()?;
-    use std::io::Write as _;
-    write!(
-        temp,
-        "export function makeThing() {{
-    const cache = new Map();
-    function ensure(key) {{
-        if (!cache.has(key)) {{
-            cache.set(key, []);
-        }}
-        return cache.get(key);
-    }}
-    const handlers = {{
-        init() {{
-            console.log(\"init\");
-        }},
-        run() {{
-            if (Math.random() > 0.5) {{
-                return \"heads\";
-            }}
-            return \"tails\";
-        }},
-    }};
-    return {{ cache, handlers }};
-}}
-export function other() {{
-    return makeThing();
-}}
-"
-    )?;
-
-    let options = IndentationArgs {
-        anchor_line: Some(15),
-        max_levels: 1,
-        ..Default::default()
-    };
-
-    let lines = read_block(temp.path(), 15, 200, options).await?;
-    assert_eq!(
-        lines,
-        vec![
-            "L10:         init() {".to_string(),
-            "L11:             console.log(\"init\");".to_string(),
-            "L12:         },".to_string(),
-            "L13:         run() {".to_string(),
-            "L14:             if (Math.random() > 0.5) {".to_string(),
-            "L15:                 return \"heads\";".to_string(),
-            "L16:             }".to_string(),
-            "L17:             return \"tails\";".to_string(),
-            "L18:         },".to_string(),
-        ]
-    );
-    Ok(())
-}
-
-fn write_cpp_sample() -> anyhow::Result<NamedTempFile> {
-    let mut temp = NamedTempFile::new()?;
-    use std::io::Write as _;
-    write!(
-        temp,
-        "#include <vector>
-#include <string>
-
-namespace sample {{
-class Runner {{
-public:
-    void setup() {{
-        if (enabled_) {{
-            init();
-        }}
-    }}
-
-    // Run the code
-    int run() const {{
-        switch (mode_) {{
-            case Mode::Fast:
-                return fast();
-            case Mode::Slow:
-                return slow();
-            default:
-                return fallback();
-        }}
-    }}
-
-private:
-    bool enabled_ = false;
-    Mode mode_ = Mode::Fast;
-
-    int fast() const {{
-        return 1;
-    }}
-}};
-}}  // namespace sample
-"
-    )?;
-    Ok(temp)
-}
-
-#[tokio::test]
-async fn indentation_mode_handles_cpp_sample_shallow() -> anyhow::Result<()> {
-    let temp = write_cpp_sample()?;
-
-    let options = IndentationArgs {
-        include_siblings: false,
-        anchor_line: Some(18),
-        max_levels: 1,
-        ..Default::default()
-    };
-
-    let lines = read_block(temp.path(), 18, 200, options).await?;
-    assert_eq!(
-        lines,
-        vec![
-            "L15:         switch (mode_) {".to_string(),
-            "L16:             case Mode::Fast:".to_string(),
-            "L17:                 return fast();".to_string(),
-            "L18:             case Mode::Slow:".to_string(),
-            "L19:                 return slow();".to_string(),
-            "L20:             default:".to_string(),
-            "L21:                 return fallback();".to_string(),
-            "L22:         }".to_string(),
-        ]
-    );
-    Ok(())
-}
-
-#[tokio::test]
-async fn indentation_mode_handles_cpp_sample() -> anyhow::Result<()> {
-    let temp = write_cpp_sample()?;
-
-    let options = IndentationArgs {
-        include_siblings: false,
-        anchor_line: Some(18),
-        max_levels: 2,
-        ..Default::default()
-    };
-
-    let lines = read_block(temp.path(), 18, 200, options).await?;
-    assert_eq!(
-        lines,
-        vec![
-            "L13:     // Run the code".to_string(),
-            "L14:     int run() const {".to_string(),
-            "L15:         switch (mode_) {".to_string(),
-            "L16:             case Mode::Fast:".to_string(),
-            "L17:                 return fast();".to_string(),
-            "L18:             case Mode::Slow:".to_string(),
-            "L19:                 return slow();".to_string(),
-            "L20:             default:".to_string(),
-            "L21:                 return fallback();".to_string(),
-            "L22:         }".to_string(),
-            "L23:     }".to_string(),
-        ]
-    );
-    Ok(())
-}
-
-#[tokio::test]
-async fn indentation_mode_handles_cpp_sample_no_headers() -> anyhow::Result<()> {
-    let temp = write_cpp_sample()?;
-
-    let options = IndentationArgs {
-        include_siblings: false,
-        include_header: false,
-        anchor_line: Some(18),
-        max_levels: 2,
-        ..Default::default()
-    };
-
-    let lines = read_block(temp.path(), 18, 200, options).await?;
-    assert_eq!(
-        lines,
-        vec![
-            "L14:     int run() const {".to_string(),
-            "L15:         switch (mode_) {".to_string(),
-            "L16:             case Mode::Fast:".to_string(),
-            "L17:                 return fast();".to_string(),
-            "L18:             case Mode::Slow:".to_string(),
-            "L19:                 return slow();".to_string(),
-            "L20:             default:".to_string(),
-            "L21:                 return fallback();".to_string(),
-            "L22:         }".to_string(),
-            "L23:     }".to_string(),
-        ]
-    );
-    Ok(())
-}
-
-#[tokio::test]
-async fn indentation_mode_handles_cpp_sample_siblings() -> anyhow::Result<()> {
-    let temp = write_cpp_sample()?;
-
-    let options = IndentationArgs {
-        include_siblings: true,
-        include_header: false,
-        anchor_line: Some(18),
-        max_levels: 2,
-        ..Default::default()
-    };
-
-    let lines = read_block(temp.path(), 18, 200, options).await?;
-    assert_eq!(
-        lines,
-        vec![
-            "L7:     void setup() {".to_string(),
-            "L8:         if (enabled_) {".to_string(),
-            "L9:             init();".to_string(),
-            "L10:         }".to_string(),
-            "L11:     }".to_string(),
-            "L12: ".to_string(),
-            "L13:     // Run the code".to_string(),
-            "L14:     int run() const {".to_string(),
-            "L15:         switch (mode_) {".to_string(),
-            "L16:             case Mode::Fast:".to_string(),
-            "L17:                 return fast();".to_string(),
-            "L18:             case Mode::Slow:".to_string(),
-            "L19:                 return slow();".to_string(),
-            "L20:             default:".to_string(),
-            "L21:                 return fallback();".to_string(),
-            "L22:         }".to_string(),
-            "L23:     }".to_string(),
-        ]
-    );
-    Ok(())
-}