[flow][enums] Allow strict equality comparison of abstract Flow Enums

Summary: Changelog: [feature] Allow `===` comparison of abstract Flow Enums, and also enums themselves with the same ID.

Reviewed By: SamChou19815

Differential Revision: D55705473

fbshipit-source-id: 56e21c5535fcc1e92f6d34669d5cd8b650b8c9b0

Author: gkz

src/typing/flow_js.ml

@@ -134,16 +134,21 @@ let strict_equatable_error cond_context (l, r) =
   | (AnyT _, _)
   | (_, AnyT _) ->
     None
-  (* No comparisons of enum objects are allowed. *)
-  | (DefT (_, EnumObjectT _), _)
-  | (_, DefT (_, EnumObjectT _)) ->
-    Some (Lazy.force comparison_error)
-  (* We allow comparison between enums of the same type. *)
+  (* We allow comparison between enums and enum values with the same id. *)
+  | ( DefT (_, EnumObjectT { enum_info = ConcreteEnum { enum_id = id1; _ }; _ }),
+      DefT (_, EnumObjectT { enum_info = ConcreteEnum { enum_id = id2; _ }; _ })
+    )
   | ( DefT (_, EnumValueT (ConcreteEnum { enum_id = id1; _ })),
       DefT (_, EnumValueT (ConcreteEnum { enum_id = id2; _ }))
     )
     when ALoc.equal_id id1 id2 ->
     None
+  (* We allow comparison between abstract and concrete enums and enum values. *)
+  | (DefT (_, EnumObjectT _), DefT (_, EnumObjectT { enum_info = AbstractEnum _; _ }))
+  | (DefT (_, EnumObjectT { enum_info = AbstractEnum _; _ }), DefT (_, EnumObjectT _))
+  | (DefT (_, EnumValueT _), DefT (_, EnumValueT (AbstractEnum _)))
+  | (DefT (_, EnumValueT (AbstractEnum _)), DefT (_, EnumValueT _)) ->
+    None
   (* We allow the comparison of enums to null and void outside of switches. *)
   | (DefT (_, EnumValueT _), DefT (_, (NullT | VoidT)))
   | (DefT (_, (NullT | VoidT)), DefT (_, EnumValueT _)) -> begin
@@ -155,7 +160,9 @@ let strict_equatable_error cond_context (l, r) =
   end
   (* We don't allow the comparison of enums and other types in general. *)
   | (DefT (_, EnumValueT _), _)
-  | (_, DefT (_, EnumValueT _)) ->
+  | (_, DefT (_, EnumValueT _))
+  | (DefT (_, EnumObjectT _), _)
+  | (_, DefT (_, EnumObjectT _)) ->
     Some (Lazy.force comparison_error)
   (* We don't check other strict equality comparisons. *)
   | _ -> None

tests/enums/abstract-enum-value.js

@@ -78,3 +78,15 @@ function g<T: string | number>(x: EnumValue<T>): T {
   const b: string = x.valueOf(); // OK
   const c: string = x; // ERROR
 }
+
+// Strict Equality
+{
+  declare const x: E;
+  declare const y: EnumValue<>;
+  x === y; // OK
+  y === x; // OK
+
+  declare const z: EnumValue<>;
+  y === z; // OK
+  z === y; // OK
+}

tests/enums/abstract-enum.js

@@ -40,3 +40,14 @@ f<string, E, typeof E>(E); // OK
 f(E); // OK
 
 f(true); // ERROR
+
+// Strict Equality
+{
+  declare const x: Enum<>;
+  E === x; // OK
+  x === E; // OK
+
+  declare const y: Enum<>;
+  x === y; // OK
+  y === x; // OK
+}

tests/enums/enums.exp

@@ -1079,6 +1079,23 @@ References:
             ^ [2]
 
 
+Error ------------------------------------------------------------------------------------------------- equality.js:63:1
+
+Cannot compare enum `E` [1] to enum `F` [2]. [invalid-compare]
+
+   equality.js:63:1
+   63| E === F; // ERROR
+       ^
+
+References:
+   equality.js:3:6
+    3| enum E {
+            ^ [1]
+   equality.js:8:6
+    8| enum F {
+            ^ [2]
+
+
 Error --------------------------------------------------------------------------------------------- error-access.js:9:13
 
 Cannot access `C` because `C` is not a member of enum `E` [1]. [invalid-enum-access]
@@ -4419,7 +4436,7 @@ References:
 
 
 
-Found 262 errors
+Found 263 errors
 
 Only showing the most relevant union/intersection branches.
 To see all branches, re-run Flow with --show-all-branches

tests/enums/equality.js

@@ -57,3 +57,7 @@ for (; e === E.A;) {} // OK
 switch (true) {
   case s === E.A: break; // Error
 }
+
+// Equality of enums
+E === E; // OK
+E === F; // ERROR