Allocate a value's copy closure only when the copy is deferred

Why:
    `components_of_module_maker` built a closure for the copy of every
    value it added, also when it then copied the value at once (the first
    time the process builds a .cmi's components, and for every module
    that is not part of a .cmi), and checked recorded counts against the
    signature by converting the count array to a list.

`make_cell` now takes the substitution and the declaration and builds a
closure only for a deferred copy, and the counts are checked by walking
the signature with an index. Which values are deferred, the type ids
they take and the components built are unchanged.

Measured with scripts/compilerBenchmarks.js against the previous commit:
allocated words -0.15% in total, -0.25% in the project builds (where
components are built again in one process and their counts are known),
-0.04% for the files compiled one by one. On a 552 module React app
(clean build, one domain) the build allocates 0.2% fewer words.

Signed-off-by: Jono Prest <jjprest@gmail.com>

Author: JonoPrest

compiler/ml/env.ml

@@ -1821,20 +1821,23 @@ and components_of_module_maker
     let key = Option.map (fun crc -> (crc, Path.name path)) origin in
     let state = Compiler_request_state.current () in
     let item_count = List.length sg in
+    (* Whether [counts] fit this signature: one for every value. *)
+    let counts_fit counts =
+      Array.length counts = item_count
+      &&
+      let rec fit index = function
+        | [] -> true
+        | Sig_value _ :: _ when counts.(index) < 0 -> false
+        | ( Sig_value _ | Sig_type _ | Sig_typext _ | Sig_module _
+          | Sig_modtype _ )
+          :: rest ->
+          fit (index + 1) rest
+      in
+      fit 0 sg
+    in
     let counts =
       match Option.bind key find_component_counts with
-      | Some counts
-        when Array.length counts = item_count
-             && List.for_all2
-                  (fun item count ->
-                    match item with
-                    | Sig_value _ -> count >= 0
-                    | Sig_type _ | Sig_typext _ | Sig_module _ | Sig_modtype _
-                      ->
-                      true)
-                  sg (Array.to_list counts) ->
-        (* The counts fit this signature: one for every value. *)
-        Some counts
+      | Some counts when counts_fit counts -> Some counts
       | Some _ | None -> None
     in
     (* The type ids each value takes, when the counts of these
@@ -1846,21 +1849,23 @@ and components_of_module_maker
     in
     let stamps_taken = ref false in
     let deferred = ref 0 in
-    let make_cell index compute =
+    (* The copy is a closure only when it is deferred. *)
+    let make_cell index sub decl =
       match (counts, recorded) with
       | Some counts, _ ->
         let base = state.type_node_id and count = counts.(index) in
         state.type_node_id <- base + count;
         incr deferred;
         Comp_cell.pending (fun () ->
-            with_reserved_type_ids ~base ~count compute)
+            with_reserved_type_ids ~base ~count (fun () ->
+                Subst.value_description sub decl))
       | None, Some recorded ->
         let type0 = state.type_node_id and stamp0 = Ident.current_time () in
-        let result = compute () in
+        let result = Subst.value_description sub decl in
         recorded.(index) <- state.type_node_id - type0;
         if Ident.current_time () <> stamp0 then stamps_taken := true;
         Comp_cell.ready result
-      | None, None -> Comp_cell.ready (compute ())
+      | None, None -> Comp_cell.ready (Subst.value_description sub decl)
     in
     let pl, sub = prefix_idents path sub sg in
     let env = ref env in
@@ -1870,9 +1875,7 @@ and components_of_module_maker
       (fun item path ->
         (match item with
         | Sig_value (id, decl) -> (
-          let decl' =
-            make_cell !index (fun () -> Subst.value_description sub decl)
-          in
+          let decl' = make_cell !index sub decl in
           c.comp_values <- Tbl.add (Ident.name id) (decl', !pos) c.comp_values;
           match decl.val_kind with
           | Val_prim _ -> ()