In GenType add support for mutual recursion

Signed-Off-By: Jono Prest <[email protected]>

Author: JonoPrest

jscomp/gentype/TranslateSignature.ml

@@ -98,13 +98,17 @@ and translateSignatureItem ~config ~outputFileRelative ~resolver ~typeEnv
     signatureItem : Translation.t =
   match signatureItem with
   | {Typedtree.sig_desc = Typedtree.Tsig_type (recFlag, typeDeclarations)} ->
+    let recursive = recFlag = Recursive in
+    if recursive then
+      typeDeclarations
+      |> TranslateTypeDeclarations.addRecursiveTypesToTypEnv ~typeEnv;
     {
       importTypes = [];
       codeItems = [];
       typeDeclarations =
         typeDeclarations
         |> TranslateTypeDeclarations.translateTypeDeclarations ~config
-             ~outputFileRelative ~recursive:(recFlag = Recursive) ~resolver
+             ~outputFileRelative ~recursive ~resolver
              ~typeEnv;
     }
   | {Typedtree.sig_desc = Tsig_value valueDescription} ->

jscomp/gentype/TranslateStructure.ml

@@ -260,14 +260,17 @@ and translateStructureItem ~config ~outputFileRelative ~resolver ~typeEnv
     (structItem : Typedtree.structure_item) : Translation.t =
   match structItem with
   | {str_desc = Tstr_type (recFlag, typeDeclarations)} ->
+    let recursive = recFlag = Recursive in
+    if recursive then
+      typeDeclarations
+      |> TranslateTypeDeclarations.addRecursiveTypesToTypEnv ~typeEnv;
     {
       importTypes = [];
       codeItems = [];
       typeDeclarations =
         typeDeclarations
         |> TranslateTypeDeclarations.translateTypeDeclarations ~config
-             ~outputFileRelative ~recursive:(recFlag = Recursive) ~resolver
-             ~typeEnv;
+             ~outputFileRelative ~recursive ~resolver ~typeEnv;
     }
   | {str_desc = Tstr_value (_loc, valueBindings)} ->
     valueBindings

jscomp/gentype/TranslateTypeDeclarations.ml

@@ -313,13 +313,19 @@ let hasSomeGADTLeaf constructorDeclarations =
     (fun declaration -> declaration.Types.cd_res != None)
     constructorDeclarations
 
+let addRecursiveTypesToTypEnv ~typeEnv typeDeclarations =
+  typeDeclarations
+  |> List.map (fun ({typ_id} : Typedtree.type_declaration) -> typ_id)
+  |> List.iter (fun type_id ->
+         typeEnv |> TypeEnv.newType ~name:(type_id |> Ident.name))
+
 let translateTypeDeclaration ~config ~outputFileRelative ~recursive ~resolver
     ~typeEnv
     ({typ_attributes; typ_id; typ_loc; typ_manifest; typ_params; typ_type} :
       Typedtree.type_declaration) : CodeItem.typeDeclaration list =
   if !Debug.translation then
     Log_.item "Translate Type Declaration %s\n" (typ_id |> Ident.name);
-  if recursive then typeEnv |> TypeEnv.newType ~name:(typ_id |> Ident.name);
+
   let typeName = Ident.name typ_id in
   let typeVars =
     typ_params