splice 2.6.4

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
128
129
130

//! Symbol reference finding using tree-sitter.
//!
//! This module provides accurate reference location for symbols,
//! enabling safe deletion operations by finding all usages.
//!
//! # Architecture
//! - Same-file references: 100% accuracy via AST traversal
//! - Cross-file references: 95-98% accuracy via import analysis
//!
//! # Key Concepts
//! - **Reference**: Any identifier that refers to a symbol definition
//! - **Shadowing**: Local definitions that shadow imported symbols
//! - **Visibility**: Private symbols only have same-file references

pub mod rust;

use crate::error::Result;
use crate::ingest::rust::RustSymbolKind;
use std::path::Path;

/// A reference to a symbol found in source code.
#[derive(Debug, Clone, PartialEq)]
pub struct Reference {
    /// File containing the reference.
    pub file_path: String,

    /// Byte start offset of the reference.
    pub byte_start: usize,

    /// Byte end offset of the reference.
    pub byte_end: usize,

    /// Line number (1-based).
    pub line: usize,

    /// Column number (0-based, in bytes).
    pub column: usize,

    /// Context around the reference for verification.
    pub context: ReferenceContext,

    /// Symbol resolution match ID (None for references from find_references)
    ///
    /// This field is populated when the reference comes from a resolve_symbol()
    /// call, but is None for references found by find_references() since those
    /// don't go through the resolution process.
    pub match_id: Option<String>,
}

/// Context information about a reference.
#[derive(Debug, Clone, PartialEq)]
pub enum ReferenceContext {
    /// Function call: `foo()` or `module::foo()`
    FunctionCall {
        /// Whether called through a path (e.g., `crate::module::foo()`)
        is_qualified: bool,
    },

    /// Type reference: `struct_name`, `impl StructName`
    TypeReference,

    /// Identifier expression: `let x = foo;`
    Identifier,

    /// Path expression in use statement: `use crate::foo::Bar;`
    ImportStatement,

    /// Field access: `struct.field` (for struct field references)
    FieldAccess,

    /// Generic type parameter: `foo<T>()`
    GenericParameter,
}

/// Result of finding references to a symbol.
#[derive(Debug, Clone)]
pub struct ReferenceSet {
    /// All references found (including same-file and cross-file).
    pub references: Vec<Reference>,

    /// The symbol definition being referenced.
    pub definition: SymbolDefinition,

    /// Whether any cross-file glob imports were found
    /// (reduces confidence since we can't enumerate glob exports).
    pub has_glob_ambiguity: bool,
}

/// Information about the symbol definition.
#[derive(Debug, Clone)]
pub struct SymbolDefinition {
    /// Symbol name.
    pub name: String,

    /// Symbol kind.
    pub kind: RustSymbolKind,

    /// File containing the definition.
    pub file_path: String,

    /// Byte span of the definition.
    pub byte_start: usize,

    /// Byte end offset of the definition.
    pub byte_end: usize,

    /// Whether the symbol is public.
    pub is_public: bool,
}

/// Find all references to a symbol.
///
/// # Arguments
/// * `graph` - The code graph database
/// * `file_path` - Path to the file containing the symbol definition
/// * `symbol_name` - Name of the symbol to find references for
/// * `symbol_kind` - Optional kind filter
///
/// # Returns
/// * `Ok(ReferenceSet)` - All references found
/// * `Err(SpliceError)` - Symbol not found or parse error
pub fn find_references(
    graph: &crate::graph::CodeGraph,
    file_path: &Path,
    symbol_name: &str,
    symbol_kind: Option<RustSymbolKind>,
) -> Result<ReferenceSet> {
    // Delegate to language-specific implementation
    rust::find_rust_references(graph, file_path, symbol_name, symbol_kind)
}