feat: accept ArraySort

compiler/src/diagnostics.rs

@@ -55,6 +55,8 @@ pub enum Diagnostic {
          ref or wref, future versions of the compiler will reject this code"
     )]
     ClassWithNoIndirectionDeprecation(Ident, Span),
+    #[error("cannot sort this type of array, only arrays of primitives can be sorted")]
+    InvalidSortType(Span),
     #[error("syntax error, expected {0}")]
     SyntaxError(ExpectedSet, Span),
     #[error("{0}")]
@@ -135,6 +137,7 @@ impl Diagnostic {
             | Self::AddMethodConflict(span)
             | Self::NonClassRefDeprecation(_, span)
             | Self::ClassWithNoIndirectionDeprecation(_, span)
+            | Self::InvalidSortType(span)
             | Self::CompileError(_, span)
             | Self::SyntaxError(_, span)
             | Self::CteError(_, span) => *span,
@@ -144,6 +147,7 @@ impl Diagnostic {
     pub fn code(&self) -> &'static str {
         match self {
             Self::CompileError(cause, _) => cause.code(),
+            Self::InvalidUseOfTemporary(_) => "UNSUPPORTED",
             _ => "OTHER",
         }
     }

compiler/src/typechecker.rs

@@ -496,6 +496,13 @@ impl<'a> TypeChecker<'a> {
                 checked_args.push(first_arg);
                 *elem
             }
+            (Intrinsic::ArraySort, TypeId::Array(inner)) => {
+                if !matches!(*inner, TypeId::Prim(_)) {
+                    self.diagnostics.push(Diagnostic::InvalidSortType(span));
+                }
+                checked_args.push(first_arg);
+                TypeId::Void
+            }
             (Intrinsic::ToString, first_arg_type) => {
                 if first_arg_type == TypeId::Variant && first_arg.is_prvalue() {
                     self.diagnostics

compiler/tests/bytecode.rs

@@ -998,3 +998,22 @@ fn compile_static_arrays() {
     ];
     TestContext::compiled(vec![sources]).unwrap().run("Testing", check);
 }
+
+#[test]
+fn compile_array_sort() {
+    let sources = r#"
+        func Testing() {
+            let a: [String];
+            ArraySort(a);
+        }
+    "#;
+
+    let check = check_code![
+        pat!(ArrayClear(_)),
+        mem!(Local(a)),
+        pat!(ArraySort(_)),
+        mem!(Local(a)),
+        pat!(Nop)
+    ];
+    TestContext::compiled(vec![sources]).unwrap().run("Testing", check);
+}

compiler/tests/compile.rs

@@ -398,3 +398,18 @@ fn fail_on_bad_variant_ops() {
         errs
     );
 }
+
+#[test]
+fn fail_on_nonprim_sort() {
+    let sources = r#"
+        struct Dummy {}
+
+        func Testing() {
+            let arr: [Dummy];
+            ArraySort(arr);
+        }
+    "#;
+
+    let (_, errs) = compiled(vec![sources]).unwrap();
+    assert!(matches!(&errs[..], &[Diagnostic::InvalidSortType(_),]), "{:?}", errs);
+}