lib: Stabilize a subset of the test_set API

This stabilizes most of the `eval` mdoule and some shared types between that and
`parse`, but not `parse` itself because the internal generated `Rule` type must
be kept out of the public API.

This also fixes parts of the CLI where the lack of this API made it impossible
or hard to correctly handle tests like in update which need the additional
persistence constraint or in general when tests are passed as literal
identifiers.

Closes #78.

Author: tingerrr

crates/typst-test-lib/src/test/suite.rs

@@ -185,6 +185,7 @@ mod tests {
     use super::*;
     use crate::_dev;
     use crate::test::{Annotation, Kind};
+    use crate::test_set::eval;
 
     #[test]
     fn test_collect() {
@@ -212,7 +213,11 @@ mod tests {
             },
             |root| {
                 let paths = Paths::new(root, None);
-                let suite = Suite::collect(&paths, &TestSet::all()).unwrap();
+                let suite = Suite::collect(
+                    &paths,
+                    &TestSet::new(eval::Context::empty(), eval::Set::built_in_all()),
+                )
+                .unwrap();
 
                 let tests = [
                     ("compile-only", Kind::CompileOnly, eco_vec![]),

crates/typst-test-lib/src/test_set/eval/func.rs

@@ -1,8 +1,9 @@
 use std::fmt::{self, Debug};
 use std::sync::Arc;
 
-use super::value::TryFromValue;
-use super::{Context, Error, Set, Value};
+use ecow::eco_vec;
+
+use super::{Context, Error, Set, TryFromValue, Type, Value};
 
 /// The backing implementation for a [`Func`].
 type FuncImpl = Arc<dyn Fn(&Context, &[Value]) -> Result<Value, Error>>;
@@ -35,150 +36,167 @@ impl Debug for Func {
 impl Func {
     /// Constructor for [`Set::built_in_all`].
     pub fn built_in_all(ctx: &Context, args: &[Value]) -> Result<Value, Error> {
-        expect_no_args("all", ctx, args)?;
+        Self::expect_no_args("all", ctx, args)?;
         Ok(Value::Set(Set::built_in_all()))
     }
 
     /// Constructor for [`Set::built_in_none`].
     pub fn built_in_none(ctx: &Context, args: &[Value]) -> Result<Value, Error> {
-        expect_no_args("none", ctx, args)?;
+        Self::expect_no_args("none", ctx, args)?;
         Ok(Value::Set(Set::built_in_none()))
     }
 
     /// Constructor for [`Set::built_in_skip`].
     pub fn built_in_skip(ctx: &Context, args: &[Value]) -> Result<Value, Error> {
-        expect_no_args("skip", ctx, args)?;
+        Self::expect_no_args("skip", ctx, args)?;
         Ok(Value::Set(Set::built_in_skip()))
     }
 
     /// Constructor for [`Set::built_in_compile_only`].
     pub fn built_in_compile_only(ctx: &Context, args: &[Value]) -> Result<Value, Error> {
-        expect_no_args("compile-only", ctx, args)?;
+        Self::expect_no_args("compile-only", ctx, args)?;
         Ok(Value::Set(Set::built_in_compile_only()))
     }
 
     /// Constructor for [`Set::built_in_ephemeral`].
     pub fn built_in_ephemeral(ctx: &Context, args: &[Value]) -> Result<Value, Error> {
-        expect_no_args("ephemeral", ctx, args)?;
+        Self::expect_no_args("ephemeral", ctx, args)?;
         Ok(Value::Set(Set::built_in_ephemeral()))
     }
 
     /// Constructor for [`Set::built_in_persistent`].
     pub fn built_in_persistent(ctx: &Context, args: &[Value]) -> Result<Value, Error> {
-        expect_no_args("persistent", ctx, args)?;
+        Self::expect_no_args("persistent", ctx, args)?;
         Ok(Value::Set(Set::built_in_persistent()))
     }
 }
 
-/// Ensure there are no args.
-pub fn expect_no_args(id: &str, _ctx: &Context, args: &[Value]) -> Result<(), Error> {
-    if args.is_empty() {
-        Ok(())
-    } else {
-        Err(Error::InvalidArgumentCount {
-            func: id.into(),
-            expected: 0,
-            is_min: false,
-            found: args.len(),
-        })
+impl Func {
+    /// Ensure there are no args.
+    pub fn expect_no_args(id: &str, _ctx: &Context, args: &[Value]) -> Result<(), Error> {
+        if args.is_empty() {
+            Ok(())
+        } else {
+            Err(Error::InvalidArgumentCount {
+                func: id.into(),
+                expected: 0,
+                is_min: false,
+                found: args.len(),
+            })
+        }
     }
-}
 
-// TODO(tinger): see test_set module todo
-
-/// Extract an exact number of values from the given arguments. Validates the
-/// types of all arguments.
-#[allow(dead_code)]
-pub fn expect_args_exact<T: TryFromValue + Debug, const N: usize>(
-    func: &str,
-    _ctx: &Context,
-    args: &[Value],
-) -> Result<[T; N], Error> {
-    if args.len() < N {
-        return Err(Error::InvalidArgumentCount {
-            func: func.into(),
-            expected: N,
-            is_min: false,
-            found: args.len(),
-        });
+    /// Extract an exact number of values from the given arguments. Validates the
+    /// types of all arguments.
+    pub fn expect_args_exact<T: TryFromValue + Debug, const N: usize>(
+        func: &str,
+        _ctx: &Context,
+        args: &[Value],
+    ) -> Result<[T; N], Error> {
+        if args.len() < N {
+            return Err(Error::InvalidArgumentCount {
+                func: func.into(),
+                expected: N,
+                is_min: false,
+                found: args.len(),
+            });
+        }
+
+        Ok(args
+            .iter()
+            .take(N)
+            .map(T::try_from_value)
+            .collect::<Result<Vec<_>, _>>()?
+            .try_into()
+            .expect("we checked both min and max of the args"))
     }
 
-    Ok(args
-        .iter()
-        .take(N)
-        .map(T::try_from_value)
-        .collect::<Result<Vec<_>, _>>()?
-        .try_into()
-        .expect("we checked both min and max of the args"))
+    /// Extract a variadic number of values with a minimum amount given arguments.
+    /// Validates the types of all arguments.
+    pub fn expect_args_min<T: TryFromValue + Debug, const N: usize>(
+        func: &str,
+        _ctx: &Context,
+        args: &[Value],
+    ) -> Result<([T; N], Vec<T>), Error> {
+        if args.len() < N {
+            return Err(Error::InvalidArgumentCount {
+                func: func.into(),
+                expected: N,
+                is_min: true,
+                found: args.len(),
+            });
+        }
+
+        let min = args
+            .iter()
+            .take(N)
+            .map(T::try_from_value)
+            .collect::<Result<Vec<_>, _>>()?
+            .try_into()
+            .expect("we checked both min and max of the args");
+
+        Ok((
+            min,
+            args[N..]
+                .iter()
+                .map(T::try_from_value)
+                .collect::<Result<_, _>>()?,
+        ))
+    }
 }
 
-/// Extract a variadic number of values with a minimum amount given arguments.
-/// Validates the types of all arguments.
-#[allow(dead_code)]
-pub fn expect_args_min<T: TryFromValue + Debug, const N: usize>(
-    func: &str,
-    _ctx: &Context,
-    args: &[Value],
-) -> Result<([T; N], Vec<T>), Error> {
-    if args.len() < N {
-        return Err(Error::InvalidArgumentCount {
-            func: func.into(),
-            expected: N,
-            is_min: true,
-            found: args.len(),
-        });
+impl TryFromValue for Func {
+    fn try_from_value(value: &Value) -> Result<Self, Error> {
+        Ok(match value {
+            Value::Func(set) => set.clone(),
+            _ => {
+                return Err(Error::TypeMismatch {
+                    expected: eco_vec![Type::Func],
+                    found: value.as_type(),
+                })
+            }
+        })
     }
-
-    let min = args
-        .iter()
-        .take(N)
-        .map(T::try_from_value)
-        .collect::<Result<Vec<_>, _>>()?
-        .try_into()
-        .expect("we checked both min and max of the args");
-
-    Ok((
-        min,
-        args[N..]
-            .iter()
-            .map(T::try_from_value)
-            .collect::<Result<_, _>>()?,
-    ))
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::test_set::parse::Num;
 
-    const NUM: Num = Num(0);
+    const NUM: usize = 0;
     const VAL: Value = Value::Num(NUM);
 
     #[test]
     fn test_expect_args_variadic_min_length() {
-        let ctx = Context::new();
+        let ctx = Context::empty();
 
         assert_eq!(
-            expect_args_min::<Num, 0>("f", &ctx, &[]).unwrap(),
+            Func::expect_args_min::<usize, 0>("f", &ctx, &[]).unwrap(),
             ([], vec![]),
         );
-        assert_eq!(expect_args_min("f", &ctx, &[VAL]).unwrap(), ([], vec![NUM]),);
         assert_eq!(
-            expect_args_min("f", &ctx, &[VAL, VAL]).unwrap(),
+            Func::expect_args_min("f", &ctx, &[VAL]).unwrap(),
+            ([], vec![NUM]),
+        );
+        assert_eq!(
+            Func::expect_args_min("f", &ctx, &[VAL, VAL]).unwrap(),
             ([], vec![NUM, NUM]),
         );
 
-        assert!(expect_args_min::<Num, 1>("f", &ctx, &[]).is_err());
-        assert_eq!(expect_args_min("f", &ctx, &[VAL]).unwrap(), ([NUM], vec![]),);
+        assert!(Func::expect_args_min::<usize, 1>("f", &ctx, &[]).is_err());
+        assert_eq!(
+            Func::expect_args_min("f", &ctx, &[VAL]).unwrap(),
+            ([NUM], vec![]),
+        );
         assert_eq!(
-            expect_args_min("f", &ctx, &[VAL, VAL]).unwrap(),
+            Func::expect_args_min("f", &ctx, &[VAL, VAL]).unwrap(),
             ([NUM], vec![NUM]),
         );
 
-        assert!(expect_args_min::<Num, 2>("f", &ctx, &[]).is_err());
-        assert!(expect_args_min::<Num, 2>("f", &ctx, &[VAL]).is_err(),);
+        assert!(Func::expect_args_min::<usize, 2>("f", &ctx, &[]).is_err());
+        assert!(Func::expect_args_min::<usize, 2>("f", &ctx, &[VAL]).is_err(),);
         assert_eq!(
-            expect_args_min("f", &ctx, &[VAL, VAL]).unwrap(),
+            Func::expect_args_min("f", &ctx, &[VAL, VAL]).unwrap(),
             ([NUM, NUM], vec![]),
         );
     }