add ==, !=, ===, !== operator support for evaluation (#3693)

extracted from #3670

depends on #3685 

adds the equal operators to the evaluator

crates/turbopack-ecmascript/src/analyzer/builtin.rs

@@ -212,7 +212,7 @@ pub fn replace_builtin(value: &mut JsValue) -> bool {
                 match &mut **prop {
                     // matching constant string property access on an object like `{a: 1, b:
                     // 2}["a"]`
-                    JsValue::Constant(ConstantValue::StrAtom(_) | ConstantValue::StrWord(_)) => {
+                    JsValue::Constant(ConstantValue::Str(_)) => {
                         let prop_str = prop.as_str().unwrap();
                         let mut potential_values = Vec::new();
                         for (i, part) in parts.iter_mut().enumerate().rev() {
@@ -463,6 +463,20 @@ pub fn replace_builtin(value: &mut JsValue) -> bool {
                 true
             }
         }
+        // match a binary operator like `a == b`
+        JsValue::Binary(..) => {
+            if let Some(v) = value.is_truthy() {
+                let v = if v {
+                    ConstantValue::True
+                } else {
+                    ConstantValue::False
+                };
+                *value = JsValue::Constant(v);
+                true
+            } else {
+                false
+            }
+        }
         // match the not operator like `!a`
         // Evaluate not when the inner value is truthy or falsy
         JsValue::Not(_, ref inner) => match inner.is_truthy() {

crates/turbopack-ecmascript/src/analyzer/graph.rs

@@ -406,6 +406,34 @@ impl EvalContext {
                 ..
             }) => JsValue::nullish_coalescing(vec![self.eval(left), self.eval(right)]),
 
+            Expr::Bin(BinExpr {
+                op: op!("=="),
+                left,
+                right,
+                ..
+            }) => JsValue::equal(self.eval(left), self.eval(right)),
+
+            Expr::Bin(BinExpr {
+                op: op!("!="),
+                left,
+                right,
+                ..
+            }) => JsValue::not_equal(self.eval(left), self.eval(right)),
+
+            Expr::Bin(BinExpr {
+                op: op!("==="),
+                left,
+                right,
+                ..
+            }) => JsValue::strict_equal(self.eval(left), self.eval(right)),
+
+            Expr::Bin(BinExpr {
+                op: op!("!=="),
+                left,
+                right,
+                ..
+            }) => JsValue::strict_not_equal(self.eval(left), self.eval(right)),
+
             &Expr::Cond(CondExpr {
                 box ref cons,
                 box ref alt,