[flow] Smart filtering for match bindings based on intermediate exhaustiveness analysis result

Summary:
In this diff, I implemented smart filtering for match bindings. What does it mean exactly?  An intuitive explanation is to make [this](https://flow.org/try/#1N4Igxg9gdgZglgcxALlAIwIZoKYBsD6uEEAztvhgE6UYCe+JADpdhgCYowa5kA0I2KAFcAtiRQAXSkOz9sADwxgJ+NPTbYuQ3BMnTZA+Y2yU4IwRO4A6SFBIrGVDGM7c+h46fNRLuKxJIGWh8MeT0ZfhYlCStpHzNsFBAMIQkIEQwJODAQfiEyfBE4eWw2fDgofDBMsAALfAA3KjgsXGxxZC4eAw0G-GhcWn9aY3wWZldu-g1mbGqJUoBaCRHEzrcDEgBrbAk62kXhXFxJ923d-cPRHEpTgyEoMDaqZdW7vKgoOfaSKgOKpqmDA+d4gB5fMA-P6LCCMLLQbiLOoYCqgh6-GDYRYIXYLSgkRZkCR4jpddwPfJLZjpOBkUEKTwJEJ+DAkMiUFSwkyZCC3dbdAC+-EgGiStnsAAIYMRkBKAPz2UxQBASgC8EoA5NKIBqANwAHUe0ElmAAXrLFRUVeqMntagAKADa2oAugBKCXAQ0Sn0Sx1HXASgA+EoeGngXzYLrVAD5NdgRHDaBreN7fY7xRIpcRo6q49rU1ABYbciAGiYSHBoEkGgAGKwAJgAHABOKy1kACoA) type check. This is an unresolvable problem in most of the languages with pattern matching, since there is no union type, so there is no way to assign type that represents a filtered view, but we can.

To achieve this, we should make use of the exhaustiveness analysis to compute an intermediate leftover value after first n patterns, so that bindings in the n+1-th pattern can see a refined value. In the current analysis, we already compute a `ValueUnion.t` that represents a leftover value. A `ValueUnion.t` can be turned into a type easily, so boom, we get a refined type for the n+1-th match pattern.

The process above can already refine the toplevel match binding, but what about nested ones, which is actually what's required to make the motivating example work. Well, for each nested one, we can run a selector on a parent `ValueUnion.t`, get back a new `ValueUnion.t` at the nested level, and then turn it into type. This will be a conservative process, so when we are unsure, we just bail out, and let the system compute a type based on destructuring as usual.

The following ASCII art illustrates the process:

```
match (x) {
  // previous n patterns <---- based on them
  //                           we compute VU_root ---------------
  {   //                                                      \|/
    foo: // <-- VU_nested1 = select(Selector.Prop('foo', VU_ROOT)
      [ //        |
        //        --------------------------------------------------
        //                                                       \|/
         const bar // <- VU_nested2 = select(Selector.Elem(1), VU_nested1)
      ]
    }
   } => {...}
   // remaining patterns
}
```

Now consider the original case of

```
const foo: ?string = 'foo';
const baz: string = match([foo]) {
    [null | undefined] => 'empty',
    [const foo] => foo,
}
```

Right before the `[const foo]` pattern, the `ValueUnion.t` is roughly

```
{
  tuples: [Tuple { type: '[?string]', elements: [{
    leafs: [] // no more null | void
    inexhaustible: ['string']
  }]}];
}
```

You might notice that the outer tracked type is `[?string]` instead of `[string]`. This is the correct behavior, since if the pattern is just `const foo`, it's not ok to give it the type of `[string]` due to the danger of aliasing mutable values. Still, it works as expected for the nested value, since after we run the selector, we will have this child `ValueUnion.t`:

```
{
  leafs: [] // no more null | void
  inexhaustible: ['string']
}
```

, which is turned into `string`, and we are happy.

Changelog: [fix] We improved the refinement system of match. Some code that previously gets a general type will now get a refined type. [example](https://flow.org/try/#1N4Igxg9gdgZglgcxALlAIwIZoKYBsD6uEEAztvhgE6UYCe+JADpdhgCYowa5kA0I2KAFcAtiRQAXSkOz9sADwxgJ+NPTbYuQ3BMnTZA+Y2yU4IwRO4A6SFBIrGVDGM7c+h46fNRLuKxJIGWh8MeT0ZfhYlCStpHzNsFBAMIQkIEQwJODAQfiEyfBE4eWw2fDgofDBMsAALfAA3KjgsXGxxZC4eAw0G-GhcWn9aY3wWZldu-g1mbGqJUoBaCRHEzrcDEgBrbAk62kXhXFxJ923d-cPRHEpTgyEoMDaqZdW7vKgoOfaSKgOKpqmDA+d4gB5fMA-P6LCCMLLQbiLOoYCqgh6-GDYRYIXYLSgkRZkCR4jpddwPfJLZjpOBkUEKTwJEJ+DAkMiUFSwkyZCC3dbdAC+-EgGiStnsAAIYMRkBKAPz2UxQBASgC8EoA5NKIBqANwAHUe0ElmAAXrLFRUVeqMntagAKADa2oAugBKCXAQ0Sn0Sx1HXASgA+EoeGngXzYLrVAD5NdgRHDaBreN7fY7xRIpcRo6q49rU1ABYbciAGiYSHBoEkGgAGKwAJgAHABOKy1kACoA)

Reviewed By: gkz

Differential Revision: D85388235

fbshipit-source-id: f88d5582afcc7da23f790d05f219d72d2c71be69

Author: SamChou19815

src/analysis/env_builder/name_def.ml

@@ -3269,7 +3269,10 @@ class def_finder ~autocomplete_hooks ~react_jsx env_info toplevel_scope =
           ~init:[]
           ~f:(fun i prev_pattern_locs_rev (_, { Case.pattern; body; guard; case_match_root_loc; _ })
              ->
-            let acc = MatchCaseRoot { case_match_root_loc; prev_pattern_locs_rev } in
+            let acc =
+              MatchCaseRoot
+                { case_match_root_loc; root_pattern_loc = fst pattern; prev_pattern_locs_rev }
+            in
             this#add_match_destructure_bindings
               ~case_match_root_loc
               ~has_guard:(Option.is_some guard)
@@ -3301,7 +3304,10 @@ class def_finder ~autocomplete_hooks ~react_jsx env_info toplevel_scope =
           ~init:[]
           ~f:(fun prev_pattern_locs_rev (_, { Case.pattern; body; guard; case_match_root_loc; _ })
              ->
-            let acc = MatchCaseRoot { case_match_root_loc; prev_pattern_locs_rev } in
+            let acc =
+              MatchCaseRoot
+                { case_match_root_loc; root_pattern_loc = fst pattern; prev_pattern_locs_rev }
+            in
             this#add_match_destructure_bindings
               ~case_match_root_loc
               ~has_guard:(Option.is_some guard)

src/analysis/env_builder/name_def_ordering.ml

@@ -985,7 +985,7 @@ struct
         | Value { hints; expr; decl_kind = _; as_const = _ } ->
           let state = depends_of_hints state hints in
           depends_of_expression expr state
-        | MatchCaseRoot { case_match_root_loc; prev_pattern_locs_rev } ->
+        | MatchCaseRoot { case_match_root_loc; root_pattern_loc = _; prev_pattern_locs_rev } ->
           depends_of_node
             (fun visitor ->
               run visitor#identifier (Flow_ast_utils.match_root_ident case_match_root_loc);

src/analysis/env_builder/name_def_types.ml

@@ -102,6 +102,7 @@ type root =
   | Value of value
   | MatchCaseRoot of {
       case_match_root_loc: ALoc.t;
+      root_pattern_loc: ALoc.t;
       prev_pattern_locs_rev: ALoc.t list;
     }
   | FunctionValue of {
@@ -241,7 +242,7 @@ module Print = struct
     | UnannotatedParameter r -> Reason.string_of_reason r
     | Annotation { annot = (loc, _); _ } -> spf "annot %s" (ALoc.debug_to_string loc)
     | Value { expr = (loc, _); _ } -> spf "val %s" (ALoc.debug_to_string loc)
-    | MatchCaseRoot { case_match_root_loc; prev_pattern_locs_rev = _ } ->
+    | MatchCaseRoot { case_match_root_loc; root_pattern_loc = _; prev_pattern_locs_rev = _ } ->
       spf "match root for case at %s" (ALoc.debug_to_string case_match_root_loc)
     | FunctionValue { function_loc; _ } -> spf "function val %s" (ALoc.debug_to_string function_loc)
     | ObjectValue _ -> "object"

src/typing/env_resolution.ml

@@ -480,8 +480,19 @@ let rec resolve_binding cx def_scope_kind reason loc b =
       t
   | Root (Value { hints = _; expr; decl_kind; as_const }) ->
     expression cx ?decl:decl_kind ~as_const expr
-  | Root (MatchCaseRoot { case_match_root_loc; prev_pattern_locs_rev = _ }) ->
-    Type_env.var_ref cx (OrdinaryName Flow_ast_utils.match_root_name) case_match_root_loc
+  | Root (MatchCaseRoot { case_match_root_loc; root_pattern_loc; prev_pattern_locs_rev }) ->
+    let unfiltered_t =
+      Type_env.var_ref cx (OrdinaryName Flow_ast_utils.match_root_name) case_match_root_loc
+    in
+    let node_cache = Context.node_cache cx in
+    let patterns =
+      Base.List.rev_map prev_pattern_locs_rev ~f:(fun l ->
+          Base.Option.value_exn (Node_cache.get_match_pattern node_cache l)
+      )
+    in
+    let value_left = Exhaustive.partial_leftover_value_union cx patterns unfiltered_t in
+    Node_cache.set_match_pattern_value_union (Context.node_cache cx) root_pattern_loc value_left;
+    Match_pattern_ir.ValueUnion.to_type (TypeUtil.reason_of_t unfiltered_t) value_left
   | Root (ObjectValue { obj_loc = loc; obj; synthesizable = ObjectSynthesizable _ }) ->
     let open Ast.Expression.Object in
     let resolve_prop ~bind_this ~prop_loc ~fn_loc fn =
@@ -832,44 +843,56 @@ let rec resolve_binding cx def_scope_kind reason loc b =
     let t = resolve_binding cx def_scope_kind reason loc binding in
     make_hooklike cx t
   | Select { selector; parent = (parent_loc, binding) } ->
-    let refined_type =
-      match selector with
-      | Selector.Prop { prop; prop_loc; _ } ->
-        let desc = RProperty (Some (OrdinaryName prop)) in
-        Type_env.get_refinement cx desc prop_loc
-      | _ -> None
+    let node_cache = Context.node_cache cx in
+    let filtered_pattern_type =
+      Node_cache.get_match_pattern_value_union node_cache parent_loc
+      |> Base.Option.bind ~f:(Match_pattern_ir.ValueUnion.select ~selector)
+      |> Base.Option.map ~f:(fun value_left ->
+             Node_cache.set_match_pattern_value_union node_cache loc value_left;
+             Match_pattern_ir.ValueUnion.to_type reason value_left
+         )
     in
-    (match refined_type with
-    | Some t ->
-      (* When we can get a refined value on a destructured property,
-         we must be in an assignment position and the type must have been resolved. *)
-      t
+    (match filtered_pattern_type with
+    | Some t -> t
     | None ->
-      let t = Type_env.checked_find_loc_env_write cx Env_api.PatternLoc parent_loc in
-      let has_anno = binding_has_annot binding in
-      let (selector, reason, has_default) = mk_selector_reason_has_default cx loc selector in
-      let kind =
-        if has_anno then
-          DestructAnnot
-        else
-          DestructInfer
+      let refined_type =
+        match selector with
+        | Selector.Prop { prop; prop_loc; _ } ->
+          let desc = RProperty (Some (OrdinaryName prop)) in
+          Type_env.get_refinement cx desc prop_loc
+        | _ -> None
       in
-      let t =
-        Flow_js_utils.map_on_resolved_type cx reason t (fun t ->
-            Tvar_resolver.mk_tvar_and_fully_resolve_no_wrap_where cx reason (fun tout ->
-                Flow_js.flow cx (t, DestructuringT (reason, kind, selector, tout, Reason.mk_id ()))
-            )
-        )
-      in
-      if has_default then
-        let (selector, reason, _) = mk_selector_reason_has_default cx loc Selector.Default in
-        Flow_js_utils.map_on_resolved_type cx reason t (fun t ->
-            Tvar_resolver.mk_tvar_and_fully_resolve_no_wrap_where cx reason (fun tout ->
-                Flow_js.flow cx (t, DestructuringT (reason, kind, selector, tout, Reason.mk_id ()))
-            )
-        )
-      else
-        t)
+      (match refined_type with
+      | Some t ->
+        (* When we can get a refined value on a destructured property,
+           we must be in an assignment position and the type must have been resolved. *)
+        t
+      | None ->
+        let t = Type_env.checked_find_loc_env_write cx Env_api.PatternLoc parent_loc in
+        let has_anno = binding_has_annot binding in
+        let (selector, reason, has_default) = mk_selector_reason_has_default cx loc selector in
+        let kind =
+          if has_anno then
+            DestructAnnot
+          else
+            DestructInfer
+        in
+        let t =
+          Flow_js_utils.map_on_resolved_type cx reason t (fun t ->
+              Tvar_resolver.mk_tvar_and_fully_resolve_no_wrap_where cx reason (fun tout ->
+                  Flow_js.flow cx (t, DestructuringT (reason, kind, selector, tout, Reason.mk_id ()))
+              )
+          )
+        in
+        if has_default then
+          let (selector, reason, _) = mk_selector_reason_has_default cx loc Selector.Default in
+          Flow_js_utils.map_on_resolved_type cx reason t (fun t ->
+              Tvar_resolver.mk_tvar_and_fully_resolve_no_wrap_where cx reason (fun tout ->
+                  Flow_js.flow cx (t, DestructuringT (reason, kind, selector, tout, Reason.mk_id ()))
+              )
+          )
+        else
+          t))
 
 let resolve_inferred_function
     cx ~scope_kind ~statics ~needs_this_param id_loc reason function_loc function_ =

src/typing/exhaustive.ml

@@ -1537,3 +1537,11 @@ let analyze cx ~match_loc patterns arg_t =
       (Error_message.EMatchNotExhaustive { loc = match_loc; examples; missing_pattern_asts = asts })
   );
   check_for_unused_patterns cx pattern_union used_pattern_locs
+
+let partial_leftover_value_union cx patterns root_t =
+  let pattern_union = PatternUnionBuilder.of_patterns_ast cx ~raise_errors:false patterns in
+  let value_union = ValueUnionBuilder.of_type cx root_t in
+  let { value_left; used_pattern_locs = _; value_matched = _ } =
+    filter_values_by_patterns cx ~raise_errors:false ~value_union ~pattern_union
+  in
+  value_left

src/typing/exhaustive.mli

@@ -13,3 +13,9 @@ val analyze :
   ((ALoc.t, ALoc.t * Type.t) Flow_ast.MatchPattern.t * (* guarded *) bool) list ->
   Type.t ->
   unit
+
+val partial_leftover_value_union :
+  Context.t ->
+  ((ALoc.t, ALoc.t * Type.t) Flow_ast.MatchPattern.t * (* guarded *) bool) list ->
+  Type.t ->
+  Match_pattern_ir.ValueUnion.t

src/typing/match_pattern_ir.ml

@@ -544,6 +544,8 @@ module rec ValueObject : sig
 
   type t = Reason.t * t'
 
+  val to_original_type : t -> Type.t
+
   val to_pattern : t -> PatternObject.t
 end = struct
   module Property = struct
@@ -571,6 +573,8 @@ end = struct
 
   type t = Reason.t * t'
 
+  let to_original_type (_, { t; _ }) = t
+
   let to_pattern (reason, { props; class_info; rest; kind; sentinel_props; _ }) =
     let loc = Reason.loc_of_reason reason in
     let (props, keys_order, rest) =
@@ -679,6 +683,10 @@ and ValueUnion : sig
   val is_empty : t -> bool
 
   val to_pattern : t -> PatternUnion.t
+
+  val to_type : Reason.t -> t -> Type.t
+
+  val select : selector:Selector.t -> t -> t option
 end = struct
   type t = {
     leafs: LeafSet.t;
@@ -707,6 +715,33 @@ end = struct
     && Base.List.is_empty enum_unknown_members
     && Base.List.is_empty inexhaustible
 
+  let union
+      {
+        leafs = leafs1;
+        tuples = tuples1;
+        arrays = arrays1;
+        objects = objects1;
+        enum_unknown_members = enum_unknown_members1;
+        inexhaustible = inexhaustible1;
+      }
+      {
+        leafs = leafs2;
+        tuples = tuples2;
+        arrays = arrays2;
+        objects = objects2;
+        enum_unknown_members = enum_unknown_members2;
+        inexhaustible = inexhaustible2;
+      } =
+    {
+      leafs = LeafSet.union leafs1 leafs2;
+      tuples = Base.List.rev_append (List.rev tuples1) tuples2;
+      arrays = Base.List.rev_append (List.rev arrays1) arrays2;
+      objects = Base.List.rev_append (List.rev objects1) objects2;
+      enum_unknown_members =
+        Base.List.rev_append (List.rev enum_unknown_members1) enum_unknown_members2;
+      inexhaustible = Base.List.rev_append (List.rev inexhaustible1) inexhaustible2;
+    }
+
   let to_pattern { leafs; tuples; arrays; objects; enum_unknown_members; inexhaustible } =
     let (tuples_exact, tuples_inexact) =
       tuples
@@ -767,4 +802,73 @@ end = struct
       | (_, (reason, _) :: _) -> Some reason
     in
     { PatternUnion.empty with PatternUnion.leafs; tuples_exact; tuples_inexact; objects; wildcard }
+
+  let to_type r { leafs; tuples; arrays; objects; enum_unknown_members; inexhaustible } =
+    let all_possible_types =
+      Base.List.concat
+        [
+          leafs |> LeafSet.elements |> Base.List.map ~f:Leaf.to_type;
+          Base.List.map tuples ~f:ValueObject.to_original_type;
+          Base.List.map arrays ~f:ValueObject.to_original_type;
+          Base.List.map objects ~f:ValueObject.to_original_type;
+          Base.List.bind enum_unknown_members ~f:(fun (_, leaf_set) ->
+              LeafSet.elements leaf_set |> Base.List.map ~f:Leaf.to_type
+          );
+          inexhaustible;
+        ]
+    in
+    TypeUtil.union_of_ts r all_possible_types
+
+  let select
+      ~selector
+      ( { leafs = _; tuples; arrays; objects; enum_unknown_members = _; inexhaustible = _ } as
+      value_union
+      ) =
+    (* Given a list of values, select a sub-value matching the given key.
+     * This is intend to be conservative. If we are unsure whether the key definitely exists/not exists,
+     * we will abort and return None. Otherwise, we return `Some(candidates)` *)
+    let conservative_find key values =
+      let rec loop acc = function
+        | [] -> Some (List.rev acc)
+        | (_, { ValueObject.kind = _; t = _; props; rest; class_info = _; sentinel_props = _ })
+          :: rest_values ->
+          (match SMap.find_opt key props with
+          | None ->
+            if Base.Option.is_some rest then
+              None
+            else
+              loop acc rest_values
+          | Some None ->
+            (* We definitely know the field doesn't exist. *)
+            loop acc rest_values
+          | Some (Some v) -> loop (v.ValueObject.Property.value :: acc) rest_values)
+      in
+      loop [] values
+    in
+    let conservative_find_all key =
+      match conservative_find key tuples with
+      | None -> None
+      | Some tuple_candidates ->
+        (match conservative_find key arrays with
+        | None -> None
+        | Some array_candidates ->
+          (match conservative_find key objects with
+          | None -> None
+          | Some object_candidates ->
+            Some (Base.List.concat [tuple_candidates; array_candidates; object_candidates])))
+    in
+    let vus_opt =
+      match selector with
+      | Selector.Elem { index; has_default = _ } ->
+        let key = string_of_int index in
+        conservative_find_all key
+      | Selector.Prop { prop; prop_loc = _; has_default = _ } -> conservative_find_all prop
+      | Selector.Computed _ -> None
+      | Selector.ObjRest _ -> None
+      | Selector.ArrRest _ -> None
+      | Selector.Default -> Some [lazy value_union]
+    in
+    match vus_opt with
+    | None -> None
+    | Some vus -> Some (Base.List.fold_right vus ~init:empty ~f:(fun (lazy vu) acc -> union vu acc))
 end

src/typing/match_pattern_ir.mli

@@ -183,4 +183,8 @@ and ValueUnion : sig
   val is_empty : t -> bool
 
   val to_pattern : t -> PatternUnion.t
+
+  val to_type : Reason.t -> t -> Type.t
+
+  val select : selector:Selector.t -> t -> t option
 end

src/typing/node_cache.ml

@@ -51,6 +51,7 @@ type cache = {
     )
     ALocMap.t;
   match_patterns: ((ALoc.t, ALoc.t * Type.t) Ast.MatchPattern.t * bool) ALocMap.t;
+  match_pattern_value_unions: Match_pattern_ir.ValueUnion.t ALocMap.t;
 }
 
 type t = cache ref
@@ -75,6 +76,7 @@ let mk_empty () =
       tparams = ALocMap.empty;
       component_sigs = ALocMap.empty;
       match_patterns = ALocMap.empty;
+      match_pattern_value_unions = ALocMap.empty;
     }
 
 let set_annotation cache ((loc, _) as anno) =
@@ -129,6 +131,10 @@ let set_component_sig cache loc c =
 let set_match_pattern cache loc p =
   cache := { !cache with match_patterns = ALocMap.add loc p !cache.match_patterns }
 
+let set_match_pattern_value_union cache loc v =
+  cache :=
+    { !cache with match_pattern_value_unions = ALocMap.add loc v !cache.match_pattern_value_unions }
+
 let get_annotation cache loc = ALocMap.find_opt loc !cache.annotations
 
 let get_expression cache loc = ALocMap.find_opt loc !cache.expressions
@@ -162,3 +168,5 @@ let get_tparam cache loc = ALocMap.find_opt loc !cache.tparams
 let get_component_sig cache loc = ALocMap.find_opt loc !cache.component_sigs
 
 let get_match_pattern cache loc = ALocMap.find_opt loc !cache.match_patterns
+
+let get_match_pattern_value_union cache loc = ALocMap.find_opt loc !cache.match_pattern_value_unions

src/typing/node_cache.mli

@@ -79,6 +79,8 @@ val set_component_sig :
 
 val set_match_pattern : t -> ALoc.t -> (ALoc.t, ALoc.t * Type.t) Ast.MatchPattern.t * bool -> unit
 
+val set_match_pattern_value_union : t -> ALoc.t -> Match_pattern_ir.ValueUnion.t -> unit
+
 val get_annotation : t -> ALoc.t -> (ALoc.t, ALoc.t * Type.t) Ast.Type.annotation option
 
 val get_expression : t -> ALoc.t -> (ALoc.t, ALoc.t * Type.t) Ast.Expression.t option
@@ -149,3 +151,5 @@ val get_component_sig :
   option
 
 val get_match_pattern : t -> ALoc.t -> ((ALoc.t, ALoc.t * Type.t) Ast.MatchPattern.t * bool) option
+
+val get_match_pattern_value_union : t -> ALoc.t -> Match_pattern_ir.ValueUnion.t option