De-functorize ImportTypeTKit and ImportTypeofTKit

Summary:
With previous refactors, we cut of a lot of dependency on `Import_export_helper_sig` for these two kits. Instead of relying on a few functions in it, we can just make the caller pass in the required functions.

This function opens up the usage of these kits in statement.ml, and the potential to kill `ImportTypeT` and `ImportTypeofT`.

Changelog: [internal]

Reviewed By: panagosg7

Differential Revision: D46205969

fbshipit-source-id: 70b967d8d3a03105ec117a1364bd1d996b7dda46

Author: SamChou19815

src/typing/annotation_inference.ml

@@ -249,16 +249,13 @@ module rec ConsGen : S = struct
   (***********)
   (* Imports *)
   (***********)
-  module Import_export_helper = struct
+  module Import_export_helper : Flow_js_utils.Import_export_helper_sig with type r = Type.t = struct
     type r = Type.t
 
     let reposition cx ?trace:_ loc ?desc:_ ?annot_loc:_ t = reposition cx loc t
 
     let return _cx _trace t = t
 
-    let with_concretized_type cx r f t =
-      ConsGen.elab_t cx t (Annot_ConcretizeForImportsExports (r, f))
-
     let export_named cx _trace (reason, named, kind) t = ConsGen.export_named cx reason kind named t
 
     let export_named_fresh_var = export_named
@@ -268,18 +265,17 @@ module rec ConsGen : S = struct
 
     let cjs_extract_named_exports cx _ (reason, local_module) t =
       ConsGen.cjs_extract_named_exports cx reason local_module t
+  end
 
-    (* This check is bypassed in annotation inference *)
-    let assert_import_is_value _cx _trace _reason _name _export_t = ()
+  let assert_import_is_value _cx _trace _reason _name _export_t = ()
 
-    let mk_typeof_annotation = ConsGen.mk_typeof_annotation
-  end
+  let with_concretized_type cx r f t = ConsGen.elab_t cx t (Annot_ConcretizeForImportsExports (r, f))
 
   module CJSRequireTKit = Flow_js_utils.CJSRequireT_kit (Import_export_helper)
   module ImportModuleNsTKit = Flow_js_utils.ImportModuleNsTKit
-  module ImportDefaultTKit = Flow_js_utils.ImportDefaultT_kit (Import_export_helper)
-  module ImportNamedTKit = Flow_js_utils.ImportNamedT_kit (Import_export_helper)
-  module ImportTypeofTKit = Flow_js_utils.ImportTypeofT_kit (Import_export_helper)
+  module ImportDefaultTKit = Flow_js_utils.ImportDefaultTKit
+  module ImportNamedTKit = Flow_js_utils.ImportNamedTKit
+  module ImportTypeofTKit = Flow_js_utils.ImportTypeofTKit
   module ExportNamedTKit = Flow_js_utils.ExportNamedT_kit (Import_export_helper)
   module AssertExportIsTypeTKit = Flow_js_utils.AssertExportIsTypeT_kit (Import_export_helper)
   module CopyNamedExportsTKit = Flow_js_utils.CopyNamedExportsT_kit (Import_export_helper)
@@ -568,7 +564,13 @@ module rec ConsGen : S = struct
     (* `import typeof` *)
     (*******************)
     | (_, Annot_ImportTypeofT (reason, export_name)) ->
-      ImportTypeofTKit.on_concrete_type cx dummy_trace reason export_name t
+      ImportTypeofTKit.on_concrete_type
+        cx
+        dummy_trace
+        ~mk_typeof_annotation:ConsGen.mk_typeof_annotation
+        reason
+        export_name
+        t
     (******************)
     (* Module exports *)
     (******************)
@@ -596,11 +598,21 @@ module rec ConsGen : S = struct
     | (ModuleT m, Annot_ImportModuleNsT (reason, is_strict)) ->
       ImportModuleNsTKit.on_ModuleT cx dummy_trace (reason, is_strict) m
     | (ModuleT m, Annot_ImportDefaultT (reason, import_kind, local, is_strict)) ->
-      ImportDefaultTKit.on_ModuleT cx dummy_trace (reason, import_kind, local, is_strict) m
+      ImportDefaultTKit.on_ModuleT
+        cx
+        dummy_trace
+        ~mk_typeof_annotation:ConsGen.mk_typeof_annotation
+        ~assert_import_is_value
+        ~with_concretized_type
+        (reason, import_kind, local, is_strict)
+        m
     | (ModuleT m, Annot_ImportNamedT (reason, import_kind, export_name, module_name, is_strict)) ->
       ImportNamedTKit.on_ModuleT
         cx
         dummy_trace
+        ~mk_typeof_annotation:ConsGen.mk_typeof_annotation
+        ~assert_import_is_value
+        ~with_concretized_type
         (reason, import_kind, export_name, module_name, is_strict)
         m
     | (AnyT (lreason, src), (Annot_CJSRequireT { reason; _ } | Annot_ImportModuleNsT (reason, _)))

src/typing/flow_common.ml

@@ -305,6 +305,8 @@ module type S = sig
 
   val possible_concrete_types_for_inspection : Context.t -> Reason.reason -> Type.t -> Type.t list
 
+  val singleton_concrete_type_for_inspection : Context.t -> Reason.reason -> Type.t -> Type.t
+
   val possible_concrete_types_for_computed_props :
     Context.t -> Reason.reason -> Type.t -> Type.t list
 

src/typing/flow_js.ml

@@ -245,22 +245,19 @@ struct
   module InstantiationKit = Instantiation_kit (InstantiationHelper)
   module ImplicitInstantiationKit = Implicit_instantiation.Kit (FlowJs) (InstantiationHelper)
 
-  module Import_export_helper = struct
+  let assert_import_is_value cx trace reason name export_t =
+    FlowJs.rec_flow cx trace (export_t, AssertImportIsValueT (reason, name))
+
+  let with_concretized_type cx r f t = f (FlowJs.singleton_concrete_type_for_inspection cx r t)
+
+  module Import_export_helper :
+    Flow_js_utils.Import_export_helper_sig with type r = Type.t -> unit = struct
     type r = Type.t -> unit
 
     let reposition = FlowJs.reposition
 
     let return cx trace t tout = FlowJs.rec_flow_t cx ~use_op:unknown_use trace (t, tout)
 
-    let with_concretized_type cx r f t =
-      let t' =
-        match FlowJs.possible_concrete_types_for_inspection cx r t with
-        | [] -> EmptyT.make r (bogus_trust ())
-        | [t] -> t
-        | t1 :: t2 :: ts -> UnionT (r, UnionRep.make t1 t2 ts)
-      in
-      f t'
-
     let export_named cx trace (reason, named, kind) module_t tout =
       FlowJs.rec_flow cx trace (module_t, Type.ExportNamedT (reason, named, kind, tout))
 
@@ -278,17 +275,9 @@ struct
       Tvar.mk_where cx reason (fun t ->
           FlowJs.rec_flow cx trace (proto_t, CJSExtractNamedExportsT (reason, local_module, t))
       )
-
-    let assert_import_is_value cx trace reason name export_t =
-      FlowJs.rec_flow cx trace (export_t, AssertImportIsValueT (reason, name))
-
-    let mk_typeof_annotation = FlowJs.mk_typeof_annotation
   end
 
   module CJSRequireTKit = CJSRequireT_kit (Import_export_helper)
-  module ImportDefaultTKit = ImportDefaultT_kit (Import_export_helper)
-  module ImportNamedTKit = ImportNamedT_kit (Import_export_helper)
-  module ImportTypeofTKit = ImportTypeofT_kit (Import_export_helper)
   module ExportNamedTKit = ExportNamedT_kit (Import_export_helper)
   module AssertExportIsTypeTKit = AssertExportIsTypeT_kit (Import_export_helper)
   module CopyNamedExportsTKit = CopyNamedExportsT_kit (Import_export_helper)
@@ -831,7 +820,15 @@ struct
             cx
             ~use_op:unknown_use
             trace
-            (ImportTypeofTKit.on_concrete_type cx trace reason export_name l, tout)
+            ( ImportTypeofTKit.on_concrete_type
+                cx
+                trace
+                ~mk_typeof_annotation:FlowJs.mk_typeof_annotation
+                reason
+                export_name
+                l,
+              tout
+            )
         (******************)
         (* Module exports *)
         (******************)
@@ -871,15 +868,33 @@ struct
             cx
             ~use_op:unknown_use
             trace
-            (ImportDefaultTKit.on_ModuleT cx trace (reason, import_kind, local, is_strict) m, tout)
+            ( ImportDefaultTKit.on_ModuleT
+                cx
+                trace
+                ~mk_typeof_annotation:FlowJs.mk_typeof_annotation
+                ~assert_import_is_value
+                ~with_concretized_type
+                (reason, import_kind, local, is_strict)
+                m,
+              tout
+            )
         | (ModuleT m, ImportNamedT (reason, import_kind, export_name, module_name, tout, is_strict))
           ->
           let import = (reason, import_kind, export_name, module_name, is_strict) in
           FlowJs.rec_flow_t
             cx
             ~use_op:unknown_use
             trace
-            (ImportNamedTKit.on_ModuleT cx trace import m, tout)
+            ( ImportNamedTKit.on_ModuleT
+                cx
+                trace
+                ~mk_typeof_annotation:FlowJs.mk_typeof_annotation
+                ~assert_import_is_value
+                ~with_concretized_type
+                import
+                m,
+              tout
+            )
         | (AnyT (lreason, _), CJSRequireT { reason; t_out; _ }) ->
           Flow_js_utils.check_untyped_import cx ImportValue lreason reason;
           rec_flow_t ~use_op:unknown_use cx trace (reposition_reason cx reason l, t_out)
@@ -9685,6 +9700,12 @@ module rec FlowJs : Flow_common.S = struct
   let possible_concrete_types_for_inspection =
     possible_concrete_types (fun ident -> ConcretizeForInspection ident)
 
+  let singleton_concrete_type_for_inspection cx reason t =
+    match possible_concrete_types_for_inspection cx reason t with
+    | [] -> EmptyT.make reason (bogus_trust ())
+    | [t] -> t
+    | t1 :: t2 :: ts -> UnionT (reason, UnionRep.make t1 t2 ts)
+
   let possible_concrete_types_for_computed_props =
     possible_concrete_types (fun ident -> ConcretizeComputedPropsT ident)
 end

src/typing/flow_js.mli

@@ -158,6 +158,8 @@ val widen_obj_type :
 
 val possible_concrete_types_for_inspection : Context.t -> Reason.reason -> Type.t -> Type.t list
 
+val singleton_concrete_type_for_inspection : Context.t -> Reason.reason -> Type.t -> Type.t
+
 val possible_concrete_types_for_computed_props : Context.t -> Reason.reason -> Type.t -> Type.t list
 
 val resolve_id : Context.t -> int -> Type.t -> unit

src/typing/flow_js_utils.ml

@@ -1109,10 +1109,6 @@ module type Import_export_helper_sig = sig
     Type.t ->
     Type.t
 
-  val assert_import_is_value : Context.t -> Type.trace -> Reason.t -> string -> Type.t -> unit
-
-  val with_concretized_type : Context.t -> Reason.t -> (Type.t -> Type.t) -> Type.t -> Type.t
-
   val export_named :
     Context.t ->
     Type.trace ->
@@ -1138,8 +1134,6 @@ module type Import_export_helper_sig = sig
     Context.t -> Type.trace -> Reason.t * (Reason.t * Type.exporttypes * bool) -> Type.t -> Type.t
 
   val return : Context.t -> Type.trace -> Type.t -> r
-
-  val mk_typeof_annotation : Context.t -> ?trace:Type.trace -> reason -> Type.t -> Type.t
 end
 
 (*********************************************************************)
@@ -1175,7 +1169,7 @@ end
    Overall, we should be able to (at least conceptually) desugar `import
    type` to `import` followed by `type`.
 *)
-module ImportTypeT_kit (F : Import_export_helper_sig) = struct
+module ImportTypeTKit = struct
   let canonicalize_imported_type cx reason t =
     match t with
     | DefT (_, trust, ClassT inst) -> Some (DefT (reason, trust, TypeT (ImportClassKind, inst)))
@@ -1209,18 +1203,15 @@ module ImportTypeT_kit (F : Import_export_helper_sig) = struct
       | None ->
         add_output cx ~trace (Error_message.EImportValueAsType (reason, export_name));
         AnyT.error reason)
-
-  let on_type cx trace reason export_name l =
-    F.with_concretized_type cx reason (on_concrete_type cx trace reason export_name) l
 end
 
 (************************************************************************)
 (* `import typeof` creates a properly-parameterized type alias for the  *)
 (* "typeof" the remote export.                                          *)
 (************************************************************************)
 
-module ImportTypeofT_kit (F : Import_export_helper_sig) = struct
-  let on_concrete_type cx trace reason export_name l =
+module ImportTypeofTKit = struct
+  let on_concrete_type cx trace ~mk_typeof_annotation reason export_name l =
     match l with
     | DefT
         ( _,
@@ -1233,7 +1224,7 @@ module ImportTypeofT_kit (F : Import_export_helper_sig) = struct
               id;
             }
         ) ->
-      let typeof_t = F.mk_typeof_annotation cx ~trace reason lower_t in
+      let typeof_t = mk_typeof_annotation cx ?trace:(Some trace) reason lower_t in
 
       poly_type
         id
@@ -1245,11 +1236,8 @@ module ImportTypeofT_kit (F : Import_export_helper_sig) = struct
       add_output cx ~trace (Error_message.EImportTypeAsTypeof (reason, export_name));
       AnyT.error reason
     | _ ->
-      let typeof_t = F.mk_typeof_annotation cx ~trace reason l in
+      let typeof_t = mk_typeof_annotation cx ?trace:(Some trace) reason l in
       DefT (reason, bogus_trust (), TypeT (ImportTypeofKind, typeof_t))
-
-  let on_type cx trace reason export_name l =
-    F.with_concretized_type cx reason (on_concrete_type cx trace reason export_name) l
 end
 
 module CJSRequireT_kit (F : Import_export_helper_sig) = struct
@@ -1325,14 +1313,14 @@ module ImportModuleNsTKit = struct
     Obj_type.mk_with_proto cx reason ~obj_kind ~frozen:true ~props proto
 end
 
-module ImportDefaultT_kit (F : Import_export_helper_sig) = struct
-  module ImportTypeTKit = ImportTypeT_kit (F)
-  module ImportTypeofTKit = ImportTypeofT_kit (F)
-
+module ImportDefaultTKit = struct
   (* import [type] X from 'SomeModule'; *)
   let on_ModuleT
       cx
       trace
+      ~mk_typeof_annotation
+      ~assert_import_is_value
+      ~with_concretized_type
       (reason, import_kind, (local_name, module_name), is_strict)
       (module_reason, exports, imported_is_strict) =
     check_nonstrict_import cx trace is_strict imported_is_strict reason;
@@ -1366,21 +1354,31 @@ module ImportDefaultT_kit (F : Import_export_helper_sig) = struct
           AnyT.error module_reason)
     in
     match import_kind with
-    | ImportType -> ImportTypeTKit.on_type cx trace reason "default" export_t
-    | ImportTypeof -> ImportTypeofTKit.on_type cx trace reason "default" export_t
+    | ImportType ->
+      with_concretized_type
+        cx
+        reason
+        (ImportTypeTKit.on_concrete_type cx trace reason "default")
+        export_t
+    | ImportTypeof ->
+      with_concretized_type
+        cx
+        reason
+        (ImportTypeofTKit.on_concrete_type cx trace ~mk_typeof_annotation reason "default")
+        export_t
     | ImportValue ->
-      F.assert_import_is_value cx trace reason "default" export_t;
+      assert_import_is_value cx trace reason "default" export_t;
       export_t
 end
 
-module ImportNamedT_kit (F : Import_export_helper_sig) = struct
-  module ImportTypeTKit = ImportTypeT_kit (F)
-  module ImportTypeofTKit = ImportTypeofT_kit (F)
-
+module ImportNamedTKit = struct
   (* import {X} from 'SomeModule'; *)
   let on_ModuleT
       cx
       trace
+      ~mk_typeof_annotation
+      ~assert_import_is_value
+      ~with_concretized_type
       (reason, import_kind, export_name, module_name, is_strict)
       (_, exports, imported_is_strict) =
     check_nonstrict_import cx trace is_strict imported_is_strict reason;
@@ -1399,18 +1397,36 @@ module ImportNamedT_kit (F : Import_export_helper_sig) = struct
     in
     let has_every_named_export = exports.has_every_named_export in
     match (import_kind, NameUtils.Map.find_opt (OrdinaryName export_name) exports_tmap) with
-    | (ImportType, Some t) -> ImportTypeTKit.on_type cx trace reason export_name t
+    | (ImportType, Some t) ->
+      with_concretized_type
+        cx
+        reason
+        (ImportTypeTKit.on_concrete_type cx trace reason export_name)
+        t
     | (ImportType, None) when has_every_named_export ->
-      ImportTypeTKit.on_type cx trace reason export_name (AnyT.untyped reason)
-    | (ImportTypeof, Some t) -> ImportTypeofTKit.on_type cx trace reason export_name t
+      with_concretized_type
+        cx
+        reason
+        (ImportTypeTKit.on_concrete_type cx trace reason export_name)
+        (AnyT.untyped reason)
+    | (ImportTypeof, Some t) ->
+      with_concretized_type
+        cx
+        reason
+        (ImportTypeofTKit.on_concrete_type cx trace ~mk_typeof_annotation reason export_name)
+        t
     | (ImportTypeof, None) when has_every_named_export ->
-      ImportTypeofTKit.on_type cx trace reason export_name (AnyT.untyped reason)
+      with_concretized_type
+        cx
+        reason
+        (ImportTypeofTKit.on_concrete_type cx trace ~mk_typeof_annotation reason export_name)
+        (AnyT.untyped reason)
     | (ImportValue, Some t) ->
-      F.assert_import_is_value cx trace reason export_name t;
+      assert_import_is_value cx trace reason export_name t;
       t
     | (ImportValue, None) when has_every_named_export ->
       let t = AnyT.untyped reason in
-      F.assert_import_is_value cx trace reason export_name t;
+      assert_import_is_value cx trace reason export_name t;
       t
     | (_, None) ->
       let num_exports = NameUtils.Map.cardinal exports_tmap in
@@ -1579,8 +1595,6 @@ end
  * exports one type at a time and it takes the type to be exported as a
  * lower (so that the type can be filtered post-resolution). *)
 module ExportTypeT_kit (F : Import_export_helper_sig) = struct
-  module ImportTypeTKit = ImportTypeT_kit (F)
-
   let on_concrete_type cx trace (reason, export_name, target_module_t) l =
     let is_type_export =
       match l with