[flow][refactor] Type check match_pattern in env_resolution

Summary:
In this diff, we now run type checking for match patterns in env_resolution, and the result will be stored in node_cache. This will enable us to check exhaustiveness during inference, to make [this example](https://flow.org/try/#1N4Igxg9gdgZglgcxALlAIwIZoKYBsD6uEEAztvhgE6UYCe+JADpdhgCYowa5kA0I2KAFcAtiRQAXSkOz9sADwxgJ+NPTbYuQ3BMnTZA+Y2yU4IwRO4A6SFBIrGVDGM7c+h46fNRLuKxJIGWh8MeT0ZfhYlCStpHzNsFBAMIQkIEQwJODAQfiEyfBE4eWw2fDgofDBMsAALfAA3KjgsXGxxZC4eAw0G-GhcWn9aY3wWZldu-g1mbGqJUoBaCRHEzrcDEgBrbAk62kXhXFxJ923d-cPRHEpTgyEoMDaqZdW7vKgoOfaSKgOKpqmDA+d4gB5fMA-P6LCCMLLQbiLOoYCqgh6-GDYRYIXYLSgkRZkCR4jpddwPfJLZjpOBkUEKTwJEJ+DAkMiUFSwkyZCC3dbdAC+-EgGiSGieVGwAAJbPYpfJkFKANoARilAB8pQAmAC6AG4ADpQI2yiRSiCpKUAXilGT2tSlAAp5ABKKXAI1Sr3KlU660APilAAZeJ7vUrTVKMH6rYGMFGSNrQ1ABXrciAGiYSHBoEkGkGrFqAOwAVisQZAAqAA) type check.

Changelog: [internal]

Reviewed By: panagosg7

Differential Revision: D85289492

fbshipit-source-id: 8ec47a4cbe3b885ad7f7ba90d9626cd2c1dc7788

Author: SamChou19815

src/analysis/env_builder/name_def.ml

@@ -3270,7 +3270,11 @@ class def_finder ~autocomplete_hooks ~react_jsx env_info toplevel_scope =
           ~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
-            this#add_match_destructure_bindings ~case_match_root_loc acc pattern;
+            this#add_match_destructure_bindings
+              ~case_match_root_loc
+              ~has_guard:(Option.is_some guard)
+              acc
+              pattern;
             ignore @@ super#match_pattern pattern;
             Base.Option.iter guard ~f:(this#visit_expression ~hints:[] ~cond:OtherTestContext);
             (* We use best-effort value hints for cases other than the current case.
@@ -3298,7 +3302,11 @@ class def_finder ~autocomplete_hooks ~react_jsx env_info toplevel_scope =
           ~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
-            this#add_match_destructure_bindings ~case_match_root_loc acc pattern;
+            this#add_match_destructure_bindings
+              ~case_match_root_loc
+              ~has_guard:(Option.is_some guard)
+              acc
+              pattern;
             ignore @@ super#match_pattern pattern;
             Base.Option.iter guard ~f:(this#visit_expression ~hints:[] ~cond:OtherTestContext);
             run this#statement body;
@@ -3307,7 +3315,7 @@ class def_finder ~autocomplete_hooks ~react_jsx env_info toplevel_scope =
       in
       x
 
-    method add_match_destructure_bindings ~case_match_root_loc root pattern =
+    method add_match_destructure_bindings ~case_match_root_loc ~has_guard root pattern =
       let visit_binding loc name binding =
         let binding = this#mk_hooklike_if_necessary (Flow_ast_utils.hook_name name) binding in
         this#add_ordinary_binding
@@ -3319,7 +3327,7 @@ class def_finder ~autocomplete_hooks ~react_jsx env_info toplevel_scope =
       this#add_binding
         (Env_api.MatchCasePatternLoc, pattern_loc)
         (mk_reason RMatchPattern pattern_loc)
-        (MatchCasePattern { case_match_root_loc; pattern });
+        (MatchCasePattern { case_match_root_loc; has_guard; pattern });
       MatchPattern.visit_pattern
         ~visit_binding
         ~visit_expression:(this#visit_expression ~hints:[] ~cond:MatchPattern)

src/analysis/env_builder/name_def_ordering.ml

@@ -1188,7 +1188,7 @@ struct
       in
       function
       | Binding binding -> depends_of_binding binding
-      | MatchCasePattern { case_match_root_loc; pattern } ->
+      | MatchCasePattern { case_match_root_loc; has_guard = _; pattern } ->
         depends_on_match_pattern case_match_root_loc pattern EnvMap.empty
       | ExpressionDef { expr; hints; _ } ->
         depends_of_hinted_expression ~for_expression_writes:true hints expr EnvMap.empty

src/analysis/env_builder/name_def_types.ml

@@ -169,6 +169,7 @@ type def =
   | Binding of binding
   | MatchCasePattern of {
       case_match_root_loc: ALoc.t;
+      has_guard: bool;
       pattern: (ALoc.t, ALoc.t) Ast.MatchPattern.t;
     }
   | ExpressionDef of expression_def

src/typing/env_resolution.ml

@@ -1072,8 +1072,10 @@ let resolve_chain_expression cx ~cond exp =
 
 let resolve_write_expression cx ~cond exp = synthesizable_expression cx ~encl_ctx:cond exp
 
-let resolve_match_pattern cx def_scope_kind def_reason case_match_root_loc pattern =
-  ignore (cx, def_scope_kind, def_reason, case_match_root_loc, pattern);
+let resolve_match_pattern cx def_reason case_match_root_loc ~has_guard pattern =
+  let (_pattern : (ALoc.t, ALoc.t * Type.t) Ast.MatchPattern.t) =
+    Statement.match_pattern cx case_match_root_loc ~has_guard pattern
+  in
   MixedT.why def_reason
 
 let resolve_generator_next cx reason gen =
@@ -1116,8 +1118,8 @@ let resolve cx (def_kind, id_loc) (def, def_scope_kind, class_stack, def_reason)
   let t =
     match def with
     | Binding b -> resolve_binding cx def_scope_kind def_reason id_loc b
-    | MatchCasePattern { case_match_root_loc; pattern } ->
-      resolve_match_pattern cx def_scope_kind def_reason case_match_root_loc pattern
+    | MatchCasePattern { case_match_root_loc; has_guard; pattern } ->
+      resolve_match_pattern cx def_reason case_match_root_loc ~has_guard pattern
     | ExpressionDef { cond_context = cond; expr; chain = true; hints = _ } ->
       resolve_chain_expression cx ~cond expr
     | ExpressionDef { cond_context = cond; expr; chain = false; hints = _ } ->

src/typing/node_cache.ml

@@ -50,6 +50,7 @@ type cache = {
       )
     )
     ALocMap.t;
+  match_patterns: ((ALoc.t, ALoc.t * Type.t) Ast.MatchPattern.t * bool) ALocMap.t;
 }
 
 type t = cache ref
@@ -73,6 +74,7 @@ let mk_empty () =
       class_sigs = ALocMap.empty;
       tparams = ALocMap.empty;
       component_sigs = ALocMap.empty;
+      match_patterns = ALocMap.empty;
     }
 
 let set_annotation cache ((loc, _) as anno) =
@@ -124,6 +126,9 @@ let set_tparam cache (((loc, _), _, _) as param) =
 let set_component_sig cache loc c =
   cache := { !cache with component_sigs = ALocMap.add loc c !cache.component_sigs }
 
+let set_match_pattern cache loc p =
+  cache := { !cache with match_patterns = ALocMap.add loc p !cache.match_patterns }
+
 let get_annotation cache loc = ALocMap.find_opt loc !cache.annotations
 
 let get_expression cache loc = ALocMap.find_opt loc !cache.expressions
@@ -155,3 +160,5 @@ let get_class_sig cache loc = ALocMap.find_opt loc !cache.class_sigs
 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

src/typing/node_cache.mli

@@ -77,6 +77,8 @@ val set_component_sig :
     ) ->
   unit
 
+val set_match_pattern : t -> ALoc.t -> (ALoc.t, ALoc.t * Type.t) Ast.MatchPattern.t * bool -> 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
@@ -145,3 +147,5 @@ val get_component_sig :
     )
   )
   option
+
+val get_match_pattern : t -> ALoc.t -> ((ALoc.t, ALoc.t * Type.t) Ast.MatchPattern.t * bool) option

src/typing/statement.ml

@@ -1339,23 +1339,7 @@ module Make
                 case
               in
               let pattern =
-                Match_pattern.pattern
-                  cx
-                  ( case_match_root_loc,
-                    Flow_ast.Expression.Identifier
-                      (Flow_ast_utils.match_root_ident case_match_root_loc)
-                  )
-                  pattern
-                  ~on_identifier:(fun ~encl_ctx cx ->
-                    identifier cx { empty_syntactic_flags with Natural_inference.encl_ctx })
-                  ~on_expression:expression
-                  ~on_binding:(fun ~use_op ~name_loc ~kind name t ->
-                    init_var kind cx ~use_op t name_loc;
-                    Type_env.constraining_type
-                      ~default:(Type_env.get_var_declared_type cx (OrdinaryName name) name_loc)
-                      cx
-                      name
-                      name_loc)
+                match_pattern cx case_match_root_loc ~has_guard:(Option.is_some guard) pattern
               in
               let guard = Base.Option.map ~f:(expression cx) guard in
               (match body with
@@ -3129,22 +3113,7 @@ module Make
                 case
               in
               let pattern =
-                Match_pattern.pattern
-                  cx
-                  ( case_match_root_loc,
-                    Identifier (Flow_ast_utils.match_root_ident case_match_root_loc)
-                  )
-                  pattern
-                  ~on_identifier:(fun ~encl_ctx cx ->
-                    identifier cx { empty_syntactic_flags with Natural_inference.encl_ctx })
-                  ~on_expression:expression
-                  ~on_binding:(fun ~use_op ~name_loc ~kind name t ->
-                    init_var kind cx ~use_op t name_loc;
-                    Type_env.constraining_type
-                      ~default:(Type_env.get_var_declared_type cx (OrdinaryName name) name_loc)
-                      cx
-                      name
-                      name_loc)
+                match_pattern cx case_match_root_loc ~has_guard:(Option.is_some guard) pattern
               in
               let (guard, guard_throws) =
                 match guard with
@@ -9014,6 +8983,32 @@ module Make
     in
     { enum_name; enum_id; members; representation_t; has_unknown_members }
 
+  and match_pattern cx case_match_root_loc ~has_guard pattern =
+    let node_cache = Context.node_cache cx in
+    match Node_cache.get_match_pattern node_cache (fst pattern) with
+    | Some (p, _has_guard) -> p
+    | None ->
+      let p =
+        Match_pattern.pattern
+          cx
+          ( case_match_root_loc,
+            Flow_ast.Expression.Identifier (Flow_ast_utils.match_root_ident case_match_root_loc)
+          )
+          pattern
+          ~on_identifier:(fun ~encl_ctx cx ->
+            identifier cx { empty_syntactic_flags with Natural_inference.encl_ctx })
+          ~on_expression:expression
+          ~on_binding:(fun ~use_op ~name_loc ~kind name t ->
+            init_var kind cx ~use_op t name_loc;
+            Type_env.constraining_type
+              ~default:(Type_env.get_var_declared_type cx (OrdinaryName name) name_loc)
+              cx
+              name
+              name_loc)
+      in
+      Node_cache.set_match_pattern node_cache (fst pattern) (p, has_guard);
+      p
+
   and error_on_match_case_invalid_syntax
       cx ~match_keyword_loc (invalid_syntax_list : ALoc.t Flow_ast.Match.Case.InvalidSyntax.t list)
       : unit =

src/typing/statement_sig.ml

@@ -276,4 +276,11 @@ module type S = sig
     Type.t
 
   val empty_array : Context.t -> ALoc.t -> Reason.t * Type.t
+
+  val match_pattern :
+    Context.t ->
+    ALoc.t ->
+    has_guard:bool ->
+    (ALoc.t, ALoc.t) Ast.MatchPattern.t ->
+    (ALoc.t, ALoc.t * Type.t) Ast.MatchPattern.t
 end