rumoca 0.7.28

Modelica compiler written in RUST
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

//! Find All References handler for Modelica files.
//!
//! Finds all usages of a symbol (variable, class, function) across the document.

use std::collections::HashMap;

use lsp_types::{Location, ReferenceParams, Uri};

use crate::ir::ast::{ClassDefinition, Component, ComponentReference, ForIndex, Token};
use crate::ir::visitor::{Visitable, Visitor};

use crate::lsp::utils::{get_word_at_position, parse_document, token_to_range};

/// Visitor that finds all references to a specific symbol name
struct ReferenceFinder<'a> {
    /// The symbol name to find
    name: &'a str,
    /// The URI for creating Location objects
    uri: &'a Uri,
    /// Whether to include declarations
    include_declaration: bool,
    /// Collected locations
    locations: Vec<Location>,
}

impl<'a> ReferenceFinder<'a> {
    fn new(name: &'a str, uri: &'a Uri, include_declaration: bool) -> Self {
        Self {
            name,
            uri,
            include_declaration,
            locations: Vec::new(),
        }
    }

    fn add_location_from_token(&mut self, token: &Token) {
        self.locations.push(Location {
            uri: self.uri.clone(),
            range: token_to_range(token),
        });
    }
}

impl Visitor for ReferenceFinder<'_> {
    fn enter_class_definition(&mut self, node: &ClassDefinition) {
        // Check class name (declaration)
        if node.name.text == self.name && self.include_declaration {
            self.add_location_from_token(&node.name);
        }

        // Check nested class names (declarations)
        for (nested_name, nested_class) in &node.classes {
            if nested_name == self.name && self.include_declaration {
                self.add_location_from_token(&nested_class.name);
            }
        }
    }

    fn enter_component(&mut self, node: &Component) {
        // Check component name (declaration)
        if node.name_token.text == self.name && self.include_declaration {
            self.add_location_from_token(&node.name_token);
        }

        // Check type name references
        for token in &node.type_name.name {
            if token.text == self.name {
                self.add_location_from_token(token);
            }
        }
    }

    fn enter_component_reference(&mut self, node: &ComponentReference) {
        for part in &node.parts {
            if part.ident.text == self.name {
                self.add_location_from_token(&part.ident);
            }
        }
    }

    fn enter_for_index(&mut self, node: &ForIndex) {
        if node.ident.text == self.name {
            self.add_location_from_token(&node.ident);
        }
    }
}

/// Handle find references request
pub fn handle_references(
    documents: &HashMap<Uri, String>,
    params: ReferenceParams,
) -> Option<Vec<Location>> {
    let uri = &params.text_document_position.text_document.uri;
    let position = params.text_document_position.position;
    let include_declaration = params.context.include_declaration;

    let text = documents.get(uri)?;
    let path = uri.path().as_str();

    let word = get_word_at_position(text, position)?;
    let ast = parse_document(text, path)?;

    let mut finder = ReferenceFinder::new(&word, uri, include_declaration);
    ast.accept(&mut finder);

    if finder.locations.is_empty() {
        None
    } else {
        Some(finder.locations)
    }
}