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
9fn 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
34fn 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
41fn spelled_type(name: &str) -> Option<Type> {
43 Type::from_name(name).filter(|ty| *ty != Type::Int || name == "int")
44}
45
46fn 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 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 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}