Skip to main content

runec/
arguments.rs

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, &params, 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    // An enum's first argument names the type of its key.
124    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            // `null` is a string where the strings still to come can't fill the stack.
226            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}