ocamlformat in JS-only files in lambda/

Author: goldfirere

ocaml/lambda/.ocamlformat

@@ -1,5 +1,17 @@
-profile=conventional
-if-then-else=k-r
-indicate-multiline-delimiters=closing-on-separate-line
-break-cases=all
+# Please make a pull request to change this file.
 disable=true
+# There is an .ocamlformat-enable file in this directory.
+# Keep the remainder of this file in sync with other .ocamlformat files in this repo.
+assignment-operator=begin-line
+cases-exp-indent=2
+doc-comments=before
+dock-collection-brackets=false
+if-then-else=keyword-first
+module-item-spacing=sparse
+parens-tuple=multi-line-only
+sequence-blank-line=compact
+space-around-lists=false
+space-around-variants=false
+type-decl=sparse
+wrap-comments=true
+version=0.24.1

ocaml/lambda/.ocamlformat-enable

@@ -1,2 +1,10 @@
 assume_info.ml
 assume_info.mli
+transl_array_comprehension.ml
+transl_array_comprehension.mli
+transl_comprehension_utils.ml
+transl_comprehension_utils.mli
+transl_list_comprehension.ml
+transl_list_comprehension.mli
+translmode.ml
+translmode.mli

ocaml/lambda/assume_info.ml

@@ -1,52 +1,56 @@
-(*
+(* The meaning of keywords [strict] and [never_returns_normally] is defined in
+   terms of abstract values as follows:
 
-   The meaning of keywords [strict] and [never_returns_normally]
-   is defined in terms of abstract values as follows:
+   relaxed (default): nor = Safe and exn = Top and div = Top strict: nor = Safe
+   and exn = Safe and div = Safe never_returns_normally: nor = Bot and exn = Top
+   and div = Top
 
-   relaxed (default):         nor = Safe and exn = Top  and div = Top
-   strict:                    nor = Safe and exn = Safe and div = Safe
-   never_returns_normally:    nor = Bot  and exn = Top  and div = Top
+   where [nor] means normal return of the call, [exn] means return via an
+   exception, [div] means diverging (non-terminating) executions, and the
+   meaning and order of elements is:
 
-   where [nor] means normal return of the call, [exn] means return via an exception,
-   [div] means diverging (non-terminating) executions,
-   and the meaning and order of elements is:
+   Top may allocate Safe does not allocate on any execution paths Bot
+   unreachable
 
-   Top    may allocate
-   Safe   does not allocate on any execution paths
-   Bot    unreachable
-
-   Using more than one keyword means intersection (i.e., meet of the  elements,
+   Using more than one keyword means intersection (i.e., meet of the elements,
    pointwise lifted to tuples), so we get the following:
 
-   [@zero_alloc assume]                               nor = Safe and exn = Top  and div = Top
-   [@zero_alloc assume strict]                        nor = Safe and exn = Safe and div = Safe
-   [@zero_alloc assume strict never_returns_normally] nor = Bot  and exn = Safe and div = Safe
-   [@zero_alloc assume never_returns_normally]        nor = Bot  and exn = Top  and div = Top
+   [@zero_alloc assume] nor = Safe and exn = Top and div = Top [@zero_alloc
+   assume strict] nor = Safe and exn = Safe and div = Safe [@zero_alloc assume
+   strict never_returns_normally] nor = Bot and exn = Safe and div = Safe
+   [@zero_alloc assume never_returns_normally] nor = Bot and exn = Top and div =
+   Top
 
-   See [Value] and [Annotation] in [backend/checkmach.ml].
-*)
-(* CR gyorsh: should we move [Value] and [Annotation] here or maybe "utils" and use them
-   directly, instead of the weird compare function that abstracts them? Perhaps we
-   should translate "strict" and "never_returns_normally" directly into (nor,exn,div)
-*)
+   See [Value] and [Annotation] in [backend/checkmach.ml]. *)
+(* CR gyorsh: should we move [Value] and [Annotation] here or maybe "utils" and
+   use them directly, instead of the weird compare function that abstracts them?
+   Perhaps we should translate "strict" and "never_returns_normally" directly
+   into (nor,exn,div) *)
 
 module Witnesses = struct
   type t = unit
 
   let join _ _ = ()
+
   let lessequal _ _ = true
+
   let meet _ _ = ()
+
   let print _ _ = ()
+
   let empty = ()
+
   let compare _ _ = 0
 end
 
 include Zero_alloc_utils.Make (Witnesses)
 
-type t = No_assume | Assume of Value.t
+type t =
+  | No_assume
+  | Assume of Value.t
 
 let compare t1 t2 =
-  match (t1, t2) with
+  match t1, t2 with
   | No_assume, No_assume -> 0
   | Assume v1, Assume v2 -> Value.compare v1 v2
   | No_assume, Assume _ -> -1
@@ -61,44 +65,24 @@ let print ppf = function
 let to_string v = Format.asprintf "%a" print v
 
 let join t1 t2 =
-  match (t1, t2) with
+  match t1, t2 with
   | No_assume, No_assume -> No_assume
-  | No_assume, Assume _
-  | Assume _, No_assume ->
-      No_assume
+  | No_assume, Assume _ | Assume _, No_assume -> No_assume
   | Assume t1, Assume t2 -> Assume (Value.join t1 t2)
 
 let meet t1 t2 =
-  match (t1, t2) with
+  match t1, t2 with
   | No_assume, No_assume -> No_assume
-  | No_assume, (Assume _ as t)
-  | (Assume _ as t), No_assume ->
-      t
+  | No_assume, (Assume _ as t) | (Assume _ as t), No_assume -> t
   | Assume t1, Assume t2 -> Assume (Value.meet t1 t2)
 
 let none = No_assume
 
 let create ~strict ~never_returns_normally =
-  let res =
-    if strict then
-      Value.safe
-    else
-      Value.relaxed Witnesses.empty
-  in
-  let res =
-    if never_returns_normally then
-      { res with nor = V.Bot }
-    else
-      res
-  in
+  let res = if strict then Value.safe else Value.relaxed Witnesses.empty in
+  let res = if never_returns_normally then { res with nor = V.Bot } else res in
   Assume res
 
-let get_value t =
-  match t with
-  | No_assume -> None
-  | Assume v -> Some v
+let get_value t = match t with No_assume -> None | Assume v -> Some v
 
-let is_none t =
-  match t with
-  | No_assume -> true
-  | Assume _ -> false
+let is_none t = match t with No_assume -> true | Assume _ -> false

ocaml/lambda/assume_info.mli

@@ -1,22 +1,34 @@
 type t
 
 val none : t
+
 val create : strict:bool -> never_returns_normally:bool -> t
+
 val compare : t -> t -> int
+
 val equal : t -> t -> bool
+
 val join : t -> t -> t
+
 val meet : t -> t -> t
+
 val to_string : t -> string
+
 val print : Format.formatter -> t -> unit
+
 val is_none : t -> bool
 
 module Witnesses : sig
   type t = unit
 
   val join : t -> t -> t
+
   val meet : t -> t -> t
+
   val lessequal : t -> t -> bool
+
   val print : Format.formatter -> t -> unit
+
   val compare : t -> t -> int
 end