Remove back-end switch optimization that relies on numeric values.

The only one that could still make sense is for the identity function, but that would be a strange optimization.
Better have it earlier on, and apply to partial cases too, where it's mostly the identity.

Author: cristianoc

jscomp/core/lam_convert.ml

@@ -119,25 +119,24 @@ let lam_is_var (x : Lam.t) (y : Ident.t) =
 (** Make sure no int range overflow happens
     also we only check [int]
 *)
-let happens_to_be_diff (sw_consts : (int * Lambda.lambda) list) : int option =
+let happens_to_be_diff (sw_consts : (int * Lambda.lambda) list) sw_names : int option =
   match sw_consts with
   | ( a,
-      Lconst (Const_pointer (a0, Pt_constructor _) | Const_base (Const_int a0))
+      Lconst (Const_base (Const_int a0))
     )
     :: ( b,
          Lconst
-           (Const_pointer (b0, Pt_constructor _) | Const_base (Const_int b0)) )
+           (Const_base (Const_int b0)) )
     :: rest
-    when no_over_flow a && no_over_flow a0 && no_over_flow b && no_over_flow b0
+    when sw_names = None && no_over_flow a && no_over_flow a0 && no_over_flow b && no_over_flow b0
     ->
       let diff = a0 - a in
       if b0 - b = diff then
         if
           Ext_list.for_all rest (fun (x, lam) ->
               match lam with
               | Lconst
-                  ( Const_pointer (x0, Pt_constructor _)
-                  | Const_base (Const_int x0) )
+                  ( Const_base (Const_int x0) )
                 when no_over_flow x0 && no_over_flow x ->
                   x0 - x = diff
               | _ -> false)
@@ -701,8 +700,9 @@ let convert (exports : Set_ident.t) (lam : Lambda.lambda) :
      sw_numblocks = 0;
      sw_consts;
      sw_numconsts;
+     sw_names;
     } -> (
-        match happens_to_be_diff sw_consts with
+        match happens_to_be_diff sw_consts sw_names with
         | Some 0 -> e
         | Some i ->
             prim ~primitive:Paddint
@@ -712,7 +712,7 @@ let convert (exports : Set_ident.t) (lam : Lambda.lambda) :
                   Lam.const (Const_int { i = Int32.of_int i; comment = None });
                 ]
               Location.none
-        | None ->
+        | _ ->
             Lam.switch e
               {
                 sw_failaction = None;

jscomp/test/adt_optimize_test.js

@@ -2,23 +2,58 @@
 
 
 function f(x) {
-  return x + 1 | 0;
+  switch (x) {
+    case /* A */0 :
+        return 1;
+    case /* B */1 :
+        return 2;
+    case /* C */2 :
+        return 3;
+    
+  }
 }
 
 function f_0(x) {
-  return x - 1 | 0;
+  switch (x) {
+    case /* A */0 :
+        return -1;
+    case /* B */1 :
+        return 0;
+    case /* C */2 :
+        return 1;
+    
+  }
 }
 
 function f2(param) {
   if (param >= 3) {
     return /* T003 */3;
-  } else {
-    return param;
+  }
+  switch (param) {
+    case 0 :
+        return /* T000 */0;
+    case 1 :
+        return /* T001 */1;
+    case 2 :
+        return /* T002 */2;
+    
   }
 }
 
 function f3(param) {
-  return param;
+  switch (param) {
+    case /* X0 */0 :
+        return /* Y0 */0;
+    case /* X1 */1 :
+        return /* Y1 */1;
+    case /* X2 */2 :
+        return /* Y2 */2;
+    case /* X3 */3 :
+        return /* Y3 */3;
+    case /* X4 */4 :
+        return /* Y4 */4;
+    
+  }
 }
 
 function f4(param) {