Skip to main content

runec/ide/
hints.rs

1use super::index::Lexeme;
2use super::{InlayHint, ScriptPointers, Symbol, SymbolKind, index};
3use crate::effects::ScriptEffects;
4use crate::project::{Project, SourceId};
5use crate::token::Kind;
6use crate::types::{BaseVarType, Type};
7use std::ops::Range;
8
9/// Literals and `calc` say nothing about their role; names and calls do.
10fn unclear(argument: &[(Lexeme<'_>, Range<usize>)]) -> bool {
11    match argument.first().map(|(token, _)| token.kind) {
12        Some(
13            Kind::Number
14            | Kind::LongLiteral
15            | Kind::StringLiteral
16            | Kind::RawStringLiteral
17            | Kind::BooleanTrue
18            | Kind::BooleanFalse
19            | Kind::CharLiteral
20            | Kind::CoordLiteral
21            | Kind::Null
22            | Kind::Calc,
23        ) => true,
24        Some(Kind::BinaryOperator) => {
25            argument[0].0.value == "-"
26                && argument.get(1).is_some_and(|(token, _)| {
27                    matches!(token.kind, Kind::Number | Kind::LongLiteral)
28                })
29        }
30        _ => false,
31    }
32}
33
34/// The name without `$` or a numeric suffix, and whether it had the suffix.
35fn stem(name: &str) -> (&str, bool) {
36    let name = name.trim_start_matches('$');
37    let stem = name.trim_end_matches(|c: char| c.is_ascii_digit());
38    (stem, stem.len() < name.len())
39}
40
41/// The type a name spells. `command` and `type` parse as `int` but are not its name.
42fn spelled_type(name: &str) -> Option<Type> {
43    Type::from_name(name).filter(|ty| *ty != Type::Int || name == "int")
44}
45
46/// Whether a parameter name tells more than its type, its numbered siblings and
47/// the call's own name. Hook parameters take callbacks, which name themselves.
48fn descriptive(name: &str, ty: Type, callee: &Symbol) -> bool {
49    if ty == Type::ClientScript {
50        return false;
51    }
52    let (stem, numbered) = stem(name);
53    let stack = match ty.base_type() {
54        BaseVarType::Integer => "int",
55        BaseVarType::String => "string",
56        BaseVarType::Long => "long",
57    };
58    if stem == ty.name()
59        || stem == ty.declared_name()
60        || stem == stack
61        || spelled_type(stem) == Some(ty)
62    {
63        return false;
64    }
65    if numbered
66        && (spelled_type(stem).is_some()
67            || callee
68                .parameters
69                .iter()
70                .filter(|(other, _)| self::stem(other) == (stem, true))
71                .count()
72                > 1)
73    {
74        return false;
75    }
76    !(stem.len() >= 3 && callee.name.contains(stem))
77}
78
79impl Project {
80    /// Cached AST effects, with pointer requirements attached only when already checked.
81    pub fn script_effects(&self, source: SourceId) -> Vec<ScriptEffects> {
82        let Some(document) = self.document(source) else {
83            return Vec::new();
84        };
85        let Some(file) = document.syntax() else {
86            return Vec::new();
87        };
88        let Some(effects) = self.effect_summaries() else {
89            return Vec::new();
90        };
91        let requirements = self
92            .pointer_requirements
93            .as_ref()
94            .filter(|(generation, _)| *generation == self.generation)
95            .and_then(|(_, sources)| sources.get(&source));
96        file.scripts
97            .iter()
98            .filter_map(|script| {
99                if script.trigger == "command" {
100                    return None;
101                }
102                let name = format!("[{},{}]", script.trigger, script.name);
103                let summary = effects.scripts.get(&(source, script.line, name.clone()))?;
104                let line = document.lines.line(script.line.saturating_sub(1))?;
105                let text = &document.text[line.clone()];
106                let start = line.start + text.len() - text.trim_start().len();
107                Some(ScriptEffects {
108                    range: start..start,
109                    may_suspend: summary.may_suspend,
110                    writes: summary.writes.iter().cloned().collect(),
111                    incomplete: summary.incomplete,
112                    required: requirements
113                        .and_then(|requirements| requirements.get(&name))
114                        .copied(),
115                })
116            })
117            .collect()
118    }
119
120    /// Entry pointer requirements from the latest completed `check`. Stale or
121    /// unavailable analysis produces no annotations.
122    pub fn script_pointers(&self, source: SourceId) -> Vec<ScriptPointers> {
123        if !self.pointer_requirements_ready() {
124            return Vec::new();
125        }
126        let Some(document) = self.document(source) else {
127            return Vec::new();
128        };
129        let Some(file) = document.syntax() else {
130            return Vec::new();
131        };
132        let Some(requirements) = self.pointer_requirements.as_ref().unwrap().1.get(&source) else {
133            return Vec::new();
134        };
135        file.scripts
136            .iter()
137            .filter(|script| script.trigger != "command")
138            .filter_map(|script| {
139                let name = format!("[{},{}]", script.trigger, script.name);
140                let required = *requirements.get(&name)?;
141                let line = document.lines.line(script.line.saturating_sub(1))?;
142                let text = &document.text[line.clone()];
143                let start = line.start + text.len() - text.trim_start().len();
144                Some(ScriptPointers {
145                    range: start..start,
146                    required,
147                })
148            })
149            .collect()
150    }
151
152    pub fn inlay_hints(&self, source: SourceId, range: Range<usize>) -> Vec<InlayHint> {
153        let Some(document) = self.document(source) else {
154            return Vec::new();
155        };
156        if document.config.is_some() {
157            return Vec::new();
158        }
159        let index = self.symbol_index();
160        let hooks = index.hooks.get(&source).map_or(&[][..], Vec::as_slice);
161        let tokens = index::tokens(document, &|name| index.is_compound(name), hooks);
162        let mut hints = Vec::new();
163        for reference in index
164            .references_in(source)
165            .filter(|reference| !reference.declaration)
166        {
167            let span = &reference.location.range;
168            if !range.contains(&span.start)
169                || document
170                    .tokens
171                    .iter()
172                    .zip(&document.spans)
173                    .any(|(token, range)| {
174                        matches!(token.kind, Kind::StringLiteral | Kind::RawStringLiteral)
175                            && range.contains(&span.start)
176                            && !hooks.iter().any(|hook| hook.range == *range)
177                    })
178            {
179                continue;
180            }
181            let symbol = index.symbol(reference.symbol);
182            if symbol.kind == SymbolKind::Constant {
183                if let Some(ty) = symbol.value_type {
184                    hints.push(InlayHint {
185                        offset: span.end,
186                        label: format!(": {}", ty.name()),
187                        parameter: false,
188                    });
189                }
190                continue;
191            }
192            if !matches!(
193                symbol.kind,
194                SymbolKind::Command
195                    | SymbolKind::Procedure
196                    | SymbolKind::Trigger
197                    | SymbolKind::ClientScript
198            ) || symbol.parameters.len() < 2
199            {
200                continue;
201            }
202            let next = tokens.partition_point(|(_, range)| range.start < span.end);
203            if tokens
204                .get(next)
205                .is_none_or(|(token, _)| token.kind != Kind::LParen)
206            {
207                continue;
208            }
209            let end = hooks[..hooks.partition_point(|hook| hook.range.start <= span.start)]
210                .last()
211                .filter(|hook| hook.range.contains(&span.start))
212                .map_or(usize::MAX, |hook| hook.range.end);
213            let mut depth = 0;
214            let mut argument = 0;
215            let mut argument_start = true;
216            let mut literal_end = 0;
217            for (i, (token, token_range)) in tokens.iter().enumerate().skip(next) {
218                if token_range.start >= end {
219                    break;
220                }
221                if token_range.start < literal_end {
222                    continue;
223                }
224                if token.kind == Kind::Semicolon {
225                    break;
226                }
227                if matches!(token.kind, Kind::StringLiteral | Kind::RawStringLiteral) {
228                    literal_end = token_range.end;
229                }
230                if depth == 1
231                    && argument_start
232                    && !matches!(
233                        token.kind,
234                        Kind::RParen | Kind::SingleLineComment | Kind::MultiLineComment
235                    )
236                {
237                    if let Some((name, ty)) = symbol.parameters.get(argument)
238                        && unclear(&tokens[i..])
239                        && descriptive(name, *ty, symbol)
240                    {
241                        hints.push(InlayHint {
242                            offset: token_range.start,
243                            label: format!("{}:", name.trim_start_matches('$')),
244                            parameter: true,
245                        });
246                    }
247                    argument_start = false;
248                }
249                match token.kind {
250                    Kind::LParen => depth += 1,
251                    Kind::RParen => {
252                        depth -= 1;
253                        if depth == 0 {
254                            break;
255                        }
256                    }
257                    Kind::Comma if depth == 1 => {
258                        argument += 1;
259                        argument_start = true;
260                    }
261                    _ => {}
262                }
263            }
264        }
265        hints.sort_by_key(|hint| hint.offset);
266        hints
267    }
268}