splice 2.8.0

Span-safe refactoring kernel for 7 languages with Magellan code graph integration
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

//! Integration tests for io error path preservation (Bug B3).
//!
//! Verifies that `splice patch` errors include the real file path in the
//! error message, not the literal `<unknown>` placeholder produced by
//! the bare `?` propagation of `std::io::Error`.

#[cfg(test)]
mod tests {
    use std::io::Write;
    use std::path::PathBuf;
    use std::process::Command;
    use tempfile::NamedTempFile;

    fn get_splice_binary() -> PathBuf {
        if let Ok(path) = std::env::var("SPLICE_TEST_BIN") {
            return PathBuf::from(path);
        }
        if let Ok(path) = std::env::var("CARGO_BIN_EXE_splice") {
            return PathBuf::from(path);
        }
        let mut path = std::env::current_exe().unwrap();
        path.pop(); // deps
        path.pop(); // debug
        path.push("splice");
        path
    }

    fn make_temp_replacement() -> NamedTempFile {
        let mut file = NamedTempFile::with_suffix(".rs").unwrap();
        file.write_all(b"pub fn x() {}\n").unwrap();
        file
    }

    #[test]
    fn test_patch_missing_source_file_reports_real_path() {
        let replacement = make_temp_replacement();
        let missing_source = "/nonexistent_splice_test_dir/missing_source_file.rs";

        let output = Command::new(get_splice_binary())
            .arg("patch")
            .arg("--file")
            .arg(missing_source)
            .arg("--symbol")
            .arg("x")
            .arg("--with")
            .arg(replacement.path())
            .arg("--output")
            .arg("json")
            .output()
            .expect("failed to run splice");

        let stdout = String::from_utf8_lossy(&output.stdout);
        let stderr = String::from_utf8_lossy(&output.stderr);
        let combined = format!("{}{}", stdout, stderr);

        assert!(
            !output.status.success(),
            "splice should fail when --file is missing"
        );
        assert!(
            !combined.contains("I/O error for path <unknown>"),
            "error message should not contain B3-style 'I/O error for path <unknown>'. Got: {}",
            combined
        );
        assert!(
            combined.contains(missing_source),
            "error message should mention the real missing path '{}'. Got: {}",
            missing_source,
            combined
        );
    }

    #[test]
    fn test_patch_missing_replacement_file_reports_real_path() {
        // Create a real source file so the source-read step succeeds.
        let temp_dir = tempfile::tempdir().unwrap();
        let cargo_toml = temp_dir.path().join("Cargo.toml");
        std::fs::write(
            &cargo_toml,
            "[package]\nname = \"t\"\nversion = \"0.1.0\"\nedition = \"2021\"\n",
        )
        .unwrap();
        let source = temp_dir.path().join("src.rs");
        std::fs::write(&source, "pub fn x() {}\n").unwrap();

        let missing_replacement = "/nonexistent_splice_test_dir/missing_replacement.rs";

        let output = Command::new(get_splice_binary())
            .arg("patch")
            .arg("--file")
            .arg(&source)
            .arg("--symbol")
            .arg("x")
            .arg("--with")
            .arg(missing_replacement)
            .arg("--output")
            .arg("json")
            .output()
            .expect("failed to run splice");

        let stdout = String::from_utf8_lossy(&output.stdout);
        let stderr = String::from_utf8_lossy(&output.stderr);
        let combined = format!("{}{}", stdout, stderr);

        assert!(
            !output.status.success(),
            "splice should fail when --with is missing"
        );
        assert!(
            !combined.contains("I/O error for path <unknown>"),
            "error message should not contain B3-style 'I/O error for path <unknown>'. Got: {}",
            combined
        );
        assert!(
            combined.contains(missing_replacement),
            "error message should mention the real missing path '{}'. Got: {}",
            missing_replacement,
            combined
        );
    }
}