splice 2.6.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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176

use crate::completion::context::CompletionContext;
use crate::completion::types::{CompletionSuggestion, SuggestionSource, SymbolKind};

pub struct SuggestionRanker {
    weights: RankingWeights,
}

#[derive(Debug, Clone)]
pub struct RankingWeights {
    pub frequency: f32,
    pub proximity: f32,
    pub kind_match: f32,
    pub text_match: f32,
    pub import_proximity: f32,
}

impl Default for SuggestionRanker {
    fn default() -> Self {
        Self {
            weights: RankingWeights {
                frequency: 0.25,
                proximity: 0.25,
                kind_match: 0.15,
                text_match: 0.20,
                import_proximity: 0.15,
            },
        }
    }
}

impl SuggestionRanker {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn rank_suggestions(
        &self,
        suggestions: Vec<CompletionSuggestion>,
        context: &CompletionContext,
    ) -> Vec<CompletionSuggestion> {
        // Filter by current token if user is typing something
        let mut filtered = if let Some(ref token) = context.current_token {
            let token_lower = token.to_lowercase();
            suggestions
                .into_iter()
                .filter(|s| {
                    s.label.to_lowercase().starts_with(&token_lower)
                        || s.label.to_lowercase().contains(&token_lower)
                })
                .collect()
        } else {
            suggestions
        };

        for suggestion in &mut filtered {
            suggestion.score = self.calculate_score(suggestion, context);
        }

        let mut ranked: Vec<CompletionSuggestion> = filtered;
        ranked.sort_by(|a, b| {
            b.score
                .partial_cmp(&a.score)
                .unwrap_or(std::cmp::Ordering::Equal)
        });

        ranked
    }

    fn calculate_score(
        &self,
        suggestion: &CompletionSuggestion,
        context: &CompletionContext,
    ) -> f32 {
        let frequency_score = self.normalize_frequency(suggestion.usage_count);
        let proximity_score = self.calculate_proximity(suggestion, context);
        let kind_score = self.calculate_kind_match(suggestion, context);
        let text_match_score = self.calculate_text_match(suggestion, context);
        let import_score = self.calculate_import_proximity(suggestion, context);

        self.weights.frequency * frequency_score
            + self.weights.proximity * proximity_score
            + self.weights.kind_match * kind_score
            + self.weights.text_match * text_match_score
            + self.weights.import_proximity * import_score
    }

    fn normalize_frequency(&self, count: usize) -> f32 {
        1.0 - (1.0 / (1.0 + count as f32))
    }

    fn calculate_proximity(
        &self,
        suggestion: &CompletionSuggestion,
        context: &CompletionContext,
    ) -> f32 {
        // Check if suggestion is in same function/module
        if let Some(ref func) = context.enclosing_function {
            // Same function = high proximity
            if suggestion.grounded_in.contains(&func.id) {
                return 1.0;
            }
        }

        // Check if suggestion is imported (cross-file but in scope)
        if matches!(suggestion.source, SuggestionSource::Imported) {
            return 0.85; // High: explicitly imported
        }

        // Same file = medium proximity
        if matches!(suggestion.source, SuggestionSource::Database) {
            return 0.6; // Medium: same file
        }

        0.3 // Low: other sources
    }

    fn calculate_kind_match(
        &self,
        suggestion: &CompletionSuggestion,
        _context: &CompletionContext,
    ) -> f32 {
        // Functions preferred when in function body
        // Structs preferred when in type context
        match suggestion.kind {
            SymbolKind::Function => 0.8,
            SymbolKind::Struct => 0.7,
            SymbolKind::Enum => 0.7,
            SymbolKind::Trait => 0.6,
            SymbolKind::Module => 0.5,
            _ => 0.4,
        }
    }

    fn calculate_text_match(
        &self,
        suggestion: &CompletionSuggestion,
        context: &CompletionContext,
    ) -> f32 {
        if let Some(ref token) = context.current_token {
            let label_lower = suggestion.label.to_lowercase();
            let token_lower = token.to_lowercase();

            // Exact prefix match = highest score
            if label_lower.starts_with(&token_lower) {
                return 1.0;
            }

            // Contains match = medium score
            if label_lower.contains(&token_lower) {
                return 0.7;
            }

            // No match = low score (shouldn't happen due to filtering)
            0.3
        } else {
            // No token filter = neutral score
            0.5
        }
    }

    fn calculate_import_proximity(
        &self,
        suggestion: &CompletionSuggestion,
        _context: &CompletionContext,
    ) -> f32 {
        if matches!(suggestion.source, SuggestionSource::Imported) {
            // Explicit imports get high score
            if suggestion.via_import.is_some() {
                return 1.0;
            }
            return 0.7;
        }

        0.0 // Not imported
    }
}