1// Copyright © SixtyFPS GmbH <info@slint.dev>
2// SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-Slint-Royalty-free-2.0 OR LicenseRef-Slint-Software-3.0
3
4//! This module contains the implementation of the builtin macros.
5//! They are just transformations that convert into some more complicated expression tree
6
7use crate::diagnostics::{BuildDiagnostics, Spanned};
8use crate::expression_tree::{
9 BuiltinFunction, BuiltinMacroFunction, Callable, EasingCurve, Expression, MinMaxOp, Unit,
10};
11use crate::langtype::{EnumerationValue, Type};
12use crate::parser::NodeOrToken;
13use smol_str::{format_smolstr, ToSmolStr};
14
15/// Used for uniquely name some variables
16static COUNTER: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(1);
17
18/// "Expand" the macro `mac` (at location `n`) with the arguments `sub_expr`
19pub fn lower_macro(
20 mac: BuiltinMacroFunction,
21 n: &dyn Spanned,
22 mut sub_expr: impl Iterator<Item = (Expression, Option<NodeOrToken>)>,
23 diag: &mut BuildDiagnostics,
24) -> Expression {
25 match mac {
26 BuiltinMacroFunction::Min => min_max_macro(n, MinMaxOp::Min, sub_expr.collect(), diag),
27 BuiltinMacroFunction::Max => min_max_macro(n, MinMaxOp::Max, sub_expr.collect(), diag),
28 BuiltinMacroFunction::Clamp => clamp_macro(n, sub_expr.collect(), diag),
29 BuiltinMacroFunction::Mod => mod_macro(n, sub_expr.collect(), diag),
30 BuiltinMacroFunction::Abs => abs_macro(n, sub_expr.collect(), diag),
31 BuiltinMacroFunction::Debug => debug_macro(n, sub_expr.collect(), diag),
32 BuiltinMacroFunction::CubicBezier => {
33 let mut has_error = None;
34 let expected_argument_type_error =
35 "Arguments to cubic bezier curve must be number literal";
36 // FIXME: this is not pretty to be handling there.
37 // Maybe "cubic_bezier" should be a function that is lowered later
38 let mut a = || match sub_expr.next() {
39 None => {
40 has_error.get_or_insert((n.to_source_location(), "Not enough arguments"));
41 0.
42 }
43 Some((Expression::NumberLiteral(val, Unit::None), _)) => val as f32,
44 // handle negative numbers
45 Some((Expression::UnaryOp { sub, op: '-' }, n)) => match *sub {
46 Expression::NumberLiteral(val, Unit::None) => (-1.0 * val) as f32,
47 _ => {
48 has_error
49 .get_or_insert((n.to_source_location(), expected_argument_type_error));
50 0.
51 }
52 },
53 Some((_, n)) => {
54 has_error.get_or_insert((n.to_source_location(), expected_argument_type_error));
55 0.
56 }
57 };
58 let expr = Expression::EasingCurve(EasingCurve::CubicBezier(a(), a(), a(), a()));
59 if let Some((_, n)) = sub_expr.next() {
60 has_error
61 .get_or_insert((n.to_source_location(), "Too many argument for bezier curve"));
62 }
63 if let Some((n, msg)) = has_error {
64 diag.push_error(msg.into(), &n);
65 }
66
67 expr
68 }
69 BuiltinMacroFunction::Rgb => rgb_macro(n, sub_expr.collect(), diag),
70 BuiltinMacroFunction::Hsv => hsv_macro(n, sub_expr.collect(), diag),
71 }
72}
73
74fn min_max_macro(
75 node: &dyn Spanned,
76 op: MinMaxOp,
77 args: Vec<(Expression, Option<NodeOrToken>)>,
78 diag: &mut BuildDiagnostics,
79) -> Expression {
80 if args.is_empty() {
81 diag.push_error(message:"Needs at least one argument".into(), source:node);
82 return Expression::Invalid;
83 }
84 let ty: Type = Expression::common_target_type_for_type_list(types:args.iter().map(|expr: &(Expression, Option)| expr.0.ty()));
85 if ty.as_unit_product().is_none() {
86 diag.push_error(message:"Invalid argument type".into(), source:node);
87 return Expression::Invalid;
88 }
89 let mut args: IntoIter<(Expression, Option<…>)> = args.into_iter();
90 let (base: Expression, arg_node: Option) = args.next().unwrap();
91 let mut base: Expression = base.maybe_convert_to(target_type:ty.clone(), &arg_node, diag);
92 for (next: Expression, arg_node: Option) in args {
93 let rhs: Expression = next.maybe_convert_to(target_type:ty.clone(), &arg_node, diag);
94 base = min_max_expression(lhs:base, rhs, op);
95 }
96 base
97}
98
99fn clamp_macro(
100 node: &dyn Spanned,
101 args: Vec<(Expression, Option<NodeOrToken>)>,
102 diag: &mut BuildDiagnostics,
103) -> Expression {
104 if args.len() != 3 {
105 diag.push_error(
106 message:"`clamp` needs three values: the `value` to clamp, the `minimum` and the `maximum`"
107 .into(),
108 source:node,
109 );
110 return Expression::Invalid;
111 }
112 let (value: Expression, value_node: Option) = args.first().unwrap().clone();
113 let ty: Type = value.ty();
114 if ty.as_unit_product().is_none() {
115 diag.push_error(message:"Invalid argument type".into(), &value_node);
116 return Expression::Invalid;
117 }
118
119 let (min: Expression, min_node: Option) = args.get(index:1).unwrap().clone();
120 let min: Expression = min.maybe_convert_to(target_type:ty.clone(), &min_node, diag);
121 let (max: Expression, max_node: Option) = args.get(index:2).unwrap().clone();
122 let max: Expression = max.maybe_convert_to(target_type:ty.clone(), &max_node, diag);
123
124 let value: Expression = min_max_expression(lhs:value, rhs:max, op:MinMaxOp::Min);
125 min_max_expression(lhs:min, rhs:value, op:MinMaxOp::Max)
126}
127
128fn mod_macro(
129 node: &dyn Spanned,
130 args: Vec<(Expression, Option<NodeOrToken>)>,
131 diag: &mut BuildDiagnostics,
132) -> Expression {
133 if args.len() != 2 {
134 diag.push_error("Needs 2 arguments".into(), node);
135 return Expression::Invalid;
136 }
137 let (lhs_ty, rhs_ty) = (args[0].0.ty(), args[1].0.ty());
138 let common_ty = if lhs_ty.default_unit().is_some() {
139 lhs_ty
140 } else if rhs_ty.default_unit().is_some() {
141 rhs_ty
142 } else if matches!(lhs_ty, Type::UnitProduct(_)) {
143 lhs_ty
144 } else if matches!(rhs_ty, Type::UnitProduct(_)) {
145 rhs_ty
146 } else {
147 Type::Float32
148 };
149
150 let source_location = Some(node.to_source_location());
151 let function = Callable::Builtin(BuiltinFunction::Mod);
152 let arguments = args.into_iter().map(|(e, n)| e.maybe_convert_to(common_ty.clone(), &n, diag));
153 if matches!(common_ty, Type::Float32) {
154 Expression::FunctionCall { function, arguments: arguments.collect(), source_location }
155 } else {
156 Expression::Cast {
157 from: Expression::FunctionCall {
158 function,
159 arguments: arguments
160 .map(|a| Expression::Cast { from: a.into(), to: Type::Float32 })
161 .collect(),
162 source_location,
163 }
164 .into(),
165 to: common_ty.clone(),
166 }
167 }
168}
169
170fn abs_macro(
171 node: &dyn Spanned,
172 args: Vec<(Expression, Option<NodeOrToken>)>,
173 diag: &mut BuildDiagnostics,
174) -> Expression {
175 if args.len() != 1 {
176 diag.push_error("Needs 1 argument".into(), node);
177 return Expression::Invalid;
178 }
179 let ty = args[0].0.ty();
180 let ty = if ty.default_unit().is_some() || matches!(ty, Type::UnitProduct(_)) {
181 ty
182 } else {
183 Type::Float32
184 };
185
186 let source_location = Some(node.to_source_location());
187 let function = Callable::Builtin(BuiltinFunction::Abs);
188 if matches!(ty, Type::Float32) {
189 let arguments =
190 args.into_iter().map(|(e, n)| e.maybe_convert_to(ty.clone(), &n, diag)).collect();
191 Expression::FunctionCall { function, arguments, source_location }
192 } else {
193 Expression::Cast {
194 from: Expression::FunctionCall {
195 function,
196 arguments: args
197 .into_iter()
198 .map(|(a, _)| Expression::Cast { from: a.into(), to: Type::Float32 })
199 .collect(),
200 source_location,
201 }
202 .into(),
203 to: ty,
204 }
205 }
206}
207
208fn rgb_macro(
209 node: &dyn Spanned,
210 args: Vec<(Expression, Option<NodeOrToken>)>,
211 diag: &mut BuildDiagnostics,
212) -> Expression {
213 if args.len() < 3 || args.len() > 4 {
214 diag.push_error(
215 format!("This function needs 3 or 4 arguments, but {} were provided", args.len()),
216 node,
217 );
218 return Expression::Invalid;
219 }
220 let mut arguments: Vec<_> = args
221 .into_iter()
222 .enumerate()
223 .map(|(i, (expr, n))| {
224 if i < 3 {
225 if expr.ty() == Type::Percent {
226 Expression::BinaryExpression {
227 lhs: Box::new(expr.maybe_convert_to(Type::Float32, &n, diag)),
228 rhs: Box::new(Expression::NumberLiteral(255., Unit::None)),
229 op: '*',
230 }
231 } else {
232 expr.maybe_convert_to(Type::Float32, &n, diag)
233 }
234 } else {
235 expr.maybe_convert_to(Type::Float32, &n, diag)
236 }
237 })
238 .collect();
239 if arguments.len() < 4 {
240 arguments.push(Expression::NumberLiteral(1., Unit::None))
241 }
242 Expression::FunctionCall {
243 function: BuiltinFunction::Rgb.into(),
244 arguments,
245 source_location: Some(node.to_source_location()),
246 }
247}
248
249fn hsv_macro(
250 node: &dyn Spanned,
251 args: Vec<(Expression, Option<NodeOrToken>)>,
252 diag: &mut BuildDiagnostics,
253) -> Expression {
254 if args.len() < 3 || args.len() > 4 {
255 diag.push_error(
256 message:format!("This function needs 3 or 4 arguments, but {} were provided", args.len()),
257 source:node,
258 );
259 return Expression::Invalid;
260 }
261 let mut arguments: Vec<_> =
262 args.into_iter().map(|(expr: Expression, n: Option)| expr.maybe_convert_to(target_type:Type::Float32, &n, diag)).collect();
263 if arguments.len() < 4 {
264 arguments.push(Expression::NumberLiteral(1., Unit::None))
265 }
266 Expression::FunctionCall {
267 function: BuiltinFunction::Hsv.into(),
268 arguments,
269 source_location: Some(node.to_source_location()),
270 }
271}
272
273fn debug_macro(
274 node: &dyn Spanned,
275 args: Vec<(Expression, Option<NodeOrToken>)>,
276 diag: &mut BuildDiagnostics,
277) -> Expression {
278 let mut string: Option = None;
279 for (expr: Expression, node: Option) in args {
280 let val: Expression = to_debug_string(expr, &node, diag);
281 string = Some(match string {
282 None => val,
283 Some(string: Expression) => Expression::BinaryExpression {
284 lhs: Box::new(string),
285 op: '+',
286 rhs: Box::new(Expression::BinaryExpression {
287 lhs: Box::new(Expression::StringLiteral(" ".into())),
288 op: '+',
289 rhs: Box::new(val),
290 }),
291 },
292 });
293 }
294 Expression::FunctionCall {
295 function: BuiltinFunction::Debug.into(),
296 arguments: vec![string.unwrap_or_else(|| Expression::default_value_for_type(&Type::String))],
297 source_location: Some(node.to_source_location()),
298 }
299}
300
301fn to_debug_string(
302 expr: Expression,
303 node: &dyn Spanned,
304 diag: &mut BuildDiagnostics,
305) -> Expression {
306 let ty = expr.ty();
307 match &ty {
308 Type::Invalid => Expression::Invalid,
309 Type::Void
310 | Type::InferredCallback
311 | Type::InferredProperty
312 | Type::Callback { .. }
313 | Type::ComponentFactory
314 | Type::Function { .. }
315 | Type::ElementReference
316 | Type::LayoutCache
317 | Type::Model
318 | Type::PathData => {
319 diag.push_error("Cannot debug this expression".into(), node);
320 Expression::Invalid
321 }
322 Type::Float32 | Type::Int32 => expr.maybe_convert_to(Type::String, node, diag),
323 Type::String => expr,
324 // TODO
325 Type::Color | Type::Brush | Type::Image | Type::Easing | Type::Array(_) => {
326 Expression::StringLiteral("<debug-of-this-type-not-yet-implemented>".into())
327 }
328 Type::Duration
329 | Type::PhysicalLength
330 | Type::LogicalLength
331 | Type::Rem
332 | Type::Angle
333 | Type::Percent
334 | Type::UnitProduct(_) => Expression::BinaryExpression {
335 lhs: Box::new(
336 Expression::Cast { from: Box::new(expr), to: Type::Float32 }.maybe_convert_to(
337 Type::String,
338 node,
339 diag,
340 ),
341 ),
342 op: '+',
343 rhs: Box::new(Expression::StringLiteral(
344 Type::UnitProduct(ty.as_unit_product().unwrap()).to_smolstr(),
345 )),
346 },
347 Type::Bool => Expression::Condition {
348 condition: Box::new(expr),
349 true_expr: Box::new(Expression::StringLiteral("true".into())),
350 false_expr: Box::new(Expression::StringLiteral("false".into())),
351 },
352 Type::Struct(s) => {
353 let local_object = format_smolstr!(
354 "debug_struct{}",
355 COUNTER.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
356 );
357 let mut string = None;
358 for k in s.fields.keys() {
359 let field_name = if string.is_some() {
360 format_smolstr!(", {}: ", k)
361 } else {
362 format_smolstr!("{{ {}: ", k)
363 };
364 let value = to_debug_string(
365 Expression::StructFieldAccess {
366 base: Box::new(Expression::ReadLocalVariable {
367 name: local_object.clone(),
368 ty: ty.clone(),
369 }),
370 name: k.clone(),
371 },
372 node,
373 diag,
374 );
375 let field = Expression::BinaryExpression {
376 lhs: Box::new(Expression::StringLiteral(field_name)),
377 op: '+',
378 rhs: Box::new(value),
379 };
380 string = Some(match string {
381 None => field,
382 Some(x) => Expression::BinaryExpression {
383 lhs: Box::new(x),
384 op: '+',
385 rhs: Box::new(field),
386 },
387 });
388 }
389 match string {
390 None => Expression::StringLiteral("{}".into()),
391 Some(string) => Expression::CodeBlock(vec![
392 Expression::StoreLocalVariable { name: local_object, value: Box::new(expr) },
393 Expression::BinaryExpression {
394 lhs: Box::new(string),
395 op: '+',
396 rhs: Box::new(Expression::StringLiteral(" }".into())),
397 },
398 ]),
399 }
400 }
401 Type::Enumeration(enu) => {
402 let local_object = "debug_enum";
403 let mut v = vec![Expression::StoreLocalVariable {
404 name: local_object.into(),
405 value: Box::new(expr),
406 }];
407 let mut cond =
408 Expression::StringLiteral(format_smolstr!("Error: invalid value for {}", ty));
409 for (idx, val) in enu.values.iter().enumerate() {
410 cond = Expression::Condition {
411 condition: Box::new(Expression::BinaryExpression {
412 lhs: Box::new(Expression::ReadLocalVariable {
413 name: local_object.into(),
414 ty: ty.clone(),
415 }),
416 rhs: Box::new(Expression::EnumerationValue(EnumerationValue {
417 value: idx,
418 enumeration: enu.clone(),
419 })),
420 op: '=',
421 }),
422 true_expr: Box::new(Expression::StringLiteral(val.clone())),
423 false_expr: Box::new(cond),
424 };
425 }
426 v.push(cond);
427 Expression::CodeBlock(v)
428 }
429 }
430}
431
432/// Generate an expression which is like `min(lhs, rhs)` if op is '<' or `max(lhs, rhs)` if op is '>'.
433/// counter is an unique id.
434/// The rhs and lhs of the expression must have the same numerical type
435pub fn min_max_expression(lhs: Expression, rhs: Expression, op: MinMaxOp) -> Expression {
436 let lhs_ty: Type = lhs.ty();
437 let rhs_ty: Type = rhs.ty();
438 let ty: Type = match (lhs_ty, rhs_ty) {
439 (a: Type, b: Type) if a == b => a,
440 (Type::Int32, Type::Float32) | (Type::Float32, Type::Int32) => Type::Float32,
441 _ => Type::Invalid,
442 };
443 Expression::MinMax { ty, op, lhs: Box::new(lhs), rhs: Box::new(rhs) }
444}
445