Merge pull request #744 from candy-lang/add-tests

Add tests to Core package

.vscode/extensions.json

@@ -6,6 +6,7 @@
     "rust-lang.rust-analyzer",
     "serayuzgur.crates",
     "tamasfe.even-better-toml",
+    "usernamehw.errorlens",
     "vadimcn.vscode-lldb"
   ]
 }

compiler/backend_inkwell/src/lib.rs

@@ -337,7 +337,7 @@ impl<'ctx> CodeGen<'ctx> {
                     let i64_type = self.context.i64_type();
                     let v = i64_type.const_int(
                         value
-                            .clamp(&i64::MIN.into(), &i64::MAX.into())
+                            .clamp(&u64::MIN.into(), &u64::MAX.into())
                             .try_into()
                             .unwrap(),
                         false,

compiler/frontend/src/mir_optimize/utils.rs

@@ -1,5 +1,6 @@
 use super::pure::PurenessInsights;
 use crate::mir::{Body, Expression, Id, VisibleExpressions};
+use itertools::Itertools;
 use rustc_hash::FxHashSet;
 use std::mem;
 
@@ -185,15 +186,67 @@ impl Id {
             return None;
         }
 
-        if self_expr == other_expr {
-            return Some(true);
-        }
-
         if !pureness.is_definition_const(self_expr) || !pureness.is_definition_const(other_expr) {
             return None;
         }
 
-        Some(false)
+        match (self_expr, other_expr) {
+            (Expression::Int(a), Expression::Int(b)) => Some(a == b),
+            (Expression::Text(a), Expression::Text(b)) => Some(a == b),
+            (
+                Expression::Tag {
+                    symbol: symbol_a,
+                    value: value_a,
+                },
+                Expression::Tag {
+                    symbol: symbol_b,
+                    value: value_b,
+                },
+            ) => {
+                if symbol_a != symbol_b || value_a.is_some() != value_b.is_some() {
+                    return Some(false);
+                }
+                if let (Some(a), Some(b)) = (value_a, value_b) {
+                    return a.semantically_equals(*b, visible, pureness);
+                }
+                Some(true)
+            }
+            (Expression::Builtin(a), Expression::Builtin(b)) => Some(a == b),
+            (Expression::List(a), Expression::List(b)) => {
+                if a.len() != b.len() {
+                    return Some(false);
+                }
+                for (a, b) in a.iter().zip_eq(b) {
+                    if !a.semantically_equals(*b, visible, pureness)? {
+                        return Some(false);
+                    }
+                }
+                Some(true)
+            }
+            (Expression::Struct(a), Expression::Struct(b)) => {
+                if a.len() != b.len() {
+                    return Some(false);
+                }
+                // TODO: Match keys and compare values.
+                None
+            }
+            // Expressions have different types.
+            (
+                Expression::Int(_)
+                | Expression::Text(_)
+                | Expression::Tag { .. }
+                | Expression::Builtin(_)
+                | Expression::List(_)
+                | Expression::Struct(_),
+                Expression::Int(_)
+                | Expression::Text(_)
+                | Expression::Tag { .. }
+                | Expression::Builtin(_)
+                | Expression::List(_)
+                | Expression::Struct(_),
+            ) => Some(false),
+            _ => None,
+        }
     }
 }
 

compiler/vm/src/heap/object_heap/int.rs

@@ -61,6 +61,7 @@ impl HeapInt {
     operator_fn!(shift_right, Shr, shr);
 
     pub fn bit_length(self, heap: &mut Heap) -> Int {
+        assert!(*self.get() >= 0.into());
         Int::create(heap, true, self.get().bits())
     }
 

compiler/vm/src/heap/object_inline/int.rs

@@ -80,18 +80,25 @@ impl InlineInt {
     }
 
     pub fn shift_left(self, heap: &mut Heap, rhs: Self) -> Int {
-        let lhs = self.get();
+        let lhs: i64 = self.get();
         #[allow(clippy::map_unwrap_or)]
         rhs.try_get::<u32>()
             .and_then(|rhs| {
                 // `checked_shl(…)` only checks that `rhs` doesn't exceed the number of bits in the
                 // type (i.e., `rhs < 64`). However, we need to check that the mathematical result
                 // is completely representable in our available bits and doesn't get truncated.
 
+                let bit_length = if lhs.is_negative() {
+                    // One 1 is necessary for the sign.
+                    i64::BITS - lhs.leading_ones() + 1
+                } else {
+                    lhs.bit_length()
+                };
+
                 #[allow(clippy::cast_possible_truncation)]
                 let value_shift = Self::VALUE_SHIFT as u32;
 
-                if self.get().bit_length() + rhs < InlineObject::BITS - value_shift {
+                if bit_length + rhs < InlineObject::BITS - value_shift {
                     Some(lhs << rhs)
                 } else {
                     None
@@ -197,12 +204,8 @@ impl InlineObjectTrait for InlineInt {
 #[extension_trait]
 pub impl I64BitLength for i64 {
     fn bit_length(self) -> u32 {
-        if self.is_negative() {
-            // One 1 is necessary for the sign.
-            Self::BITS - self.leading_ones() + 1
-        } else {
-            Self::BITS - self.leading_zeros()
-        }
+        assert!(!self.is_negative());
+        Self::BITS - self.leading_zeros()
     }
 }
 
@@ -278,10 +281,6 @@ mod tests {
 
     #[test]
     fn bit_length() {
-        assert_eq!(inline_int(-4).bit_length(), inline_int(3));
-        assert_eq!(inline_int(-3).bit_length(), inline_int(3));
-        assert_eq!(inline_int(-2).bit_length(), inline_int(2));
-        assert_eq!(inline_int(-1).bit_length(), inline_int(1));
         assert_eq!(inline_int(0).bit_length(), inline_int(0));
         assert_eq!(inline_int(1).bit_length(), inline_int(1));
         assert_eq!(inline_int(2).bit_length(), inline_int(2));

packages/Builtins/_.candy

@@ -171,6 +171,9 @@ intBitLength value :=
   # intBitLength -3 => 2
   # ```
   needs (value | typeIs Int)
+  needs
+    (value | ✨.intAdd 1 | ✨.intCompareTo 0 | ✨.equals Greater)
+    "Value must be non-negative"
   ✨.intBitLength value
 
 intBitwiseAnd a b :=

packages/Core/bool.candy

@@ -49,3 +49,36 @@ implies a b :=
   needs (is a)
   needs (is b)
   a | not | or b
+
+test =
+  [checkEquals] = use "..check"
+
+  checkEquals (is True) True
+  checkEquals (is False) True
+  checkEquals (is 3) False
+
+  checkEquals (not True) False
+  checkEquals (not False) True
+
+  ## `lazyAnd` and `lazyOr` are automatically tested by the tests for the
+  ## non-lazy variants.
+
+  checkEquals (True | and True) True
+  checkEquals (True | and False) False
+  checkEquals (False | and True) False
+  checkEquals (False | and False) False
+
+  checkEquals (True | or True) True
+  checkEquals (True | or False) True
+  checkEquals (False | or True) True
+  checkEquals (False | or False) False
+
+  checkEquals (True | xor True) False
+  checkEquals (True | xor False) True
+  checkEquals (False | xor True) True
+  checkEquals (False | xor False) False
+
+  checkEquals (True | implies True) True
+  checkEquals (True | implies False) False
+  checkEquals (False | implies True) True
+  checkEquals (False | implies False) True

packages/Core/check.candy

@@ -1,10 +1,16 @@
-bool = use "..bool"
-[if] = use "..controlFlow"
+[equals] = use "Builtins"
 
 check condition :=
   # Panics if the `condition` is `False`.
   #
   # This function is useful for ensuring that your mental model of the state of
   # your program matches its actual state.
-  needs (bool.is condition)
-  needs condition "A check didn't succeed."
+  isConditionBool = condition %
+    True | False -> True
+    _ -> False
+  needs isConditionBool
+  needs condition "A check failed."
+
+checkEquals actual expected :=
+  # Panics if `actual` and `expected` are different.
+  needs (actual | equals expected) "A check failed: Expected {actual} to be {expected}."

packages/Core/controlFlow.candy

@@ -43,3 +43,12 @@ repeat times body :=
       recurse (times | builtins.intSubtract 1)
     }
   }
+
+test =
+  [checkEquals] = use "..check"
+
+  checkEquals (ifElse True { Then } { Else }) Then
+  checkEquals (ifElse False { Then } { Else }) Else
+
+  checkEquals (if True { Then }) Then
+  checkEquals (if False { Then }) Nothing

packages/Core/equality.candy

@@ -1,3 +1,40 @@
 builtins = use "Builtins"
 
 equals := builtins.equals
+
+test =
+  [checkEquals] = use "..check"
+
+  checkEquals (equals 2 Foo) False
+
+  ## numbers
+  checkEquals (equals 5 5) True
+  checkEquals (equals 3 5) False
+
+  ## text
+  checkEquals (equals "Hey" "Hey") True
+  checkEquals (equals "A" "B") False
+
+  ## tags
+  checkEquals (equals Kiwi Kiwi) True
+  checkEquals (equals Kiwi Banana) False
+  checkEquals (equals Kiwi (Kiwi 3)) False
+  checkEquals (equals (Kiwi 3) (Kiwi 3)) True
+  checkEquals (equals (Kiwi 5) (Kiwi 3)) False
+
+  ## functions
+  foo = { a -> 4 }
+  checkEquals (equals foo foo) True
+  ## TODO: Currently, this is not implemented correctly in the VM.
+  # checkEquals (equals foo { a -> 4 }) False
+
+  ## lists
+  checkEquals (equals (1, 2, 3) (1, 2, 3)) True
+  checkEquals (equals (1, 2, 3) (1, 2)) False
+  checkEquals (equals (1, 2, 3) (1, 2, 30)) False
+
+  ## structs
+  checkEquals (equals [Foo: 2] [Foo: 2]) True
+  checkEquals (equals [Foo: 2] [Bar: 2]) False
+  checkEquals (equals [Foo: 2] []) False
+  checkEquals (equals [Foo: 2] [Foo: 3]) False

packages/Core/function.candy

@@ -38,3 +38,17 @@ doNotRun body :=
   # - Making the code invalid (for example, by deleting needed functions) results in compiler
   #   errors.
   needs (is0 body)
+
+test =
+  [checkEquals] = use "..check"
+
+  checkEquals (is {}) True
+  checkEquals (is 4) False
+  checkEquals (getArgumentCount {}) 0
+  checkEquals (getArgumentCount { a -> }) 1
+
+  checkEquals (is0 {}) True
+  checkEquals (is0 { a -> }) False
+
+  checkEquals (run { 4 }) 4
+  checkEquals (doNotRun { 4 }) Nothing