[flow] Avoid crashing when we are doing any substitution for generic conditional types

Summary:
In generic conditional type, we have a step to replace all GenericT with any, to see whether the check will still fail (so that we can always take the false branch).

During the substitution, we might encounter `Subst_name.Synthetic` that are otherwise unreachable, since during conditional type evaluation, we can see through the `OpenT` for `check_t`.

We should replace these synthetic `GenericT` that's supposed to represent generic `EvalT` results with stuck `EvalT` backed by opaque types. However, that's a more complicated fix. For now, I will just did a hole for the generic conditional type use case to avoid the crash.

Changelog: [fix] Fixed a potential crash when evaluating a conditional type. [example](https://flow.org/try/#1N4Igxg9gdgZglgcxALlAIwIZoKYBsD6uEEAztvhgE6UYCe+JADpdhgCYowa5kA0I2KAFcAtiRQAXSkOz9sADwxgJ+NPTbYuQ3BMnTZA+Y2yU4IwRO4A6SFBIrGVDGM7c+h46fNRLuKxJIGWh8MeT0ZfhYlCStpHzNsFBAMIQkIEQwJODAQfiEyfBE4eWw2fDgofDBMsAALfAA3KjgsXGxxZC4eAw0G-GhcWn9aY3wWZldu-g1mbGqJUoBaCRHEzrcDEgBrbAk62kXhXFxJ923d-cPRHEpTgyEoMDaqZdW7vKgoOfaSKgOKpqmDA+d4gB5fMA-P6LCCMLLQbiLOoYCqgh6-GDYRYIXYLSgkRZkCR4jpddwPfJLZjpOBkUEKTwJEJ+DAkMiUFSwkyZCC3dbdAC+-EgGiSK2MAAIAHLQADycLgCNwAGlsLQSAAeAAqAD4JQBeCUAEgAatwZJrgAAdKASiUAbR2tAlFQlTogMAlWoAusgJQ0IHA2BKFAsoGwSF7HWrvRKAPwhkRw51+p28G0CnUAbht4uwEtlaAAVnMJAB1OASWoyqDy+FQbiq2javWG622h1Ol22mt1xUNlVqzW631Rp3e9NQAU5nyrCUAQSgECrJkLJeU2rXpdbxoASqw2LKoIMNe27VYL1vlBWq72FUqm6ebXa7dHna73Z6tVeJKPv8XSzfCdnwlTNJ0zLNchABoTBIfskgyewTBAAUgA)

Reviewed By: panagosg7

Differential Revision: D84923742

fbshipit-source-id: f5493405c7a480792e2a6144ab75c494c7a6bc63

Author: SamChou19815

src/typing/flow_js.mli

@@ -59,7 +59,13 @@ val resolve_spread_list :
 (* polymorphism *)
 
 val subst :
-  Context.t -> ?use_op:Type.use_op -> ?force:bool -> Type.t Subst_name.Map.t -> Type.t -> Type.t
+  Context.t ->
+  ?use_op:Type.use_op ->
+  ?force:bool ->
+  ?purpose:Type_subst.Purpose.t ->
+  Type.t Subst_name.Map.t ->
+  Type.t ->
+  Type.t
 
 (* destructors *)
 

src/typing/implicit_instantiation.ml

@@ -1763,10 +1763,20 @@ module Kit (FlowJs : Flow_common.S) (Instantiation_helper : Flow_js_utils.Instan
               )
             in
             let any_substituted_check_t =
-              Type_subst.subst cx ~use_op:unknown_use any_subst_map check_t
+              Type_subst.subst
+                cx
+                ~use_op:unknown_use
+                ~purpose:Type_subst.Purpose.ConditionalTypeAnySubst
+                any_subst_map
+                check_t
             in
             let any_substituted_extends_t =
-              Type_subst.subst cx ~use_op:unknown_use any_subst_map extends_t
+              Type_subst.subst
+                cx
+                ~use_op:unknown_use
+                ~purpose:Type_subst.Purpose.ConditionalTypeAnySubst
+                any_subst_map
+                extends_t
             in
             (match
                SpeculationKit.try_singleton_throw_on_failure

src/typing/type_subst.ml

@@ -211,9 +211,20 @@ class virtual ['a] type_subst_base =
         Context.make_export_map cx exps'
   end
 
+module Purpose = struct
+  type t =
+    | Normal
+    (* In generic conditional type, we have a step to replace all GenericT with any, to see whether
+     * the check will still fail (so that we can always take the false branch).
+     * During the substitution, we might encounter `Subst_name.Synthetic`. We shouldn't crash
+     * over there. Instead, we should keep them as is. *)
+    | ConditionalTypeAnySubst
+end
+
 let substituter =
   object (self)
-    inherit [replacement Subst_name.Map.t * bool * bool * use_op option] type_subst_base as super
+    inherit
+      [replacement Subst_name.Map.t * bool * bool * Purpose.t * use_op option] type_subst_base as super
 
     val mutable change_id = false
 
@@ -223,14 +234,17 @@ let substituter =
     val mutable obj_reachable_targs = None
 
     method! type_ cx map_cx t =
-      let (map, force, placeholder_no_infer, use_op) = map_cx in
+      let (map, force, placeholder_no_infer, purpose, use_op) = map_cx in
       if Subst_name.Map.is_empty map then
         t
       else
         let t_out =
           match t with
           | GenericT { name = Subst_name.Synthetic { name; op_kind; ts = ids }; reason; _ } ->
-            if Base.List.exists ~f:(fun name -> Subst_name.Map.mem name map) ids then
+            if
+              purpose = Purpose.Normal
+              && Base.List.exists ~f:(fun name -> Subst_name.Map.mem name map) ids
+            then
               failwith
                 (Utils_js.spf
                    "Cannot substitute through synthetic name %s(kind=%s) at %s."
@@ -272,14 +286,17 @@ let substituter =
               Nel.fold_left
                 (fun (xs, map, changed) typeparam ->
                   let bound =
-                    self#type_ cx (map, force, placeholder_no_infer, use_op) typeparam.Type.bound
+                    self#type_
+                      cx
+                      (map, force, placeholder_no_infer, purpose, use_op)
+                      typeparam.Type.bound
                   in
                   let default =
                     match typeparam.default with
                     | None -> None
                     | Some default ->
                       let default_ =
-                        self#type_ cx (map, force, placeholder_no_infer, use_op) default
+                        self#type_ cx (map, force, placeholder_no_infer, purpose, use_op) default
                       in
                       if default_ == default then
                         typeparam.default
@@ -296,7 +313,7 @@ let substituter =
             in
             let xs = xs |> List.rev |> Nel.of_list in
             let xs = Base.Option.value_exn xs in
-            let inner_ = self#type_ cx (map, false, placeholder_no_infer, None) inner in
+            let inner_ = self#type_ cx (map, false, placeholder_no_infer, purpose, None) inner in
             let changed = changed || inner_ != inner in
             let id =
               if change_id then
@@ -311,7 +328,9 @@ let substituter =
               t
           | ThisInstanceT (r, this, i, this_name) ->
             let (name, map) = avoid_capture map this_name in
-            let this_ = self#instance_type cx (map, force, placeholder_no_infer, use_op) this in
+            let this_ =
+              self#instance_type cx (map, force, placeholder_no_infer, purpose, use_op) this
+            in
             if this_ == this && name == this_name then
               t
             else
@@ -352,10 +371,10 @@ let substituter =
             mod_reason_of_t (Reason.replace_desc_reason desc) t_out
           | _ -> t_out
 
-    method! predicate cx (map, force, placeholder_no_infer, use_op) p =
+    method! predicate cx map_cx p =
       match p with
-      | LatentP _ -> super#predicate cx (map, force, placeholder_no_infer, use_op) p
-      | LatentThisP _ -> super#predicate cx (map, force, placeholder_no_infer, use_op) p
+      | LatentP _ -> super#predicate cx map_cx p
+      | LatentThisP _ -> super#predicate cx map_cx p
       | p -> p
 
     method! obj_type cx map_cx t =
@@ -385,27 +404,29 @@ let substituter =
         (Some name, map)
 
     method! destructor cx map_cx t =
-      let (map, _, placeholder_no_infer, _) = map_cx in
+      let (map, _, placeholder_no_infer, purpose, _) = map_cx in
       match t with
       | ConditionalType { distributive_tparam_name; infer_tparams; extends_t; true_t; false_t } ->
         let (distributive_tparam_name, map) =
           self#distributive_tparam_name distributive_tparam_name map
         in
-        let false_t' = self#type_ cx (map, false, placeholder_no_infer, None) false_t in
+        let false_t' = self#type_ cx (map, false, placeholder_no_infer, purpose, None) false_t in
         let (tparams_rev, map, changed) =
           Base.List.fold
             infer_tparams
             ~init:([], map, false)
             ~f:(fun (xs, map, changed) typeparam ->
               let bound =
-                self#type_ cx (map, false, placeholder_no_infer, None) typeparam.Type.bound
+                self#type_ cx (map, false, placeholder_no_infer, purpose, None) typeparam.Type.bound
               in
               let (name, map) = avoid_capture map typeparam.name in
               ({ typeparam with bound; name } :: xs, map, changed || bound != typeparam.bound)
           )
         in
-        let extends_t' = self#type_ cx (map, false, placeholder_no_infer, None) extends_t in
-        let true_t' = self#type_ cx (map, false, placeholder_no_infer, None) true_t in
+        let extends_t' =
+          self#type_ cx (map, false, placeholder_no_infer, purpose, None) extends_t
+        in
+        let true_t' = self#type_ cx (map, false, placeholder_no_infer, purpose, None) true_t in
         if changed || extends_t != extends_t' || true_t != true_t' || false_t != false_t' then
           ConditionalType
             {
@@ -421,11 +442,13 @@ let substituter =
         let (distributive_tparam_name, map) =
           self#distributive_tparam_name distributive_tparam_name map
         in
-        let property_type' = self#type_ cx (map, false, placeholder_no_infer, None) property_type in
+        let property_type' =
+          self#type_ cx (map, false, placeholder_no_infer, purpose, None) property_type
+        in
         let homomorphic' =
           match homomorphic with
           | SemiHomomorphic t ->
-            let t' = self#type_ cx (map, false, placeholder_no_infer, None) t in
+            let t' = self#type_ cx (map, false, placeholder_no_infer, purpose, None) t in
             if t' == t then
               homomorphic
             else
@@ -451,14 +474,23 @@ let substituter =
     method eval_id _cx _map_cx _id = assert false
   end
 
-let subst cx ?use_op ?(force = true) ?(placeholder_no_infer = false) map ty =
+let subst
+    cx ?use_op ?(force = true) ?(placeholder_no_infer = false) ?(purpose = Purpose.Normal) map ty =
   let map = Subst_name.Map.map (fun t -> TypeSubst (t, free_var_finder cx t)) map in
-  substituter#type_ cx (map, force, placeholder_no_infer, use_op) ty
+  substituter#type_ cx (map, force, placeholder_no_infer, purpose, use_op) ty
 
-let subst_destructor cx ?use_op ?(force = true) ?(placeholder_no_infer = false) map des =
+let subst_destructor
+    cx ?use_op ?(force = true) ?(placeholder_no_infer = false) ?(purpose = Purpose.Normal) map des =
   let map = Subst_name.Map.map (fun t -> TypeSubst (t, free_var_finder cx t)) map in
-  substituter#destructor cx (map, force, placeholder_no_infer, use_op) des
-
-let subst_instance_type cx ?use_op ?(force = true) ?(placeholder_no_infer = false) map instance_t =
+  substituter#destructor cx (map, force, placeholder_no_infer, purpose, use_op) des
+
+let subst_instance_type
+    cx
+    ?use_op
+    ?(force = true)
+    ?(placeholder_no_infer = false)
+    ?(purpose = Purpose.Normal)
+    map
+    instance_t =
   let map = Subst_name.Map.map (fun t -> TypeSubst (t, free_var_finder cx t)) map in
-  substituter#instance_type cx (map, force, placeholder_no_infer, use_op) instance_t
+  substituter#instance_type cx (map, force, placeholder_no_infer, purpose, use_op) instance_t

src/typing/type_subst.mli

@@ -69,11 +69,18 @@ val free_var_finder_in_destructor :
 
 val new_name : Subst_name.t -> Subst_name.Set.t -> Subst_name.t
 
+module Purpose : sig
+  type t =
+    | Normal
+    | ConditionalTypeAnySubst
+end
+
 val subst :
   Context.t ->
   ?use_op:Type.use_op ->
   ?force:bool ->
   ?placeholder_no_infer:bool ->
+  ?purpose:Purpose.t ->
   Type.t Subst_name.Map.t ->
   Type.t ->
   Type.t
@@ -83,6 +90,7 @@ val subst_destructor :
   ?use_op:Type.use_op ->
   ?force:bool ->
   ?placeholder_no_infer:bool ->
+  ?purpose:Purpose.t ->
   Type.t Subst_name.Map.t ->
   Type.destructor ->
   Type.destructor
@@ -92,6 +100,7 @@ val subst_instance_type :
   ?use_op:Type.use_op ->
   ?force:bool ->
   ?placeholder_no_infer:bool ->
+  ?purpose:Purpose.t ->
   Type.t Subst_name.Map.t ->
   Type.instance_t ->
   Type.instance_t

tests/conditional_type/crash_regression_test.js

@@ -0,0 +1,12 @@
+// Should not crash!
+type NonOptionalKeys<T> = $Values<{
+  [key in keyof T]: void extends T[key] ? empty : key,
+}>;
+type ObjectWithNonOptionalKey<T> = {
+  [key in NonOptionalKeys<T>]: T[key],
+};
+type AnotherObject<TObject> = $ReadOnly<{
+  ...ObjectWithNonOptionalKey<{
+    [key in keyof TObject]: TObject[key],
+  }>,
+}>;