Pass bool to eval_equals

Summary:
Instead of fn.

This is used in the following diffs (we can match on `bool` but cannot match on `fn`).

Note I tried to replace `fn(bool) -> bool` and call like `cmp(a == b)` with:
* `(a == b) == positive`
* creating two different closures for `==` and `!=`

but for reasons I don't understand, it leads to perf regression.

Reviewed By: ndmitchell

Differential Revision: D30888379

fbshipit-source-id: fe936adc019cb69e45f2a51741982b7e36c54617

Author: stepancheg

starlark/src/eval/fragment/expr.rs

@@ -43,6 +43,22 @@ use gazebo::{coerce::coerce_ref, prelude::*};
 use std::cmp::Ordering;
 use thiserror::Error;
 
+/// `bool` operation.
+#[derive(Copy, Clone, Dupe)]
+enum MaybeNot {
+    Id,
+    Not,
+}
+
+impl MaybeNot {
+    fn as_fn(self) -> fn(bool) -> bool {
+        match self {
+            MaybeNot::Id => |x| x,
+            MaybeNot::Not => |x| !x,
+        }
+    }
+}
+
 pub(crate) type ExprCompiled = Box<
     dyn for<'v> Fn(&mut Evaluator<'v, '_>) -> Result<Value<'v>, ExprEvalException> + Send + Sync,
 >;
@@ -102,12 +118,13 @@ fn eval_compare(
 fn try_eval_type_is(
     l: ExprCompiledValue,
     r: ExprCompiledValue,
-    cmp: fn(bool) -> bool,
+    maybe_not: MaybeNot,
 ) -> Result<ExprCompiledValue, (ExprCompiledValue, ExprCompiledValue)> {
     match (l, r) {
         (ExprCompiledValue::Type(l), ExprCompiledValue::Value(r)) => {
             if let Some(r) = r.downcast_frozen_ref::<StarlarkStr>() {
                 let t = r.map(|r| r.unpack());
+                let cmp = maybe_not.as_fn();
                 Ok(expr!("type_is", l, |_eval| {
                     Value::new_bool(cmp(l.get_type() == t.as_ref()))
                 }))
@@ -123,21 +140,22 @@ fn eval_equals(
     span: Span,
     l: ExprCompiledValue,
     r: ExprCompiledValue,
-    cmp: fn(bool) -> bool,
+    maybe_not: MaybeNot,
 ) -> ExprCompiledValue {
+    let cmp = maybe_not.as_fn();
     if let (Some(l), Some(r)) = (l.as_value(), r.as_value()) {
         // If comparison fails, let it fail in runtime.
         if let Ok(r) = l.equals(r.to_value()) {
             return value!(FrozenValue::new_bool(cmp(r)));
         }
     }
 
-    let (l, r) = match try_eval_type_is(l, r, cmp) {
+    let (l, r) = match try_eval_type_is(l, r, maybe_not) {
         Ok(e) => return e,
         Err((l, r)) => (l, r),
     };
 
-    let (r, l) = match try_eval_type_is(r, l, cmp) {
+    let (r, l) = match try_eval_type_is(r, l, maybe_not) {
         Ok(e) => return e,
         Err((r, l)) => (r, l),
     };
@@ -607,8 +625,8 @@ impl Compiler<'_> {
                                 })
                             }
                         }
-                        BinOp::Equal => eval_equals(span, l, r, |x| x),
-                        BinOp::NotEqual => eval_equals(span, l, r, |x| !x),
+                        BinOp::Equal => eval_equals(span, l, r, MaybeNot::Id),
+                        BinOp::NotEqual => eval_equals(span, l, r, MaybeNot::Not),
                         BinOp::Less => eval_compare(span, l, r, |x| x == Ordering::Less),
                         BinOp::Greater => eval_compare(span, l, r, |x| x == Ordering::Greater),
                         BinOp::LessOrEqual => eval_compare(span, l, r, |x| x != Ordering::Greater),