splice 2.9.2

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
122
123
124
125
126
127

//! Enhanced symbol extraction tests.
//!
//! TDD for Phase 1: Enhanced Symbol Storage
//! - module_path tracking
//! - fully_qualified name building
//! - visibility extraction

use splice::ingest::rust::{extract_rust_symbols, RustSymbolKind, Visibility};

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_extract_private_function_has_visibility() {
        // Source with private function (no pub modifier)
        let source = b"fn private_fn() {}\n";

        let symbols = extract_rust_symbols(std::path::Path::new("/tmp/test.rs"), source)
            .expect("Failed to parse");

        assert_eq!(symbols.len(), 1);
        assert_eq!(symbols[0].name, "private_fn");
        assert_eq!(symbols[0].kind, RustSymbolKind::Function);
        assert_eq!(symbols[0].visibility, Visibility::Private);
    }

    #[test]
    fn test_extract_public_function_has_pub_visibility() {
        // Source with public function
        let source = b"pub fn public_fn() {}\n";

        let symbols = extract_rust_symbols(std::path::Path::new("/tmp/test.rs"), source)
            .expect("Failed to parse");

        assert_eq!(symbols.len(), 1);
        assert_eq!(symbols[0].name, "public_fn");
        assert_eq!(symbols[0].visibility, Visibility::Public);
    }

    #[test]
    fn test_extract_pub_crate_function_has_restricted_visibility() {
        // Source with pub(crate) function
        let source = b"pub(crate) fn crate_fn() {}\n";

        let symbols = extract_rust_symbols(std::path::Path::new("/tmp/test.rs"), source)
            .expect("Failed to parse");

        assert_eq!(symbols.len(), 1);
        assert_eq!(symbols[0].name, "crate_fn");
        assert_eq!(
            symbols[0].visibility,
            Visibility::Restricted("pub(crate)".to_string())
        );
    }

    #[test]
    fn test_extract_public_struct() {
        // Source with public struct
        let source = b"pub struct MyStruct;\n";

        let symbols = extract_rust_symbols(std::path::Path::new("/tmp/test.rs"), source)
            .expect("Failed to parse");

        assert_eq!(symbols.len(), 1);
        assert_eq!(symbols[0].name, "MyStruct");
        assert_eq!(symbols[0].kind, RustSymbolKind::Struct);
        assert_eq!(symbols[0].visibility, Visibility::Public);
    }

    #[test]
    fn test_extract_module_declaration() {
        // Source with module declaration
        let source = b"mod my_module;\n";

        let symbols = extract_rust_symbols(std::path::Path::new("/tmp/test.rs"), source)
            .expect("Failed to parse");

        assert_eq!(symbols.len(), 1);
        assert_eq!(symbols[0].name, "my_module");
        assert_eq!(symbols[0].kind, RustSymbolKind::Module);
        // Module declarations have no explicit pub modifier, detected as Private
        // (though they can be imported within the crate)
        assert_eq!(symbols[0].visibility, Visibility::Private);
    }

    #[test]
    fn test_fully_qualified_name_for_crate_level_function() {
        // Source with crate-level function (no module)
        let source = b"pub fn crate_fn() {}\n";

        let symbols = extract_rust_symbols(std::path::Path::new("/tmp/test.rs"), source)
            .expect("Failed to parse");

        assert_eq!(symbols.len(), 1);
        // At crate level, fully_qualified = "crate::<name>"
        assert_eq!(symbols[0].fully_qualified, "crate::crate_fn");
        assert_eq!(symbols[0].module_path, "crate");
    }

    #[test]
    fn test_multiple_symbols_extracted() {
        // Source with multiple symbols
        let source = b"
            pub struct Foo;
            pub fn bar() {}
            mod baz {}
        ";

        let symbols = extract_rust_symbols(std::path::Path::new("/tmp/test.rs"), source)
            .expect("Failed to parse");

        assert_eq!(symbols.len(), 3);

        // Check struct
        assert_eq!(symbols[0].name, "Foo");
        assert_eq!(symbols[0].kind, RustSymbolKind::Struct);

        // Check function
        assert_eq!(symbols[1].name, "bar");
        assert_eq!(symbols[1].kind, RustSymbolKind::Function);

        // Check module
        assert_eq!(symbols[2].name, "baz");
        assert_eq!(symbols[2].kind, RustSymbolKind::Module);
    }
}