Better logic to simplify negation.

Author: cristianoc

compiler/core/js_exp_make.ml

@@ -665,6 +665,36 @@ let bin ?comment (op : J.binop) (e0 : t) (e1 : t) : t =
 let string_of_expression = ref (fun _ -> "")
 let debug = false
 
+(**
+  [push_negation e] attempts to simplify a negated expression by pushing the negation
+  deeper into the expression tree. Returns [Some simplified] if simplification is possible,
+  [None] otherwise.
+
+  Simplification rules:
+  - [!(not e)] -> [e]
+  - [!true] -> [false]
+  - [!false] -> [true]
+  - [!(a === b)] -> [a !== b]
+  - [!(a !== b)] -> [a === b]
+  - [!(a && b)] -> [!a || !b]  (De Morgan's law)
+  - [!(a || b)] -> [!a && !b]  (De Morgan's law)
+*)
+let rec push_negation (e : t) : t option =
+  match e.expression_desc with
+  | Js_not e -> Some e
+  | Bool b -> Some (bool (not b))
+  | Bin (EqEqEq, a, b) -> Some {e with expression_desc = Bin (NotEqEq, a, b)}
+  | Bin (NotEqEq, a, b) -> Some {e with expression_desc = Bin (EqEqEq, a, b)}
+  | Bin (And, a, b) -> (
+    match (push_negation a, push_negation b) with
+    | Some a_, Some b_ -> Some {e with expression_desc = Bin (Or, a_, b_)}
+    | _ -> None)
+  | Bin (Or, a, b) -> (
+    match (push_negation a, push_negation b) with
+    | Some a_, Some b_ -> Some {e with expression_desc = Bin (And, a_, b_)}
+    | _ -> None)
+  | _ -> None
+
 (**
   [simplify_and e1 e2] attempts to simplify the boolean AND expression [e1 && e2].
   Returns [Some simplified] if simplification is possible, [None] otherwise.
@@ -802,6 +832,16 @@ let rec simplify_and (e1 : t) (e2 : t) : t option =
   - [e || true] -> [true]
   - [false || e] -> [e]
   - [e || false] -> [e]
+
+  Algebraic transformation strategy:
+  When basic rules don't apply, attempts to leverage [simplify_and] by:
+  1. Using the equivalence: [e1 || e2 ≡ !(!(e1) && !(e2))]
+  2. Applying [push_negation] to get [!(e1)] and [!(e2)]
+  3. Using [simplify_and] on these negated terms
+  4. If successful, applying [push_negation] again to get the final result
+
+  This transformation allows reuse of [simplify_and]'s more extensive optimizations
+  in the context of OR expressions.
 *)
 and simplify_or (e1 : t) (e2 : t) : t option =
   if debug then
@@ -813,7 +853,13 @@ and simplify_or (e1 : t) (e2 : t) : t option =
   | _, Bool true -> Some true_
   | Bool false, _ -> Some e2
   | _, Bool false -> Some e1
-  | _ -> None
+  | _ -> (
+    match (push_negation e1, push_negation e2) with
+    | Some e1_, Some e2_ -> (
+      match simplify_and e1_ e2_ with
+      | Some e -> push_negation e
+      | None -> None)
+    | _ -> None)
 
 let and_ ?comment (e1 : t) (e2 : t) : t =
   match (e1.expression_desc, e2.expression_desc) with

tests/tests/src/and_or_simplify.mjs

@@ -2,11 +2,7 @@
 
 
 function check_null_eq_typeof(x) {
-  if (typeof x !== "boolean" || x !== null) {
-    return 4;
-  } else {
-    return 3;
-  }
+  return 4;
 }
 
 function check_null_neq_typeof(x) {
@@ -18,11 +14,7 @@ function check_null_neq_typeof(x) {
 }
 
 function check_undefined_eq_typeof(x) {
-  if (typeof x !== "boolean" || x !== undefined) {
-    return 4;
-  } else {
-    return 3;
-  }
+  return 4;
 }
 
 function check_undefined_neq_typeof(x) {