1use crate::clientscript::hook_types;
2use crate::parser::Expr;
3use crate::symbol::{ReturnType, SymbolKind, SymbolRegistry, SymbolTable};
4use crate::types::{BaseVarType, Type};
5use std::collections::VecDeque;
6
7fn stack(ty: Type) -> usize {
8 match ty.base_type() {
9 BaseVarType::Integer => 0,
10 BaseVarType::String => 1,
11 BaseVarType::Long => 2,
12 }
13}
14
15pub fn expression_types(expr: &Expr, registry: &SymbolRegistry, locals: &SymbolTable) -> Vec<Type> {
16 let symbol = match expr {
17 Expr::Tuple(values) | Expr::MultiAssign(values, _) => {
18 return values
19 .iter()
20 .flat_map(|value| expression_types(value, registry, locals))
21 .collect();
22 }
23 Expr::StringLiteral(_) | Expr::JoinedString { .. } => return vec![Type::String],
24 Expr::LongLiteral(_) => return vec![Type::Long],
25 Expr::LocalVar(name, _) | Expr::ArrayAccess { name, .. } => locals.lookup(name),
26 Expr::GameVar(name, _) => registry.lookup_game_var(name.trim_start_matches('.')),
27 Expr::ConstantVar(name, _) => registry.lookup_constant(name),
28 Expr::CommandCall { name, args, .. } => return command_returns(registry, name, args),
29 Expr::Identifier(name) => registry
30 .lookup_command(name.trim_start_matches('.'))
31 .or_else(|| registry.lookup_constant(name)),
32 Expr::ProcCall { name, .. } => registry
33 .lookup_script_by_trigger("proc", name)
34 .or_else(|| registry.lookup_script_by_trigger("clientscript", name)),
35 Expr::Calc(value) | Expr::BinaryOp { lhs: value, .. } => {
36 return expression_types(value, registry, locals);
37 }
38 _ => None,
39 };
40 match symbol.map(|symbol| &symbol.kind) {
41 Some(SymbolKind::LocalVar { var_type, .. } | SymbolKind::GameVar { var_type, .. }) => {
42 vec![*var_type]
43 }
44 Some(SymbolKind::ScriptParam { param_type, .. }) => vec![*param_type],
45 Some(SymbolKind::Constant { const_type, .. }) => vec![*const_type],
46 Some(
47 SymbolKind::Command { return_types, .. } | SymbolKind::Script { return_types, .. },
48 ) => return_types.clone(),
49 _ => vec![Type::Int],
50 }
51}
52
53pub fn command_returns(registry: &SymbolRegistry, name: &str, args: &[Expr]) -> Vec<Type> {
54 let name = name.trim_start_matches('.');
55 match name {
56 "__pop_int" | "__get_array" => return vec![Type::Int],
57 "__pop_string" | "__join" => return vec![Type::String],
58 "__pop_long" => return vec![Type::Long],
59 _ => {}
60 }
61 let value = |index: usize, hint: Type| {
62 args.get(index).and_then(|arg| match arg {
63 Expr::IntLiteral(value) => Some(*value),
64 Expr::CharLiteral(value) => Some(*value as i32),
65 Expr::Identifier(name) => registry
66 .lookup_reference(name, hint)
67 .or_else(|| registry.type_chars.get(name).copied()),
68 Expr::ConstantVar(name, _) => registry.lookup_constant(name).and_then(|symbol| {
69 if let SymbolKind::Constant { int_value, .. } = symbol.kind {
70 int_value
71 } else {
72 None
73 }
74 }),
75 _ => None,
76 })
77 };
78 let dynamic = match registry.dynamic_returns.get(name) {
79 Some(ReturnType::TypeArgument(index)) => value(*index, Type::Int)
80 .and_then(|value| char::from_u32(value as u32))
81 .and_then(Type::from_char),
82 Some(ReturnType::ParamArgument(index)) => value(*index, Type::Param)
83 .map(|id| registry.param_types.get(&id).copied().unwrap_or(Type::Int)),
84 None => None,
85 };
86 if let Some(ty) = dynamic {
87 return vec![ty];
88 }
89 match registry.lookup_command(name).map(|symbol| &symbol.kind) {
90 Some(SymbolKind::Command { return_types, .. }) => return_types.clone(),
91 _ => Vec::new(),
92 }
93}
94
95pub fn command_hints(
96 registry: &SymbolRegistry,
97 name: &str,
98 args: &[Expr],
99 locals: &SymbolTable,
100) -> Vec<Option<Type>> {
101 let params = command_parameters(registry, name, args, locals);
102 if registry.stack_commands.contains(name) {
103 positional_hints(registry, ¶ms, args, locals)
104 } else {
105 (0..args.len()).map(|i| params.get(i).copied()).collect()
106 }
107}
108
109pub(crate) fn command_parameters(
110 registry: &SymbolRegistry,
111 name: &str,
112 args: &[Expr],
113 locals: &SymbolTable,
114) -> Vec<Type> {
115 let mut params = registry
116 .command_param_types
117 .get(name)
118 .cloned()
119 .unwrap_or_default();
120 if !registry.stack_commands.contains(name) {
121 return params;
122 }
123 if matches!(
125 registry.dynamic_returns.get(name),
126 Some(ReturnType::TypeArgument(1))
127 ) && let Some(Expr::Identifier(key)) = args.first()
128 && let Some(ty) = Type::from_name(key)
129 && let Some(slot) = params.last_mut()
130 {
131 *slot = ty;
132 }
133 if let Some(&explicit) = registry.hook_commands.get(name)
134 && let Some(signature) = args.iter().rev().find_map(|arg| match arg {
135 Expr::StringLiteral(value) => Some(value.as_str()),
136 _ => None,
137 })
138 {
139 let triggers = if signature.ends_with('Y') {
140 args.iter()
141 .rev()
142 .filter(|arg| {
143 expression_types(arg, registry, locals)
144 .first()
145 .is_some_and(|ty| stack(*ty) == 0)
146 })
147 .nth(usize::from(
148 explicit && !registry.component_first_command(name),
149 ))
150 .and_then(|arg| match arg {
151 Expr::IntLiteral(n) => usize::try_from(*n).ok(),
152 _ => None,
153 })
154 .unwrap_or(0)
155 } else {
156 0
157 };
158 params = hook_types(signature, triggers, explicit);
159 if registry.component_first_command(name) {
160 params.rotate_right(1);
161 }
162 }
163 params
164}
165
166pub fn proc_hints(
167 registry: &SymbolRegistry,
168 name: &str,
169 args: &[Expr],
170 locals: &SymbolTable,
171) -> Vec<Option<Type>> {
172 let symbol = registry
173 .lookup_script_by_trigger("proc", name)
174 .or_else(|| registry.lookup_script_by_trigger("clientscript", name));
175 let Some(SymbolKind::Script {
176 trigger,
177 param_types,
178 ..
179 }) = symbol.map(|symbol| &symbol.kind)
180 else {
181 return vec![None; args.len()];
182 };
183 if registry
184 .stack_scripts
185 .contains(&format!("{trigger}:{name}"))
186 {
187 positional_hints(registry, param_types, args, locals)
188 } else {
189 (0..args.len())
190 .map(|i| param_types.get(i).copied())
191 .collect()
192 }
193}
194
195pub fn positional_hints(
196 registry: &SymbolRegistry,
197 params: &[Type],
198 args: &[Expr],
199 locals: &SymbolTable,
200) -> Vec<Option<Type>> {
201 let mut slot = 0;
202 args.iter()
203 .map(|arg| {
204 let hint = params.get(slot).copied();
205 slot += expression_types(arg, registry, locals).len().max(1);
206 hint
207 })
208 .collect()
209}
210
211pub fn stack_hints(
212 registry: &SymbolRegistry,
213 params: &[Type],
214 args: &[Expr],
215 locals: &SymbolTable,
216) -> Vec<Option<Type>> {
217 let mut pending: [VecDeque<Type>; 3] = Default::default();
218 for &ty in params {
219 pending[stack(ty)].push_back(ty);
220 }
221 args.iter()
222 .enumerate()
223 .map(|(i, arg)| {
224 let mut types = expression_types(arg, registry, locals);
225 if matches!(arg, Expr::NullLiteral)
227 && (pending[0].is_empty()
228 || pending[1].len()
229 > args[i + 1..]
230 .iter()
231 .flat_map(|arg| expression_types(arg, registry, locals))
232 .filter(|ty| stack(*ty) == 1)
233 .count())
234 {
235 types = vec![Type::String];
236 }
237 if let Expr::StringLiteral(name) | Expr::Identifier(name) = arg
238 && let Some(&ty) = pending[0].front()
239 && registry.lookup_reference(name, ty).is_some()
240 && (matches!(arg, Expr::Identifier(_))
241 || args[i..]
242 .iter()
243 .flat_map(|arg| expression_types(arg, registry, locals))
244 .filter(|ty| stack(*ty) == 1)
245 .count()
246 > pending[1].len())
247 {
248 types = vec![ty];
249 }
250 let hint = types
251 .first()
252 .and_then(|ty| pending[stack(*ty)].front().copied());
253 for ty in types {
254 pending[stack(ty)].pop_front();
255 }
256 hint
257 })
258 .collect()
259}