Deploying to gh-pages from @ edf7240 🚀

coverage/src/ast/types.ml.html

@@ -2270,8 +2270,8 @@ <h2>47.34%</h2>
   | <span data-count="14">F</span>64 -&gt; pf fmt "f64"
 
 let num_type_eq t1 t2 =
-  <span data-count="3224900">m</span>atch (t1, t2) with
-  | <span data-count="2957365">I</span>32, I32 | <span data-count="89292">I</span>64, I64 | <span data-count="88973">F</span>32, F32 | <span data-count="89227">F</span>64, F64 -&gt; true
+  <span data-count="3224939">m</span>atch (t1, t2) with
+  | <span data-count="2957404">I</span>32, I32 | <span data-count="89292">I</span>64, I64 | <span data-count="88973">F</span>32, F32 | <span data-count="89227">F</span>64, F64 -&gt; true
   | <span data-count="43">_</span>, _ -&gt; false
 
 let compare_num_type t1 t2 =
@@ -2566,8 +2566,8 @@ <h2>47.34%</h2>
   | <span data-count="0">R</span>ef_type t -&gt; pp_ref_type fmt t
 
 let val_type_eq t1 t2 =
-  <span data-count="3223073">m</span>atch (t1, t2) with
-  | <span data-count="3223051">N</span>um_type t1, Num_type t2 -&gt; num_type_eq t1 t2
+  <span data-count="3223112">m</span>atch (t1, t2) with
+  | <span data-count="3223089">N</span>um_type t1, Num_type t2 -&gt; num_type_eq t1 t2
   | <span data-count="22">R</span>ef_type t1, Ref_type t2 -&gt; ref_type_eq t1 t2
   | <span data-count="0">_</span>, _ -&gt; false
 
@@ -2582,15 +2582,15 @@ <h2>47.34%</h2>
 
 let pp_param fmt (id, vt) = <span data-count="226">p</span>f fmt "(param%a %a)" pp_id_opt id pp_val_type vt
 
-let param_eq (_, t1) (_, t2) = <span data-count="1615764">v</span>al_type_eq t1 t2
+let param_eq (_, t1) (_, t2) = <span data-count="1615791">v</span>al_type_eq t1 t2
 
 let compare_param (_, t1) (_, t2) = <span data-count="32176">c</span>ompare_val_type t1 t2
 
 type nonrec 'a param_type = 'a param list
 
 let pp_param_type fmt params = <span data-count="109">l</span>ist ~sep:sp pp_param fmt params
 
-let param_type_eq t1 t2 = <span data-count="1614473">L</span>ist.equal param_eq t1 t2
+let param_type_eq t1 t2 = <span data-count="1614487">L</span>ist.equal param_eq t1 t2
 
 let compare_param_type t1 t2 = <span data-count="63685">L</span>ist.compare compare_param t1 t2
 
@@ -2600,7 +2600,7 @@ <h2>47.34%</h2>
 
 let pp_result_type fmt results = <span data-count="115">l</span>ist ~sep:sp pp_result_ fmt results
 
-let result_type_eq t1 t2 = <span data-count="1614394">L</span>ist.equal val_type_eq t1 t2
+let result_type_eq t1 t2 = <span data-count="1614409">L</span>ist.equal val_type_eq t1 t2
 
 let compare_result_type t1 t2 = <span data-count="32833">L</span>ist.compare compare_val_type t1 t2
 
@@ -2639,7 +2639,7 @@ <h2>47.34%</h2>
     results
 
 let func_type_eq (pt1, rt1) (pt2, rt2) =
-  <span data-count="1614473">p</span>aram_type_e<span data-count="1614473">q</span> pt1 pt2 &amp;&amp; <span data-count="1614394">r</span>esult_type_eq rt1 rt2
+  <span data-count="1614488">p</span>aram_type_e<span data-count="1614487">q</span> pt1 pt2 &amp;&amp; <span data-count="1614409">r</span>esult_type_eq rt1 rt2
 
 let compare_func_type (pt1, rt1) (pt2, rt2) =
   <span data-count="63685">l</span>et pt = compare_param_type pt1 pt2 in

coverage/src/cmd/cmd_sym.ml.html

@@ -351,21 +351,21 @@ <h2>88.76%</h2>
   <span data-count="359">l</span>et res_queue = Wq.make () in
   <span data-count="359">l</span>et path_count = ref 0 in
   let callback v =
-    <span data-count="1709">l</span>et open Symbolic_choice_intf in
+    <span data-count="1742">l</span>et open Symbolic_choice_intf in
     incr path_count;
-    <span data-count="1711">m</span>atch (fail_mode, v) with
-    | <span data-count="1521">_</span>, (EVal (Ok ()), _) -&gt; ()
+    <span data-count="1746">m</span>atch (fail_mode, v) with
+    | <span data-count="1549">_</span>, (EVal (Ok ()), _) -&gt; ()
     | <span data-count="1">_</span>, (EVal (Error e), thread) -&gt; Wq.push (`Error e, thread) res_queue
     | <span data-count="160">(</span><span data-count="160">`</span>Both | <span data-count="0">`</span>Trap_only), (ETrap (t, m), thread) -&gt;
       Wq.push (`ETrap (t, m), thread) res_queue
-    | <span data-count="31">(</span><span data-count="31">`</span>Both | <span data-count="0">`</span>Assertion_only), (EAssert (e, m), thread) -&gt;
+    | <span data-count="34">(</span><span data-count="34">`</span>Both | <span data-count="0">`</span>Assertion_only), (EAssert (e, m), thread) -&gt;
       Wq.push (`EAssert (e, m), thread) res_queue
     | <span data-count="0">(</span><span data-count="0">`</span>Trap_only | <span data-count="0">`</span>Assertion_only), _ -&gt; ()
   in
   let join_handles =
     Symbolic_choice_with_memory.run ~workers solver result thread ~callback
       ~callback_init:(fun () -&gt; <span data-count="710">W</span>q.make_pledge res_queue)
-      ~callback_end:(fun () -&gt; <span data-count="677">W</span>q.end_pledge res_queue)
+      ~callback_end:(fun () -&gt; <span data-count="676">W</span>q.end_pledge res_queue)
   in
   <span data-count="359">l</span>et results =
     Wq.read_as_seq res_queue ~finalizer:(fun () -&gt;

coverage/src/data_structures/env_id.ml.html

@@ -112,14 +112,14 @@ <h2>77.78%</h2>
   <span data-count="3321">l</span>et last = succ last in
   <span data-count="3321">(</span>{ c; last }, r)
 
-let get i c = <span data-count="12070663">M</span>ap.find i c.c
+let get i c = <span data-count="12070667">M</span>ap.find i c.c
 
 let map f c = <span data-count="0">{</span> c with c = Map.ma<span data-count="0">p</span> f c.c }
 
 module Tbl = Hashtbl.Make (struct
   include Int
 
-  let hash x = <span data-count="1256703">x</span>
+  let hash x = <span data-count="1257073">x</span>
 end)
 </code></pre>
       </div>

coverage/src/data_structures/func_id.ml.html

@@ -105,8 +105,8 @@ <h2>100.00%</h2>
   <span data-count="8917">(</span>last, { c; last = suc<span data-count="8917">c</span> last })
 
 let get i c =
-  <span data-count="122342">l</span>et v, _ = IMap.find i c.c in
-  <span data-count="122342">v</span>
+  <span data-count="122373">l</span>et v, _ = IMap.find i c.c in
+  <span data-count="122362">v</span>
 
 let get_typ i c =
   <span data-count="4265">l</span>et _, t = IMap.find i c.c in

coverage/src/data_structures/stack.ml.html

@@ -525,17 +525,17 @@ <h2>96.00%</h2>
 
   let empty = []
 
-  let push s v = <span data-count="88835447">v</span> :: s
+  let push s v = <span data-count="88835065">v</span> :: s
 
-  let push_bool s b = <span data-count="16445460">p</span>ush s (I32 (V.Bool.int3<span data-count="16445507">2</span> b))
+  let push_bool s b = <span data-count="16445542">p</span>ush s (I32 (V.Bool.int3<span data-count="16445584">2</span> b))
 
-  let push_const_i32 s i = <span data-count="7806735">p</span>ush s (I32 (V.const_i3<span data-count="7807159">2</span> i))
+  let push_const_i32 s i = <span data-count="7806750">p</span>ush s (I32 (V.const_i3<span data-count="7807427">2</span> i))
 
-  let push_i32 s i = <span data-count="6482211">p</span>ush s (I32 i)
+  let push_i32 s i = <span data-count="6482571">p</span>ush s (I32 i)
 
   let push_i32_of_int s i = <span data-count="12">p</span>ush_const_i32 s (Int32.of_in<span data-count="12">t</span> i)
 
-  let push_const_i64 s i = <span data-count="10576173">p</span>ush s (I64 (V.const_i6<span data-count="10576211">4</span> i))
+  let push_const_i64 s i = <span data-count="10576190">p</span>ush s (I64 (V.const_i6<span data-count="10576223">4</span> i))
 
   let push_i64 s i = <span data-count="10139753">p</span>ush s (I64 i)
 
@@ -554,22 +554,22 @@ <h2>96.00%</h2>
   let pp fmt (s : t) =
     <span data-count="95">F</span>mt.list ~sep:(fun fmt () -&gt; <span data-count="15">F</span>mt.string fmt " ; ") V.pp fmt s
 
-  let pop = function <span data-count="0">[</span>] -&gt; raise Empty | <span data-count="76511993">h</span>d :: tl -&gt; (hd, tl)
+  let pop = function <span data-count="0">[</span>] -&gt; raise Empty | <span data-count="76512955">h</span>d :: tl -&gt; (hd, tl)
 
-  let drop = function <span data-count="0">[</span>] -&gt; raise Empty | <span data-count="7642">_</span>hd :: tl -&gt; tl
+  let drop = function <span data-count="0">[</span>] -&gt; raise Empty | <span data-count="7675">_</span>hd :: tl -&gt; tl
 
   let pop_i32 s =
-    <span data-count="6980835">l</span>et hd, tl = pop s in
-    <span data-count="6980640">m</span>atch hd with <span data-count="6980612">I</span>32 n -&gt; (n, tl) | _ -&gt; assert false
+    <span data-count="6981187">l</span>et hd, tl = pop s in
+    <span data-count="6981202">m</span>atch hd with <span data-count="6981232">I</span>32 n -&gt; (n, tl) | _ -&gt; assert false
 
   let pop2_i32 s =
-    <span data-count="9201043">l</span>et n2, s = pop s in
-    <span data-count="9201010">l</span>et n1, tl = pop s in
-    <span data-count="9200970">m</span>atch (n1, n2) with <span data-count="9201016">I</span>32 n1, I32 n2 -&gt; ((n1, n2), tl) | _ -&gt; assert false
+    <span data-count="9201273">l</span>et n2, s = pop s in
+    <span data-count="9201281">l</span>et n1, tl = pop s in
+    <span data-count="9201285">m</span>atch (n1, n2) with <span data-count="9201301">I</span>32 n1, I32 n2 -&gt; ((n1, n2), tl) | _ -&gt; assert false
 
   let pop_i64 s =
-    <span data-count="10355616">l</span>et hd, tl = pop s in
-    <span data-count="10355593">m</span>atch hd with <span data-count="10355581">I</span>64 n -&gt; (n, tl) | _ -&gt; assert false
+    <span data-count="10355617">l</span>et hd, tl = pop s in
+    <span data-count="10355609">m</span>atch hd with <span data-count="10355606">I</span>64 n -&gt; (n, tl) | _ -&gt; assert false
 
   let pop2_i64 s =
     <span data-count="10227027">l</span>et n2, s = pop s in
@@ -603,17 +603,17 @@ <h2>96.00%</h2>
     <span data-count="231">m</span>atch hd with <span data-count="231">R</span>ef hd -&gt; (hd, tl) | _ -&gt; assert false
 
   let pop_bool s =
-    <span data-count="16373052">l</span>et hd, tl = pop s in
-    <span data-count="16373053">m</span>atch hd with <span data-count="16373038">I</span>32 n -&gt; (V.I32.to_boo<span data-count="16373086">l</span> n, tl) | _ -&gt; assert false
+    <span data-count="16373209">l</span>et hd, tl = pop s in
+    <span data-count="16373204">m</span>atch hd with <span data-count="16373201">I</span>32 n -&gt; (V.I32.to_boo<span data-count="16373209">l</span> n, tl) | _ -&gt; assert false
 
   let pop_n s n =
-    <span data-count="12022386">(</span>List.filter<span data-count="12022418">i</span> (fun i _hd -&gt; <span data-count="12576988">i</span> &lt; n) s, List.filter<span data-count="12022427">i</span> (fun i _hd -&gt; <span data-count="12576837">i</span> &gt;= n) s)
+    <span data-count="12022500">(</span>List.filter<span data-count="12022520">i</span> (fun i _hd -&gt; <span data-count="12577237">i</span> &lt; n) s, List.filter<span data-count="12022529">i</span> (fun i _hd -&gt; <span data-count="12577191">i</span> &gt;= n) s)
 
-  let keep s n = <span data-count="3856772">L</span>ist.filteri (fun i _hd -&gt; <span data-count="528189">i</span> &lt; n) s
+  let keep s n = <span data-count="3857121">L</span>ist.filteri (fun i _hd -&gt; <span data-count="528276">i</span> &lt; n) s
 
   let rec drop_n s n =
-    <span data-count="16855785">i</span>f n = 0 then <span data-count="15782187">s</span>
-    else <span data-count="1073600">m</span>atch s with [] -&gt; assert false | <span data-count="1073602">_</span> :: tl -&gt; drop_n tl (n - 1)
+    <span data-count="16856282">i</span>f n = 0 then <span data-count="15782432">s</span>
+    else <span data-count="1073853">m</span>atch s with [] -&gt; assert false | <span data-count="1073854">_</span> :: tl -&gt; drop_n tl (n - 1)
 end
 </code></pre>
       </div>

coverage/src/data_structures/synchronizer.ml.html

@@ -182,33 +182,33 @@ <h2>87.50%</h2>
   }
 
 let get synchro pledge =
-  <span data-count="44927">l</span>et rec inner_loop synchro pledge =
-    <span data-count="46040">m</span>atch synchro.getter () with
-    | <span data-count="2128">N</span>one when synchro.pledges = <span data-count="1011">0</span> || synchro.close<span data-count="0">d</span> -&gt;
-      <span data-count="1011">C</span>ondition.broadcast synchro.cond;
-      <span data-count="1011">N</span>one
-    | <span data-count="1119">N</span>one -&gt;
+  <span data-count="44990">l</span>et rec inner_loop synchro pledge =
+    <span data-count="46054">m</span>atch synchro.getter () with
+    | <span data-count="2084">N</span>one when synchro.pledges = <span data-count="1012">0</span> || synchro.close<span data-count="0">d</span> -&gt;
+      <span data-count="1012">C</span>ondition.broadcast synchro.cond;
+      <span data-count="1012">N</span>one
+    | <span data-count="1072">N</span>one -&gt;
       Condition.wait synchro.cond synchro.mutex;
-      <span data-count="1112">i</span>nner_loop synchro pledge
-    | <span data-count="43910">S</span>ome _ as v -&gt;
-      if pledge then <span data-count="43718">s</span>ynchro.pledges &lt;- synchro.pledges + 1;
-      <span data-count="43910">v</span>
+      <span data-count="1065">i</span>nner_loop synchro pledge
+    | <span data-count="43970">S</span>ome _ as v -&gt;
+      if pledge then <span data-count="43778">s</span>ynchro.pledges &lt;- synchro.pledges + 1;
+      <span data-count="43970">v</span>
   in
-  Mutex.protect synchro.mutex (fun () -&gt; <span data-count="44928">i</span>nner_loop synchro pledge)
+  Mutex.protect synchro.mutex (fun () -&gt; <span data-count="44989">i</span>nner_loop synchro pledge)
 
 let write v { writter; cond; mutex; _ } =
-  <span data-count="43934">M</span>utex.protect mutex (fun () -&gt; <span data-count="43944">w</span>ritter v cond)
+  <span data-count="44001">M</span>utex.protect mutex (fun () -&gt; <span data-count="44007">w</span>ritter v cond)
 
 let make_pledge synchro =
   <span data-count="710">M</span>utex.lock synchro.mutex;
   <span data-count="710">s</span>ynchro.pledges &lt;- synchro.pledges + 1;
   Mutex.unlock synchro.mutex
 
 let end_pledge synchro =
-  <span data-count="44370">M</span>utex.lock synchro.mutex;
-  <span data-count="44369">s</span>ynchro.pledges &lt;- synchro.pledges - 1;
+  <span data-count="44433">M</span>utex.lock synchro.mutex;
+  <span data-count="44433">s</span>ynchro.pledges &lt;- synchro.pledges - 1;
   Condition.broadcast synchro.cond;
-  <span data-count="44369">M</span>utex.unlock synchro.mutex
+  <span data-count="44433">M</span>utex.unlock synchro.mutex
 
 let fail q =
   <span data-count="0">M</span>utex.lock q.mutex;
@@ -217,12 +217,12 @@ <h2>87.50%</h2>
   <span data-count="0">M</span>utex.unlock q.mutex
 
 let rec work_while f q =
-  <span data-count="44398">m</span>atch get q true with
-  | <span data-count="675">N</span>one -&gt; ()
-  | <span data-count="43718">S</span>ome v -&gt;
-    let () = f v (fun v -&gt; <span data-count="43388">w</span>rite v q) in
-    <span data-count="43695">e</span>nd_pledge q;
-    <span data-count="43695">w</span>ork_while f q
+  <span data-count="44462">m</span>atch get q true with
+  | <span data-count="676">N</span>one -&gt; ()
+  | <span data-count="43778">S</span>ome v -&gt;
+    let () = f v (fun v -&gt; <span data-count="43454">w</span>rite v q) in
+    <span data-count="43757">e</span>nd_pledge q;
+    <span data-count="43758">w</span>ork_while f q
 </code></pre>
       </div>
     </div>

coverage/src/data_structures/wq.ml.html

@@ -115,20 +115,20 @@ <h2>100.00%</h2>
     <span data-count="336">N</span>il
   | <span data-count="192">S</span>ome v -&gt; Cons (v, read_as_se<span data-count="192">q</span> q ~finalizer)
 
-let push v q = <span data-count="551">S</span>ynchronizer.write v q
+let push v q = <span data-count="554">S</span>ynchronizer.write v q
 
-let work_while f q = <span data-count="705">S</span>ynchronizer.work_while f q
+let work_while f q = <span data-count="704">S</span>ynchronizer.work_while f q
 
 let fail = Synchronizer.fail
 
 let make () =
   <span data-count="718">l</span>et q = Queue.create () in
   <span data-count="718">l</span>et writter v condvar =
-    <span data-count="43948">l</span>et was_empty = Queue.is_empty q in
-    <span data-count="43948">Q</span>ueue.push v q;
-    <span data-count="43948">i</span>f was_empty then <span data-count="1449">C</span>ondition.broadcast condvar
+    <span data-count="44022">l</span>et was_empty = Queue.is_empty q in
+    <span data-count="44022">Q</span>ueue.push v q;
+    <span data-count="44022">i</span>f was_empty then <span data-count="1428">C</span>ondition.broadcast condvar
   in
-  Synchronizer.init (fun () -&gt; <span data-count="46047">Q</span>ueue.take_opt q) writter
+  Synchronizer.init (fun () -&gt; <span data-count="46065">Q</span>ueue.take_opt q) writter
 </code></pre>
       </div>
     </div>