rototo 0.1.0-alpha.4

Control plane for runtime configuration of your application.
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

use crate::diagnostics::{DiagnosticLocation, SourcePosition};

use super::super::WorkspaceLintSnapshot;
use super::WorkspaceReference;

pub(crate) fn references(
    snapshot: &WorkspaceLintSnapshot,
    path: &str,
    position: SourcePosition,
    include_declaration: bool,
) -> Vec<WorkspaceReference> {
    let Some(target) = snapshot.references.target_at_position(path, position) else {
        return Vec::new();
    };

    let mut locations = snapshot.references.reference_locations(&target);
    if include_declaration && let Some(declaration) = snapshot.references.declaration(&target) {
        locations.push(declaration);
    }

    references_from_locations(snapshot, locations)
}

fn references_from_locations(
    snapshot: &WorkspaceLintSnapshot,
    locations: Vec<DiagnosticLocation>,
) -> Vec<WorkspaceReference> {
    let mut references = locations
        .into_iter()
        .filter_map(|mut location| {
            let document = snapshot
                .lint
                .documents
                .iter()
                .find(|document| document.path == location.path)?;
            location.doc = Some(document.id);
            Some(WorkspaceReference {
                uri: document.uri.clone(),
                location,
            })
        })
        .collect::<Vec<_>>();
    sort_and_deduplicate_workspace_references(&mut references);
    references
}

fn sort_and_deduplicate_workspace_references(references: &mut Vec<WorkspaceReference>) {
    references.sort_by(|left, right| {
        left.uri.cmp(&right.uri).then_with(|| {
            source_location_sort_key(&left.location).cmp(&source_location_sort_key(&right.location))
        })
    });
    references.dedup_by(|left, right| {
        left.uri == right.uri
            && source_location_sort_key(&left.location) == source_location_sort_key(&right.location)
    });
}

fn source_location_sort_key(location: &DiagnosticLocation) -> (usize, usize, usize, usize) {
    location
        .range
        .map(|range| {
            (
                range.start.line,
                range.start.character,
                range.end.line,
                range.end.character,
            )
        })
        .unwrap_or((0, 0, 0, 0))
}