[Fix] Properly force 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_seq correctly evaluates 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 evaluates the content of an enum variant
+%force% ('Foo 5 | [| 'Foo String |])