Add full optimization level for aggressive optimizing.

tests/call_fn.rs

@@ -1,25 +1,24 @@
-#![cfg(not(feature = "no_stdlib"))]
 #![cfg(not(feature = "no_function"))]
 use rhai::{Engine, EvalAltResult, INT};
 
 #[test]
-fn test_engine_call_fn() -> Result<(), EvalAltResult> {
+fn test_call_fn() -> Result<(), EvalAltResult> {
     let mut engine = Engine::new();
 
     engine.consume(
+        true,
         r"
             fn hello(x, y) {
-                x.len() + y
+                x + y
             }
             fn hello(x) {
                 x * 2
             }
                 ",
-        true,
     )?;
 
-    let r: i64 = engine.call_fn("hello", (String::from("abc"), 123 as INT))?;
-    assert_eq!(r, 126);
+    let r: i64 = engine.call_fn("hello", (42 as INT, 123 as INT))?;
+    assert_eq!(r, 165);
 
     let r: i64 = engine.call_fn("hello", 123 as INT)?;
     assert_eq!(r, 246);

tests/constants.rs

@@ -1,19 +1,19 @@
-use rhai::{Engine, EvalAltResult};
+use rhai::{Engine, EvalAltResult, INT};
 
 #[test]
 fn test_constant() -> Result<(), EvalAltResult> {
     let mut engine = Engine::new();
 
-    assert_eq!(engine.eval::<i64>("const x = 123; x")?, 123);
+    assert_eq!(engine.eval::<INT>("const x = 123; x")?, 123);
 
     assert!(
-        matches!(engine.eval::<i64>("const x = 123; x = 42;").expect_err("expects error"),
+        matches!(engine.eval::<INT>("const x = 123; x = 42;").expect_err("expects error"),
         EvalAltResult::ErrorAssignmentToConstant(var, _) if var == "x")
     );
 
     #[cfg(not(feature = "no_index"))]
     assert!(
-        matches!(engine.eval::<i64>("const x = [1, 2, 3, 4, 5]; x[2] = 42;").expect_err("expects error"),
+        matches!(engine.eval::<INT>("const x = [1, 2, 3, 4, 5]; x[2] = 42;").expect_err("expects error"),
         EvalAltResult::ErrorAssignmentToConstant(var, _) if var == "x")
     );
 

tests/mismatched_op.rs

@@ -32,13 +32,13 @@ fn test_mismatched_op_custom_type() {
         .eval::<INT>("60 + new_ts()")
         .expect_err("expects error");
 
-    match r {
-        #[cfg(feature = "only_i32")]
-        EvalAltResult::ErrorFunctionNotFound(err, _) if err == "+ (i32, TestStruct)" => (),
+    #[cfg(feature = "only_i32")]
+    assert!(
+        matches!(r, EvalAltResult::ErrorFunctionNotFound(err, _) if err == "+ (i32, TestStruct)")
+    );
 
-        #[cfg(not(feature = "only_i32"))]
-        EvalAltResult::ErrorFunctionNotFound(err, _) if err == "+ (i64, TestStruct)" => (),
-
-        _ => panic!(),
-    }
+    #[cfg(not(feature = "only_i32"))]
+    assert!(
+        matches!(r, EvalAltResult::ErrorFunctionNotFound(err, _) if err == "+ (i64, TestStruct)")
+    );
 }

tests/optimizer.rs

@@ -0,0 +1,32 @@
+#![cfg(not(feature = "no_optimize"))]
+
+use rhai::{Engine, EvalAltResult, OptimizationLevel, INT};
+
+#[test]
+fn test_optimizer() -> Result<(), EvalAltResult> {
+    fn run_test(engine: &mut Engine) -> Result<(), EvalAltResult> {
+        assert_eq!(engine.eval::<INT>(r"if true { 42 } else { 123 }")?, 42);
+        assert_eq!(
+            engine.eval::<INT>(r"if 1 == 1 || 2 > 3 { 42 } else { 123 }")?,
+            42
+        );
+        assert_eq!(
+            engine.eval::<INT>(r#"const abc = "hello"; if abc < "foo" { 42 } else { 123 }"#)?,
+            123
+        );
+        Ok(())
+    }
+
+    let mut engine = Engine::new();
+
+    engine.set_optimization_level(OptimizationLevel::None);
+    run_test(&mut engine)?;
+
+    engine.set_optimization_level(OptimizationLevel::Simple);
+    run_test(&mut engine)?;
+
+    engine.set_optimization_level(OptimizationLevel::Full);
+    run_test(&mut engine)?;
+
+    Ok(())
+}