Properly force enum variants

The implementation of deep_seq and force primops haven't been properly
updated to handle enum variants, letting them mostly unevaluated. This
could in particular let contracts be unexpectedly unevaluated, and also
show unevaluated chunk in the REPL when inputting enum variants there,
which isn't ideal.

This commit properly forces enum variants.

core/src/eval/mod.rs

@@ -185,6 +185,7 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
             .map(|result| result.body)
     }
 
+    /// Same as [Self::eval_full], but takes a closure as an argument instead of a term.
     pub fn eval_full_closure(&mut self, t0: Closure) -> Result<Closure, EvalError> {
         self.eval_deep_closure_impl(t0, false)
             .map(|result| Closure {

core/src/eval/operation.rs

@@ -707,6 +707,10 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
                             env: Environment::new(),
                         })
                     }
+                    Term::EnumVariant { arg, .. } => Ok(Closure {
+                        body: seq_terms(std::iter::once(arg), pos_op),
+                        env,
+                    }),
                     _ => {
                         if let Some((next, ..)) = self.stack.pop_arg(&self.cache) {
                             Ok(next)
@@ -1063,6 +1067,23 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
                             env: Environment::new(),
                         })
                     }
+                    // For an enum variant, `force x` is simply equivalent to `deep_seq x x`, as
+                    // there's no lazy pending contract to apply.
+                    Term::EnumVariant { tag, arg, attrs } => {
+                        let cont = RichTerm::new(
+                            Term::EnumVariant {
+                                tag,
+                                arg: arg.clone(),
+                                attrs,
+                            },
+                            pos.into_inherited(),
+                        );
+
+                        Ok(Closure {
+                            body: seq_terms(std::iter::once(arg), pos_op, cont),
+                            env,
+                        })
+                    }
                     _ => Ok(Closure {
                         body: RichTerm { term: t, pos },
                         env

core/tests/integration/inputs/adts/deep_seq_enum.ncl

@@ -0,0 +1,7 @@
+# test.type = 'error'
+#
+# [test.metadata]
+# error = 'EvalError::BlameError'
+
+# Check that deep_eq correctly evaluate the content of an enum variant
+%deep_seq% ('Foo 5 | [| 'Foo String |]) null

core/tests/integration/inputs/adts/force_enum.ncl

@@ -0,0 +1,7 @@
+# test.type = 'error'
+#
+# [test.metadata]
+# error = 'EvalError::BlameError'
+
+# Check that force correctly evaluate the content of an enum variant
+%force% ('Foo 5 | [| 'Foo String |])