1use swamp_script_modules::modules::Module;
2use swamp_script_modules::symtbl::SymbolTable;
3use swamp_script_node::Node;
4use swamp_script_semantic::prelude::{IntrinsicFunction, IntrinsicFunctionDefinition};
5use swamp_script_types::{AliasType, Signature, Type, TypeForParameter};
6use tiny_ver::TinyVersion;
7
8pub const PACKAGE_NAME: &str = "core";
9fn add_intrinsic_types(core_ns: &mut SymbolTable) {
10 let int_alias = AliasType {
11 name: Node::default(),
12 assigned_name: "Int".to_string(),
13 referenced_type: Type::Int,
14 };
15 core_ns.add_alias(int_alias).unwrap();
16
17 let float_alias = AliasType {
18 name: Node::default(),
19 assigned_name: "Float".to_string(),
20 referenced_type: Type::Float,
21 };
22 core_ns.add_alias(float_alias).unwrap();
23
24 let string_alias = AliasType {
25 name: Node::default(),
26 assigned_name: "String".to_string(),
27 referenced_type: Type::String,
28 };
29 core_ns.add_alias(string_alias).unwrap();
30
31 let bool_alias = AliasType {
32 name: Node::default(),
33 assigned_name: "Bool".to_string(),
34 referenced_type: Type::Bool,
35 };
36 core_ns.add_alias(bool_alias).unwrap();
37}
38
39#[allow(clippy::too_many_lines)]
40fn add_intrinsic_functions(core_ns: &mut SymbolTable) {
41 add_intrinsic_float_functions(core_ns);
42 add_intrinsic_int_functions(core_ns);
43 add_intrinsic_string_functions(core_ns);
44 add_intrinsic_vec_functions(core_ns);
45 add_intrinsic_map_functions(core_ns);
46 add_intrinsic_sparse_functions(core_ns);
47}
48
49#[allow(clippy::too_many_lines)]
50fn add_intrinsic_sparse_functions(core_ns: &mut SymbolTable) {
51 let slice_to_self = Signature {
52 parameters: [TypeForParameter {
53 name: "slice".to_string(),
54 resolved_type: Type::Never,
55 is_mutable: false,
56 node: None,
57 }]
58 .into(),
59 return_type: Box::new(Type::Never),
60 };
61 let slice_to_self_functions = [IntrinsicFunction::SparseFromSlice];
62 for intrinsic_fn in slice_to_self_functions {
63 let name = intrinsic_fn.to_string();
64 core_ns
65 .add_intrinsic_function(IntrinsicFunctionDefinition {
66 name,
67 intrinsic: intrinsic_fn,
68 signature: slice_to_self.clone(),
69 })
70 .unwrap();
71 }
72
73 let unit_to_value = Signature {
74 parameters: [].into(),
75 return_type: Box::new(Type::Never),
76 };
77
78 let unit_to_value_functions = [IntrinsicFunction::SparseCreate];
79
80 for intrinsic_fn in unit_to_value_functions {
81 let name = intrinsic_fn.to_string();
82 core_ns
83 .add_intrinsic_function(IntrinsicFunctionDefinition {
84 name,
85 intrinsic: intrinsic_fn,
86 signature: unit_to_value.clone(),
87 })
88 .unwrap();
89 }
90
91 let self_to_value = Signature {
92 parameters: [TypeForParameter {
93 name: "self".to_string(),
94 resolved_type: Type::Never,
95 is_mutable: false,
96 node: None,
97 }]
98 .into(),
99 return_type: Box::new(Type::Never),
100 };
101
102 let self_to_value_functions = [
103 IntrinsicFunction::SparseIter,
104 IntrinsicFunction::SparseIterMut,
105 ];
106
107 for intrinsic_fn in self_to_value_functions {
108 let name = intrinsic_fn.to_string();
109 core_ns
110 .add_intrinsic_function(IntrinsicFunctionDefinition {
111 name,
112 intrinsic: intrinsic_fn,
113 signature: self_to_value.clone(),
114 })
115 .unwrap();
116 }
117
118 let self_value_to_value = Signature {
119 parameters: [
120 TypeForParameter {
121 name: "self".to_string(),
122 resolved_type: Type::Never,
123 is_mutable: false,
124 node: None,
125 },
126 TypeForParameter {
127 name: "i".to_string(),
128 resolved_type: Type::Never,
129 is_mutable: false,
130 node: None,
131 },
132 ]
133 .into(),
134 return_type: Box::new(Type::Never),
135 };
136
137 let self_value_to_value_functions = [
138 IntrinsicFunction::SparseSubscript,
139 IntrinsicFunction::SparseAdd,
140 ];
141
142 for intrinsic_fn in self_value_to_value_functions {
143 let name = intrinsic_fn.to_string();
144 core_ns
145 .add_intrinsic_function(IntrinsicFunctionDefinition {
146 name,
147 intrinsic: intrinsic_fn,
148 signature: self_value_to_value.clone(),
149 })
150 .unwrap();
151 }
152
153 let self_value_value_mut_to_unit = Signature {
154 parameters: [
155 TypeForParameter {
156 name: "self".to_string(),
157 resolved_type: Type::Never,
158 is_mutable: false,
159 node: None,
160 },
161 TypeForParameter {
162 name: "key".to_string(),
163 resolved_type: Type::Never,
164 is_mutable: false,
165 node: None,
166 },
167 TypeForParameter {
168 name: "value".to_string(),
169 resolved_type: Type::Never,
170 is_mutable: true,
171 node: None,
172 },
173 ]
174 .into(),
175 return_type: Box::new(Type::Never),
176 };
177
178 let self_value_value_mut_to_unit_functions = [IntrinsicFunction::SparseSubscriptMut];
179
180 for intrinsic_fn in self_value_value_mut_to_unit_functions {
181 let name = intrinsic_fn.to_string();
182 core_ns
183 .add_intrinsic_function(IntrinsicFunctionDefinition {
184 name,
185 intrinsic: intrinsic_fn,
186 signature: self_value_value_mut_to_unit.clone(),
187 })
188 .unwrap();
189 }
190
191 let self_value_to_bool = Signature {
192 parameters: [
193 TypeForParameter {
194 name: "self".to_string(),
195 resolved_type: Type::Never,
196 is_mutable: false,
197 node: None,
198 },
199 TypeForParameter {
200 name: "i".to_string(),
201 resolved_type: Type::Never,
202 is_mutable: false,
203 node: None,
204 },
205 ]
206 .into(),
207 return_type: Box::new(Type::Bool),
208 };
209
210 let self_value_to_bool_functions = [IntrinsicFunction::SparseHas];
211
212 for intrinsic_fn in self_value_to_bool_functions {
213 let name = intrinsic_fn.to_string();
214 core_ns
215 .add_intrinsic_function(IntrinsicFunctionDefinition {
216 name,
217 intrinsic: intrinsic_fn,
218 signature: self_value_to_bool.clone(),
219 })
220 .unwrap();
221 }
222
223 let self_value_to_option_value = Signature {
224 parameters: [
225 TypeForParameter {
226 name: "self".to_string(),
227 resolved_type: Type::Never,
228 is_mutable: false,
229 node: None,
230 },
231 TypeForParameter {
232 name: "key".to_string(),
233 resolved_type: Type::Never,
234 is_mutable: false,
235 node: None,
236 },
237 ]
238 .into(),
239 return_type: Box::new(Type::Optional(Box::new(Type::Never))),
240 };
241
242 let self_value_to_option_value_functions = [IntrinsicFunction::SparseRemove];
243
244 for intrinsic_fn in self_value_to_option_value_functions {
245 let name = intrinsic_fn.to_string();
246 core_ns
247 .add_intrinsic_function(IntrinsicFunctionDefinition {
248 name,
249 intrinsic: intrinsic_fn,
250 signature: self_value_to_option_value.clone(),
251 })
252 .unwrap();
253 }
254}
255
256#[allow(clippy::too_many_lines)]
257fn add_intrinsic_map_functions(core_ns: &mut SymbolTable) {
258 let slice_to_self = Signature {
259 parameters: [TypeForParameter {
260 name: "slice_pair".to_string(),
261 resolved_type: Type::Never,
262 is_mutable: false,
263 node: None,
264 }]
265 .into(),
266 return_type: Box::new(Type::Never),
267 };
268 let slice_to_self_functions = [IntrinsicFunction::MapFromSlicePair];
269 for intrinsic_fn in slice_to_self_functions {
270 let name = intrinsic_fn.to_string();
271 core_ns
272 .add_intrinsic_function(IntrinsicFunctionDefinition {
273 name,
274 intrinsic: intrinsic_fn,
275 signature: slice_to_self.clone(),
276 })
277 .unwrap();
278 }
279
280 let unit_to_value = Signature {
281 parameters: [].into(),
282 return_type: Box::new(Type::Never),
283 };
284
285 let unit_to_value_functions = [IntrinsicFunction::MapCreate];
286
287 for intrinsic_fn in unit_to_value_functions {
288 let name = intrinsic_fn.to_string();
289 core_ns
290 .add_intrinsic_function(IntrinsicFunctionDefinition {
291 name,
292 intrinsic: intrinsic_fn,
293 signature: unit_to_value.clone(),
294 })
295 .unwrap();
296 }
297
298 let self_to_value = Signature {
299 parameters: [TypeForParameter {
300 name: "self".to_string(),
301 resolved_type: Type::Never,
302 is_mutable: false,
303 node: None,
304 }]
305 .into(),
306 return_type: Box::new(Type::Never),
307 };
308
309 let self_to_value_functions = [IntrinsicFunction::MapIter, IntrinsicFunction::MapIterMut];
310
311 for intrinsic_fn in self_to_value_functions {
312 let name = intrinsic_fn.to_string();
313 core_ns
314 .add_intrinsic_function(IntrinsicFunctionDefinition {
315 name,
316 intrinsic: intrinsic_fn,
317 signature: self_to_value.clone(),
318 })
319 .unwrap();
320 }
321
322 let self_value_to_value = Signature {
323 parameters: [
324 TypeForParameter {
325 name: "self".to_string(),
326 resolved_type: Type::Never,
327 is_mutable: false,
328 node: None,
329 },
330 TypeForParameter {
331 name: "i".to_string(),
332 resolved_type: Type::Never,
333 is_mutable: false,
334 node: None,
335 },
336 ]
337 .into(),
338 return_type: Box::new(Type::Never),
339 };
340
341 let self_value_to_value_functions = [IntrinsicFunction::MapSubscript];
342
343 for intrinsic_fn in self_value_to_value_functions {
344 let name = intrinsic_fn.to_string();
345 core_ns
346 .add_intrinsic_function(IntrinsicFunctionDefinition {
347 name,
348 intrinsic: intrinsic_fn,
349 signature: self_value_to_value.clone(),
350 })
351 .unwrap();
352 }
353
354 let self_value_value_mut_to_unit = Signature {
355 parameters: [
356 TypeForParameter {
357 name: "self".to_string(),
358 resolved_type: Type::Never,
359 is_mutable: true,
360 node: None,
361 },
362 TypeForParameter {
363 name: "key".to_string(),
364 resolved_type: Type::Never,
365 is_mutable: false,
366 node: None,
367 },
368 ]
369 .into(),
370 return_type: Box::new(Type::Never),
371 };
372
373 let self_value_value_mut_to_unit_functions = [
374 IntrinsicFunction::MapSubscriptMut,
375 IntrinsicFunction::MapSubscriptMutCreateIfNeeded,
376 ];
377
378 for intrinsic_fn in self_value_value_mut_to_unit_functions {
379 let name = intrinsic_fn.to_string();
380 core_ns
381 .add_intrinsic_function(IntrinsicFunctionDefinition {
382 name,
383 intrinsic: intrinsic_fn,
384 signature: self_value_value_mut_to_unit.clone(),
385 })
386 .unwrap();
387 }
388
389 let self_value_to_bool = Signature {
390 parameters: [
391 TypeForParameter {
392 name: "self".to_string(),
393 resolved_type: Type::Never,
394 is_mutable: false,
395 node: None,
396 },
397 TypeForParameter {
398 name: "i".to_string(),
399 resolved_type: Type::Never,
400 is_mutable: false,
401 node: None,
402 },
403 ]
404 .into(),
405 return_type: Box::new(Type::Bool),
406 };
407
408 let self_value_to_bool_functions = [IntrinsicFunction::MapHas];
409
410 for intrinsic_fn in self_value_to_bool_functions {
411 let name = intrinsic_fn.to_string();
412 core_ns
413 .add_intrinsic_function(IntrinsicFunctionDefinition {
414 name,
415 intrinsic: intrinsic_fn,
416 signature: self_value_to_bool.clone(),
417 })
418 .unwrap();
419 }
420
421 let self_value_to_unit_value = Signature {
422 parameters: [
423 TypeForParameter {
424 name: "self".to_string(),
425 resolved_type: Type::Never,
426 is_mutable: true,
427 node: None,
428 },
429 TypeForParameter {
430 name: "key".to_string(),
431 resolved_type: Type::Never,
432 is_mutable: false,
433 node: None,
434 },
435 ]
436 .into(),
437 return_type: Box::new(Type::Unit),
438 };
439
440 let self_value_to_option_value_functions = [IntrinsicFunction::MapRemove];
441
442 for intrinsic_fn in self_value_to_option_value_functions {
443 let name = intrinsic_fn.to_string();
444 core_ns
445 .add_intrinsic_function(IntrinsicFunctionDefinition {
446 name,
447 intrinsic: intrinsic_fn,
448 signature: self_value_to_unit_value.clone(),
449 })
450 .unwrap();
451 }
452
453 let self_to_int = Signature {
454 parameters: [TypeForParameter {
455 name: "self".to_string(),
456 resolved_type: Type::Never,
457 is_mutable: false,
458 node: None,
459 }]
460 .into(),
461 return_type: Box::new(Type::Int),
462 };
463
464 let self_to_int_functions = [IntrinsicFunction::MapLen];
465
466 for intrinsic_fn in self_to_int_functions {
467 let name = intrinsic_fn.to_string();
468 core_ns
469 .add_intrinsic_function(IntrinsicFunctionDefinition {
470 name,
471 intrinsic: intrinsic_fn,
472 signature: self_to_int.clone(),
473 })
474 .unwrap();
475 }
476
477 let self_to_bool = Signature {
478 parameters: [TypeForParameter {
479 name: "self".to_string(),
480 resolved_type: Type::Never,
481 is_mutable: false,
482 node: None,
483 }]
484 .into(),
485 return_type: Box::new(Type::Bool),
486 };
487
488 let self_to_bool_functions = [IntrinsicFunction::MapIsEmpty];
489
490 for intrinsic_fn in self_to_bool_functions {
491 let name = intrinsic_fn.to_string();
492 core_ns
493 .add_intrinsic_function(IntrinsicFunctionDefinition {
494 name,
495 intrinsic: intrinsic_fn,
496 signature: self_to_bool.clone(),
497 })
498 .unwrap();
499 }
500}
501
502#[allow(clippy::too_many_lines)]
503fn add_intrinsic_vec_functions(core_ns: &mut SymbolTable) {
504 let unit_to_value = Signature {
505 parameters: [].into(),
506 return_type: Box::new(Type::Never),
507 };
508
509 let unit_to_value_functions = [IntrinsicFunction::VecCreate];
510
511 for intrinsic_fn in unit_to_value_functions {
512 let name = intrinsic_fn.to_string();
513 core_ns
514 .add_intrinsic_function(IntrinsicFunctionDefinition {
515 name,
516 intrinsic: intrinsic_fn,
517 signature: unit_to_value.clone(),
518 })
519 .unwrap();
520 }
521
522 let self_value_to_unit = Signature {
523 parameters: [
524 TypeForParameter {
525 name: "self".to_string(),
526 resolved_type: Type::Never,
527 is_mutable: true,
528 node: None,
529 },
530 TypeForParameter {
531 name: "v".to_string(),
532 resolved_type: Type::Never,
533 is_mutable: false,
534 node: None,
535 },
536 ]
537 .into(),
538 return_type: Box::new(Type::Unit),
539 };
540
541 let self_value_to_unit_functions = [IntrinsicFunction::VecPush];
542
543 for intrinsic_fn in self_value_to_unit_functions {
544 let name = intrinsic_fn.to_string();
545 core_ns
546 .add_intrinsic_function(IntrinsicFunctionDefinition {
547 name,
548 intrinsic: intrinsic_fn,
549 signature: self_value_to_unit.clone(),
550 })
551 .unwrap();
552 }
553
554 let self_value_to_value = Signature {
555 parameters: [TypeForParameter {
556 name: "self".to_string(),
557 resolved_type: Type::Never,
558 is_mutable: true,
559 node: None,
560 }]
561 .into(),
562 return_type: Box::new(Type::Never),
563 };
564 let self_value_to_option_functions = [IntrinsicFunction::VecPop];
565 for intrinsic_fn in self_value_to_option_functions {
566 let name = intrinsic_fn.to_string();
567 core_ns
568 .add_intrinsic_function(IntrinsicFunctionDefinition {
569 name,
570 intrinsic: intrinsic_fn,
571 signature: self_value_to_value.clone(),
572 })
573 .unwrap();
574 }
575
576 let self_int_to_value = Signature {
577 parameters: [
578 TypeForParameter {
579 name: "self".to_string(),
580 resolved_type: Type::Never,
581 is_mutable: false,
582 node: None,
583 },
584 TypeForParameter {
585 name: "i".to_string(),
586 resolved_type: Type::Int,
587 is_mutable: false,
588 node: None,
589 },
590 ]
591 .into(),
592 return_type: Box::new(Type::Never),
593 };
594
595 let self_int_to_value_functions = [IntrinsicFunction::VecSubscript];
596
597 for intrinsic_fn in self_int_to_value_functions {
598 let name = intrinsic_fn.to_string();
599 core_ns
600 .add_intrinsic_function(IntrinsicFunctionDefinition {
601 name,
602 intrinsic: intrinsic_fn,
603 signature: self_int_to_value.clone(),
604 })
605 .unwrap();
606 }
607
608 let self_int_value_mut_to_unit = Signature {
609 parameters: [
610 TypeForParameter {
611 name: "self".to_string(),
612 resolved_type: Type::Never,
613 is_mutable: true,
614 node: None,
615 },
616 TypeForParameter {
617 name: "i".to_string(),
618 resolved_type: Type::Int,
619 is_mutable: false,
620 node: None,
621 },
622 ]
623 .into(),
624 return_type: Box::new(Type::Never),
625 };
626
627 let self_int_value_mut_to_unit_functions = [IntrinsicFunction::VecSubscriptMut];
628
629 for intrinsic_fn in self_int_value_mut_to_unit_functions {
630 let name = intrinsic_fn.to_string();
631 core_ns
632 .add_intrinsic_function(IntrinsicFunctionDefinition {
633 name,
634 intrinsic: intrinsic_fn,
635 signature: self_int_value_mut_to_unit.clone(),
636 })
637 .unwrap();
638 }
639
640 let self_int_to_unit_value = Signature {
641 parameters: [
642 TypeForParameter {
643 name: "self".to_string(),
644 resolved_type: Type::Never,
645 is_mutable: true,
646 node: None,
647 },
648 TypeForParameter {
649 name: "i".to_string(),
650 resolved_type: Type::Int,
651 is_mutable: false,
652 node: None,
653 },
654 ]
655 .into(),
656 return_type: Box::new(Type::Unit),
657 };
658
659 let self_int_to_optional_value_functions = [IntrinsicFunction::VecRemoveIndex];
660
661 for intrinsic_fn in self_int_to_optional_value_functions {
662 let name = intrinsic_fn.to_string();
663 core_ns
664 .add_intrinsic_function(IntrinsicFunctionDefinition {
665 name,
666 intrinsic: intrinsic_fn,
667 signature: self_int_to_unit_value.clone(),
668 })
669 .unwrap();
670 }
671
672 let self_to_unit = Signature {
673 parameters: [TypeForParameter {
674 name: "self".to_string(),
675 resolved_type: Type::Never,
676 is_mutable: false,
677 node: None,
678 }]
679 .into(),
680 return_type: Box::new(Type::Unit),
681 };
682
683 let self_to_unit_functions = [IntrinsicFunction::VecClear];
684
685 for intrinsic_fn in self_to_unit_functions {
686 let name = intrinsic_fn.to_string();
687 core_ns
688 .add_intrinsic_function(IntrinsicFunctionDefinition {
689 name,
690 intrinsic: intrinsic_fn,
691 signature: self_to_unit.clone(),
692 })
693 .unwrap();
694 }
695
696 let self_to_value = Signature {
697 parameters: [TypeForParameter {
698 name: "self".to_string(),
699 resolved_type: Type::Never,
700 is_mutable: false,
701 node: None,
702 }]
703 .into(),
704 return_type: Box::new(Type::Never),
705 };
706
707 let self_to_value_functions = [IntrinsicFunction::VecIter, IntrinsicFunction::VecIterMut];
708
709 for intrinsic_fn in self_to_value_functions {
710 let name = intrinsic_fn.to_string();
711 core_ns
712 .add_intrinsic_function(IntrinsicFunctionDefinition {
713 name,
714 intrinsic: intrinsic_fn,
715 signature: self_to_value.clone(),
716 })
717 .unwrap();
718 }
719
720 let slice_to_self = Signature {
721 parameters: [TypeForParameter {
722 name: "slice".to_string(),
723 resolved_type: Type::Never, is_mutable: false,
725 node: None,
726 }]
727 .into(),
728 return_type: Box::new(Type::Never),
729 };
730 let slice_to_self_functions = [IntrinsicFunction::VecFromSlice];
731 for intrinsic_fn in slice_to_self_functions {
732 let name = intrinsic_fn.to_string();
733 core_ns
734 .add_intrinsic_function(IntrinsicFunctionDefinition {
735 name,
736 intrinsic: intrinsic_fn,
737 signature: slice_to_self.clone(),
738 })
739 .unwrap();
740 }
741
742 let self_to_int = Signature {
743 parameters: [TypeForParameter {
744 name: "self".to_string(),
745 resolved_type: Type::Never,
746 is_mutable: false,
747 node: None,
748 }]
749 .into(),
750 return_type: Box::new(Type::Int),
751 };
752
753 let self_to_int_functions = [IntrinsicFunction::VecLen];
754
755 for intrinsic_fn in self_to_int_functions {
756 let name = intrinsic_fn.to_string();
757 core_ns
758 .add_intrinsic_function(IntrinsicFunctionDefinition {
759 name,
760 intrinsic: intrinsic_fn,
761 signature: self_to_int.clone(),
762 })
763 .unwrap();
764 }
765
766 let self_to_bool = Signature {
767 parameters: [TypeForParameter {
768 name: "self".to_string(),
769 resolved_type: Type::Never,
770 is_mutable: false,
771 node: None,
772 }]
773 .into(),
774 return_type: Box::new(Type::Bool),
775 };
776
777 let self_to_bool_functions = [IntrinsicFunction::VecIsEmpty];
778
779 for intrinsic_fn in self_to_bool_functions {
780 let name = intrinsic_fn.to_string();
781 core_ns
782 .add_intrinsic_function(IntrinsicFunctionDefinition {
783 name,
784 intrinsic: intrinsic_fn,
785 signature: self_to_bool.clone(),
786 })
787 .unwrap();
788 }
789}
790
791#[allow(clippy::too_many_lines)]
792fn add_intrinsic_string_functions(core_ns: &mut SymbolTable) {
793 let string_to_int = Signature {
794 parameters: [TypeForParameter {
795 name: "self".into(),
796 resolved_type: Type::String,
797 is_mutable: false,
798 node: None,
799 }]
800 .into(),
801 return_type: Box::new(Type::Int),
802 };
803
804 let string_to_int_functions = [IntrinsicFunction::StringLen];
805
806 for intrinsic_fn in string_to_int_functions {
807 let name = intrinsic_fn.to_string();
808 core_ns
809 .add_intrinsic_function(IntrinsicFunctionDefinition {
810 name,
811 intrinsic: intrinsic_fn,
812 signature: string_to_int.clone(),
813 })
814 .unwrap();
815 }
816}
817
818#[allow(clippy::too_many_lines)]
819fn add_intrinsic_int_functions(core_ns: &mut SymbolTable) {
820 let int_to_int = Signature {
821 parameters: [TypeForParameter {
822 name: "self".into(),
823 resolved_type: Type::Int,
824 is_mutable: false,
825 node: None,
826 }]
827 .into(),
828 return_type: Box::new(Type::Int),
829 };
830
831 let int_to_int_functions = [IntrinsicFunction::IntAbs, IntrinsicFunction::IntRnd];
832
833 for intrinsic_fn in int_to_int_functions {
834 let name = intrinsic_fn.to_string();
835 core_ns
836 .add_intrinsic_function(IntrinsicFunctionDefinition {
837 name,
838 intrinsic: intrinsic_fn,
839 signature: int_to_int.clone(),
840 })
841 .unwrap();
842 }
843
844 let int_int_to_int = Signature {
845 parameters: [
846 TypeForParameter {
847 name: "self".into(),
848 resolved_type: Type::Int,
849 is_mutable: false,
850 node: None,
851 },
852 TypeForParameter {
853 name: "b".into(),
854 resolved_type: Type::Int,
855 is_mutable: false,
856 node: None,
857 },
858 ]
859 .into(),
860 return_type: Box::new(Type::Int),
861 };
862 let int_int_to_int_functions = [IntrinsicFunction::IntMax, IntrinsicFunction::IntMin];
863
864 for intrinsic_fn in int_int_to_int_functions {
865 let name = intrinsic_fn.to_string();
866 core_ns
867 .add_intrinsic_function(IntrinsicFunctionDefinition {
868 name,
869 intrinsic: intrinsic_fn,
870 signature: int_int_to_int.clone(),
871 })
872 .unwrap();
873 }
874
875 let int_to_float = Signature {
876 parameters: [TypeForParameter {
877 name: "self".into(),
878 resolved_type: Type::Int,
879 is_mutable: false,
880 node: None,
881 }]
882 .into(),
883 return_type: Box::new(Type::Float),
884 };
885
886 core_ns
887 .add_intrinsic_function(IntrinsicFunctionDefinition {
888 name: IntrinsicFunction::IntToFloat.to_string(),
889 intrinsic: IntrinsicFunction::IntToFloat,
890 signature: int_to_float.clone(),
891 })
892 .unwrap();
893}
894
895#[allow(clippy::too_many_lines)]
896fn add_intrinsic_float_functions(core_ns: &mut SymbolTable) {
897 let float_to_float = Signature {
898 parameters: [TypeForParameter {
899 name: "self".into(),
900 resolved_type: Type::Float,
901 is_mutable: false,
902 node: None,
903 }]
904 .into(),
905 return_type: Box::new(Type::Float),
906 };
907
908 let float_to_float_functions = [
909 IntrinsicFunction::FloatSqrt,
910 IntrinsicFunction::FloatSign,
911 IntrinsicFunction::FloatAbs,
912 IntrinsicFunction::FloatRnd,
913 IntrinsicFunction::FloatCos,
914 IntrinsicFunction::FloatSin,
915 IntrinsicFunction::FloatAcos,
916 IntrinsicFunction::FloatAsin,
917 ];
918 for intrinsic_fn in float_to_float_functions {
919 let name = intrinsic_fn.to_string();
920 core_ns
921 .add_intrinsic_function(IntrinsicFunctionDefinition {
922 name,
923 intrinsic: intrinsic_fn,
924 signature: float_to_float.clone(),
925 })
926 .unwrap();
927 }
928
929 let float_to_int = Signature {
930 parameters: [TypeForParameter {
931 name: "self".into(),
932 resolved_type: Type::Float,
933 is_mutable: false,
934 node: None,
935 }]
936 .into(),
937 return_type: Box::new(Type::Int),
938 };
939
940 let float_to_int_functions = [IntrinsicFunction::FloatRound, IntrinsicFunction::FloatFloor];
941 for intrinsic_fn in float_to_int_functions {
942 let name = intrinsic_fn.to_string();
943 core_ns
944 .add_intrinsic_function(IntrinsicFunctionDefinition {
945 name,
946 intrinsic: intrinsic_fn,
947 signature: float_to_int.clone(),
948 })
949 .unwrap();
950 }
951
952 let float_float_to_float = Signature {
953 parameters: [
954 TypeForParameter {
955 name: "self".into(),
956 resolved_type: Type::Float,
957 is_mutable: false,
958 node: None,
959 },
960 TypeForParameter {
961 name: "other".into(),
962 resolved_type: Type::Float,
963 is_mutable: false,
964 node: None,
965 },
966 ]
967 .into(),
968 return_type: Box::new(Type::Float),
969 };
970
971 let float_float_to_float_functions = [
972 IntrinsicFunction::FloatAtan2,
973 IntrinsicFunction::FloatMin,
974 IntrinsicFunction::FloatMax,
975 IntrinsicFunction::Float2Magnitude,
976 ];
977 for intrinsic_fn in float_float_to_float_functions {
978 let name = intrinsic_fn.to_string();
979 core_ns
980 .add_intrinsic_function(IntrinsicFunctionDefinition {
981 name,
982 intrinsic: intrinsic_fn,
983 signature: float_float_to_float.clone(),
984 })
985 .unwrap();
986 }
987
988 let float_float_float_to_float = Signature {
989 parameters: [
990 TypeForParameter {
991 name: "self".into(),
992 resolved_type: Type::Float,
993 is_mutable: false,
994 node: None,
995 },
996 TypeForParameter {
997 name: "a".into(),
998 resolved_type: Type::Float,
999 is_mutable: false,
1000 node: None,
1001 },
1002 TypeForParameter {
1003 name: "b".into(),
1004 resolved_type: Type::Float,
1005 is_mutable: false,
1006 node: None,
1007 },
1008 ]
1009 .into(),
1010 return_type: Box::new(Type::Float),
1011 };
1012
1013 core_ns
1014 .add_intrinsic_function(IntrinsicFunctionDefinition {
1015 name: IntrinsicFunction::FloatClamp.to_string(),
1016 intrinsic: IntrinsicFunction::FloatClamp,
1017 signature: float_float_float_to_float.clone(),
1018 })
1019 .unwrap();
1020}
1021
1022#[must_use]
1025pub fn create_module(tiny_version: &TinyVersion) -> Module {
1026 let canonical_core_path = [tiny_version.versioned_name(PACKAGE_NAME).unwrap()];
1027 let mut intrinsic_types_symbol_table = SymbolTable::new(&canonical_core_path);
1028 add_intrinsic_types(&mut intrinsic_types_symbol_table);
1029 add_intrinsic_functions(&mut intrinsic_types_symbol_table);
1030
1031 Module::new(intrinsic_types_symbol_table, None)
1032}