convert missing cases

Author: aspeddro

jscomp/gentype/Converter.ml

@@ -32,7 +32,7 @@ let type_get_inlined ~config ~lookup_id ~type_name_is_interface type0 =
           in
           let f type_var =
             match
-              pairs |> List.find (fun (typeVar1, _) -> type_var = typeVar1)
+              pairs |> List.find (fun (type_var1, _) -> type_var = type_var1)
             with
             | _, type_argument -> Some type_argument
             | exception Not_found -> None

jscomp/gentype/Dependencies.ml

@@ -6,31 +6,31 @@ let rec handle_namespace ~name dep =
   | Dot (External s, module_name) when s = name -> External module_name
   | Dot (dep1, s) -> Dot (dep1 |> handle_namespace ~name, s)
 
-let rec fromPath1 ~config ~type_env (path : Path.t) =
+let rec from_path1 ~config ~type_env (path : Path.t) =
   match path with
   | Pident id -> (
     let name = id |> Ident.name in
     match type_env |> TypeEnv.lookup ~name with
     | None -> (type_env, External name)
-    | Some typeEnv1 -> (
-      let typeEnv2 =
+    | Some type_env1 -> (
+      let type_env2 =
         match type_env |> TypeEnv.get_module ~name with
-        | Some typeEnv2 -> typeEnv2
-        | None -> typeEnv1
+        | Some type_env2 -> type_env2
+        | None -> type_env1
       in
-      match typeEnv1 |> TypeEnv.expand_alias_to_external_module ~name with
-      | Some dep -> (typeEnv2, dep)
+      match type_env1 |> TypeEnv.expand_alias_to_external_module ~name with
+      | Some dep -> (type_env2, dep)
       | None ->
         let resolved_name =
-          name |> TypeEnv.add_module_path ~type_env:typeEnv1
+          name |> TypeEnv.add_module_path ~type_env:type_env1
         in
-        (typeEnv2, Internal resolved_name)))
+        (type_env2, Internal resolved_name)))
   | Pdot (Pident id, s, _pos)
     when id |> ScopedPackage.is_generated_module ~config ->
     ( type_env,
       External (s |> ScopedPackage.add_generated_module ~generated_module:id) )
   | Pdot (p, s, _pos) -> (
-    let type_env_from_p, dep = p |> fromPath1 ~config ~type_env in
+    let type_env_from_p, dep = p |> from_path1 ~config ~type_env in
     match
       type_env_from_p |> TypeEnv.expand_alias_to_external_module ~name:s
     with
@@ -47,7 +47,7 @@ let rec is_internal dep =
   | Dot (d, _) -> d |> is_internal
 
 let from_path ~config ~type_env path =
-  let _, dep = path |> fromPath1 ~config ~type_env in
+  let _, dep = path |> from_path1 ~config ~type_env in
   if !Debug.type_resolution then
     Log_.item "fromPath path:%s typeEnv:%s %s resolved:%s\n" (path |> Path.name)
       (type_env |> TypeEnv.to_string)

jscomp/gentype/EmitJs.ml

@@ -669,7 +669,7 @@ let emit_translation_as_string ~config ~file_name
         in
         let f type_var =
           match
-            pairs |> List.find (fun (typeVar1, _) -> type_var = typeVar1)
+            pairs |> List.find (fun (type_var1, _) -> type_var = type_var1)
           with
           | _, type_argument -> Some type_argument
           | exception Not_found -> None

jscomp/gentype/GenTypeCommon.ml

@@ -195,7 +195,7 @@ let string_t = ident "string"
 let unit_t = ident "void"
 let weakmap_t (x, y) = ident ~type_args:[x; y] "WeakMap"
 let weakset_t x = ident ~type_args:[x] "WeakSet"
-let int64T = Tuple [number_t; number_t]
+let int64_t = Tuple [number_t; number_t]
 
 module NodeFilename = struct
   include Filename

jscomp/gentype/TranslateCoreType.ml

@@ -52,17 +52,17 @@ let rec translate_arrow_type ~config ~type_vars_gen
     ~no_function_return_dependencies ~type_env ~rev_arg_deps ~rev_args
     (core_type : Typedtree.core_type) =
   match core_type.ctyp_desc with
-  | Ttyp_arrow (Nolabel, coreType1, coreType2) ->
+  | Ttyp_arrow (Nolabel, core_type1, core_type2) ->
     let {dependencies; type_} =
-      coreType1 |> fun __x ->
+      core_type1 |> fun __x ->
       translateCoreType_ ~config ~type_vars_gen ~type_env __x
     in
     let next_rev_deps = List.rev_append dependencies rev_arg_deps in
-    coreType2
+    core_type2
     |> translate_arrow_type ~config ~type_vars_gen
          ~no_function_return_dependencies ~type_env ~rev_arg_deps:next_rev_deps
          ~rev_args:((Nolabel, type_) :: rev_args)
-  | Ttyp_arrow (((Labelled lbl | Optional lbl) as label), coreType1, coreType2)
+  | Ttyp_arrow (((Labelled lbl | Optional lbl) as label), core_type1, core_type2)
     -> (
     let as_label =
       match
@@ -71,13 +71,13 @@ let rec translate_arrow_type ~config ~type_vars_gen
       | Some s -> s
       | None -> ""
     in
-    match coreType1 |> remove_option ~label with
+    match core_type1 |> remove_option ~label with
     | None ->
       let {dependencies; type_ = type1} =
-        coreType1 |> translateCoreType_ ~config ~type_vars_gen ~type_env
+        core_type1 |> translateCoreType_ ~config ~type_vars_gen ~type_env
       in
       let next_rev_deps = List.rev_append dependencies rev_arg_deps in
-      coreType2
+      core_type2
       |> translate_arrow_type ~config ~type_vars_gen
            ~no_function_return_dependencies ~type_env
            ~rev_arg_deps:next_rev_deps
@@ -93,7 +93,7 @@ let rec translate_arrow_type ~config ~type_vars_gen
         t1 |> translateCoreType_ ~config ~type_vars_gen ~type_env
       in
       let next_rev_deps = List.rev_append dependencies rev_arg_deps in
-      coreType2
+      core_type2
       |> translate_arrow_type ~config ~type_vars_gen
            ~no_function_return_dependencies ~type_env
            ~rev_arg_deps:next_rev_deps
@@ -259,11 +259,11 @@ and translateCoreType_ ~config ~type_vars_gen
         |> List.map (fun (_, translation) -> translation.dependencies)
         |> List.flatten
       in
-      let typeEnv1 = type_env |> TypeEnv.add_type_equations ~type_equations in
+      let type_env1 = type_env |> TypeEnv.add_type_equations ~type_equations in
       let dependencies_from_record_type, type_ =
         signature.sig_type
         |> signature_to_module_runtime_representation ~config ~type_vars_gen
-             ~type_env:typeEnv1
+             ~type_env:type_env1
       in
       {
         dependencies =

jscomp/gentype/TranslateStructure.ml

@@ -6,7 +6,7 @@ let rec addAnnotationsToTypes_ ~config ~(expr : Typedtree.expression)
   | ( Texp_function {arg_label; param; cases = [{c_rhs}]},
       _,
       {a_type} :: next_types ) ->
-    let nextTypes1 = next_types |> addAnnotationsToTypes_ ~config ~expr:c_rhs in
+    let next_types1 = next_types |> addAnnotationsToTypes_ ~config ~expr:c_rhs in
     let a_name = Ident.name param in
     let _ = Printtyped.implementation in
     let a_name =
@@ -16,7 +16,7 @@ let rec addAnnotationsToTypes_ ~config ~(expr : Typedtree.expression)
         | _ -> "" (* should not happen *)
       else a_name
     in
-    {a_name; a_type} :: nextTypes1
+    {a_name; a_type} :: next_types1
   | Texp_construct ({txt = Lident "Function$"}, _, [fun_expr]), _, _ ->
     (* let uncurried1: function$<_, _> = Function$(x => x |> string_of_int, [`Has_arity1]) *)
     addAnnotationsToTypes_ ~config ~expr:fun_expr arg_types
@@ -50,14 +50,14 @@ and add_annotations_to_fields ~config (expr : Typedtree.expression)
   match (expr.exp_desc, fields, arg_types) with
   | _, [], _ -> ([], arg_types |> add_annotations_to_types ~config ~expr)
   | Texp_function {cases = [{c_rhs}]}, field :: next_fields, _ ->
-    let nextFields1, types1 =
+    let next_fields1, types1 =
       add_annotations_to_fields ~config c_rhs next_fields arg_types
     in
     let name =
       TranslateTypeDeclarations.rename_record_field
         ~attributes:expr.exp_attributes ~name:field.name_j_s
     in
-    ({field with name_j_s = name} :: nextFields1, types1)
+    ({field with name_j_s = name} :: next_fields1, types1)
   | _ -> (fields, arg_types)
 [@@live]
 
@@ -321,7 +321,7 @@ and translate_structure_item ~config ~output_file_relative ~resolver ~type_env
                        Tmod_structure
                          {
                            str_items =
-                             [({str_desc = Tstr_primitive _} as structItem1)];
+                             [({str_desc = Tstr_primitive _} as struct_item1)];
                          };
                    },
                    _,
@@ -332,7 +332,7 @@ and translate_structure_item ~config ~output_file_relative ~resolver ~type_env
        };
    _;
   } ->
-    structItem1
+    struct_item1
     |> translate_structure_item ~config ~output_file_relative ~resolver
          ~type_env
   | {str_desc = Tstr_include {incl_type = signature}} ->

jscomp/gentype/TranslateTypeExprFromTypes.ml

@@ -77,7 +77,7 @@ let translate_constr ~config ~params_translation ~(path : Path.t) ~type_env =
   match (path |> path_to_list |> List.rev, params_translation) with
   | (["FB"; "bool"] | ["bool"]), [] -> {dependencies = []; type_ = boolean_t}
   | (["FB"; "int"] | ["int"]), [] -> {dependencies = []; type_ = number_t}
-  | (["Int64"; "t"] | ["int64"]), [] -> {dependencies = []; type_ = int64T}
+  | (["Int64"; "t"] | ["int64"]), [] -> {dependencies = []; type_ = int64_t}
   | (["FB"; "float"] | ["float"]), [] -> {dependencies = []; type_ = number_t}
   | ( ( ["FB"; "string"]
       | ["string"]
@@ -89,17 +89,17 @@ let translate_constr ~config ~params_translation ~(path : Path.t) ~type_env =
     {dependencies = []; type_ = bigint_t}
   | (["Js"; "Date"; "t"] | ["Date"; "t"]), [] ->
     {dependencies = []; type_ = date_t}
-  | ["Map"; "t"], [paramTranslation1; paramTranslation2] ->
+  | ["Map"; "t"], [param_translation1; param_translation2] ->
     {
       dependencies =
-        paramTranslation1.dependencies @ paramTranslation2.dependencies;
-      type_ = map_t (paramTranslation1.type_, paramTranslation2.type_);
+        param_translation1.dependencies @ param_translation2.dependencies;
+      type_ = map_t (param_translation1.type_, param_translation2.type_);
     }
-  | ["WeakMap"; "t"], [paramTranslation1; paramTranslation2] ->
+  | ["WeakMap"; "t"], [param_translation1; param_translation2] ->
     {
       dependencies =
-        paramTranslation1.dependencies @ paramTranslation2.dependencies;
-      type_ = weakmap_t (paramTranslation1.type_, paramTranslation2.type_);
+        param_translation1.dependencies @ param_translation2.dependencies;
+      type_ = weakmap_t (param_translation1.type_, param_translation2.type_);
     }
   | ["Set"; "t"], [param_translation] ->
     {
@@ -136,20 +136,20 @@ let translate_constr ~config ~params_translation ~(path : Path.t) ~type_env =
             ] );
     }
   | ( (["Pervasives"; "result"] | ["Belt"; "Result"; "t"] | ["result"]),
-      [paramTranslation1; paramTranslation2] ) ->
+      [param_translation1; param_translation2] ) ->
     let case name type_ = {case = {label_j_s = StringLabel name}; t = type_} in
     let variant =
       create_variant ~inherits:[] ~no_payloads:[]
         ~payloads:
           [
-            case "Ok" paramTranslation1.type_;
-            case "Error" paramTranslation2.type_;
+            case "Ok" param_translation1.type_;
+            case "Error" param_translation2.type_;
           ]
         ~polymorphic:false ~tag:None ~unboxed:false
     in
     {
       dependencies =
-        paramTranslation1.dependencies @ paramTranslation2.dependencies;
+        param_translation1.dependencies @ param_translation2.dependencies;
       type_ = variant;
     }
   | ( (["React"; "callback"] | ["ReactV3"; "React"; "callback"]),
@@ -278,26 +278,26 @@ let rec translate_arrow_type ~config ~type_vars_gen ~type_env ~rev_arg_deps
   | Tlink t ->
     translate_arrow_type ~config ~type_vars_gen ~type_env ~rev_arg_deps
       ~rev_args t
-  | Tarrow (Nolabel, typeExpr1, typeExpr2, _) ->
+  | Tarrow (Nolabel, type_expr1, type_expr2, _) ->
     let {dependencies; type_} =
-      typeExpr1 |> fun __x ->
+      type_expr1 |> fun __x ->
       translateTypeExprFromTypes_ ~config ~type_vars_gen ~type_env __x
     in
     let next_rev_deps = List.rev_append dependencies rev_arg_deps in
-    typeExpr2
+    type_expr2
     |> translate_arrow_type ~config ~type_vars_gen ~type_env
          ~rev_arg_deps:next_rev_deps
          ~rev_args:((Nolabel, type_) :: rev_args)
-  | Tarrow (((Labelled lbl | Optional lbl) as label), typeExpr1, typeExpr2, _)
+  | Tarrow (((Labelled lbl | Optional lbl) as label), type_expr1, type_expr2, _)
     -> (
-    match typeExpr1 |> remove_option ~label with
+    match type_expr1 |> remove_option ~label with
     | None ->
       let {dependencies; type_ = type1} =
-        typeExpr1
+        type_expr1
         |> translateTypeExprFromTypes_ ~config ~type_vars_gen ~type_env
       in
       let next_rev_deps = List.rev_append dependencies rev_arg_deps in
-      typeExpr2
+      type_expr2
       |> translate_arrow_type ~config ~type_vars_gen ~type_env
            ~rev_arg_deps:next_rev_deps
            ~rev_args:((Label lbl, type1) :: rev_args)
@@ -306,7 +306,7 @@ let rec translate_arrow_type ~config ~type_vars_gen ~type_env ~rev_arg_deps
         t1 |> translateTypeExprFromTypes_ ~config ~type_vars_gen ~type_env
       in
       let next_rev_deps = List.rev_append dependencies rev_arg_deps in
-      typeExpr2
+      type_expr2
       |> translate_arrow_type ~config ~type_vars_gen ~type_env
            ~rev_arg_deps:next_rev_deps
            ~rev_args:((OptLabel lbl, type1) :: rev_args))
@@ -453,11 +453,11 @@ and translateTypeExprFromTypes_ ~config ~type_vars_gen ~type_env
         |> List.map (fun (_, translation) -> translation.dependencies)
         |> List.flatten
       in
-      let typeEnv1 = type_env |> TypeEnv.add_type_equations ~type_equations in
+      let type_env1 = type_env |> TypeEnv.add_type_equations ~type_equations in
       let dependencies_from_record_type, type_ =
         signature.sig_type
         |> signature_to_module_runtime_representation ~config ~type_vars_gen
-             ~type_env:typeEnv1
+             ~type_env:type_env1
       in
       {
         dependencies =
@@ -496,19 +496,19 @@ and signature_to_module_runtime_representation ~config ~type_vars_gen ~type_env
              in
              (dependencies, [field])
            | Types.Sig_module (id, module_declaration, _recStatus) ->
-             let typeEnv1 =
+             let type_env1 =
                match
                  type_env |> TypeEnv.get_module ~name:(id |> Ident.name)
                with
-               | Some typeEnv1 -> typeEnv1
+               | Some type_env1 -> type_env1
                | None -> type_env
              in
              let dependencies, type_ =
                match module_declaration.md_type with
                | Mty_signature signature ->
                  signature
                  |> signature_to_module_runtime_representation ~config
-                      ~type_vars_gen ~type_env:typeEnv1
+                      ~type_vars_gen ~type_env:type_env1
                | Mty_ident _ | Mty_functor _ | Mty_alias _ -> ([], unknown)
              in
              let field =

jscomp/gentype/TypeEnv.ml

@@ -51,7 +51,7 @@ let new_type ~name type_env =
 
 let get_module ~name type_env =
   match type_env.map |> StringMap.find name with
-  | Module typeEnv1 -> Some typeEnv1
+  | Module type_env1 -> Some type_env1
   | Type _ -> None
   | exception Not_found -> None
 
@@ -82,13 +82,13 @@ let rec add_type_equation ~flattened ~type_ type_env =
     }
   | module_name :: rest -> (
     match type_env |> get_module ~name:module_name with
-    | Some typeEnv1 ->
+    | Some type_env1 ->
       {
         type_env with
         map =
           type_env.map
           |> StringMap.add module_name
-               (Module (typeEnv1 |> add_type_equation ~flattened:rest ~type_));
+               (Module (type_env1 |> add_type_equation ~flattened:rest ~type_));
       }
     | None -> type_env)
   | [] -> type_env
@@ -143,7 +143,7 @@ let rec lookup_module_type ~path type_env =
       Log_.item "Typenv.lookupModuleType %s moduleName:%s\n"
         (type_env |> to_string) module_name;
     match type_env.map |> StringMap.find module_name with
-    | Module typeEnv1 -> typeEnv1 |> lookup_module_type ~path:path1
+    | Module type_env1 -> type_env1 |> lookup_module_type ~path:path1
     | Type _ -> None
     | exception Not_found -> (
       match type_env.parent with

jscomp/syntax/benchmarks/Benchmark.ml

@@ -33,7 +33,7 @@ module Time : sig
 
   val now : unit -> t
 
-  val toUint64 : t -> int64 [@@live]
+  val to_uint64 : t -> int64 [@@live]
 
   (* let of_uint64_ns ns = ns *)
 
@@ -55,7 +55,7 @@ end = struct
 
   let zero = 0L
 
-  let toUint64 s = s
+  let to_uint64 s = s
 
   let nanosecond = 1L
   let microsecond = Int64.mul 1000L nanosecond