Use any kind of formula for compiler constraints

So now, one can write:

    ocaml-version: [ >= 3.12.1 & <= 4.00.0 ]

opam.ocp

@@ -18,10 +18,10 @@ begin library "opam-lib"
     "opamParallel.ml"
     "opamFilename.ml"
     "opamPackage.ml"
+    "opamFormula.ml"
     "opamVersion.ml"
     "opamVariable.ml"
     "opamAlias.ml"
-    "opamFormula.ml"
     "opamTypes.ml"
     "opamFormat.ml"
     "opamParser.mly"

src/opamClient.ml

@@ -92,9 +92,10 @@ let available_packages root compiler config pinned packages =
   let filter nv =
     let opam = OpamFile.OPAM.read (OpamPath.opam root nv) in
     let consistent_ocaml_version =
+      let atom (r,v) = OpamVersion.Compiler.compare ocaml_version r v in
       match OpamFile.OPAM.ocaml_version opam with
-      | None       -> true
-      | Some (r,v) -> OpamVersion.Compiler.compare ocaml_version r v in
+      | None   -> true
+      | Some c -> OpamFormula.eval atom c in
     let consistent_pinned_version =
       not (OpamPackage.Name.Map.mem (OpamPackage.name nv) pinned) ||
         match OpamPackage.Name.Map.find (OpamPackage.name nv) pinned with
@@ -259,46 +260,6 @@ let find_installed_package_by_name t name =
   with Not_found ->
     OpamGlobals.error_and_exit "Package %s is not installed" (OpamPackage.Name.to_string name)
 
-(* Remove the packages which does not fullfil the compiler constraints
-   & deal with pinned packages. *)
-let packages t =
-  let ocaml_version =
-    let current_alias = t.alias in
-    let default_alias = OpamAlias.of_string OpamGlobals.default_alias in
-    if current_alias = default_alias then (
-      let current = OpamVersion.Compiler.current () in
-      let system = OpamFile.Config.system_version t.config in
-      match current, system  with
-      | None  , None   -> OpamGlobals.error_and_exit "No OCaml compiler installed."
-      | None  , Some s -> s
-      | Some c, Some s ->
-        if s <> c then (
-          OpamGlobals.warning "The version of OCaml in your path (%S) \
-                                 is not the same as the one OPAM has been \
-                                 initialized with (%S)."
-            (OpamVersion.Compiler.to_string c)
-            (OpamVersion.Compiler.to_string s)
-        );
-        s
-      | Some c, None   -> c
-    ) else
-      match t.compiler with
-      | Some v -> v
-      | None   -> OpamGlobals.error_and_exit "No OCaml compiler defined."in
-  let filter nv =
-    let opam = opam t nv in
-    let consistent_ocaml_version =
-      match OpamFile.OPAM.ocaml_version opam with
-      | None       -> true
-      | Some (r,v) -> OpamVersion.Compiler.compare ocaml_version r v in
-    let consistent_pinned_version =
-      not (OpamPackage.Name.Map.mem (OpamPackage.name nv) t.pinned) ||
-        match OpamPackage.Name.Map.find (OpamPackage.name nv) t.pinned with
-        | Version v -> v = OpamPackage.version nv
-        | _         -> true (* any version is fine, as this will be overloaded on install *) in
-    consistent_ocaml_version && consistent_pinned_version in
-  OpamPackage.Set.filter filter t.packages
-
 let find_package_by_name t name =
   let r = OpamPackage.Set.filter (fun nv -> OpamPackage.name nv = name) t.packages in
   if OpamPackage.Set.is_empty r then

src/opamFile.ml

@@ -679,7 +679,7 @@ module OPAM = struct
       ] @ (
         match t.ocaml_version with
         | None   -> []
-        | Some v -> [ Variable (s_ocaml_version, OpamFormat.make_constraint v) ]
+        | Some v -> [ Variable (s_ocaml_version, OpamFormat.make_compiler_constraint v) ]
       ) @
         List.map (fun (s, v) -> Variable (s, v)) t.others;
     } in
@@ -735,7 +735,7 @@ module OPAM = struct
     let conflicts = OpamFormat.assoc_default OpamFormula.Empty s s_conflicts OpamFormat.parse_formula in
     let libraries = OpamFormat.assoc_list s s_libraries (OpamFormat.parse_list (OpamFormat.parse_string |> OpamVariable.Section.of_string)) in
     let syntax = OpamFormat.assoc_list s s_syntax (OpamFormat.parse_list (OpamFormat.parse_string |> OpamVariable.Section.of_string)) in
-    let ocaml_version = OpamFormat.assoc_option s s_ocaml_version OpamFormat.parse_constraint in
+    let ocaml_version = OpamFormat.assoc_option s s_ocaml_version OpamFormat.parse_compiler_constraint in
     let parse_file = OpamFormat.parse_option (OpamFormat.parse_string |> OpamFilename.Base.of_string) OpamFormat.parse_filter in
     let patches = OpamFormat.assoc_list s s_patches (OpamFormat.parse_list parse_file) in
     let files = OpamFormat.assoc_list s s_files (OpamFormat.parse_list parse_file) in

src/opamFormat.ml

@@ -349,16 +349,6 @@ let parse_relop = function
   | "<"  -> `Lt
   | _    -> invalid_arg "parse_relop"
 
-let parse_constraint = function
-  | List [ Symbol r; String v ] ->
-      (try (parse_relop r, OpamVersion.Compiler.of_string v)
-       with _ -> bad_format "Expecting a relop, got %s" r)
-  | x -> bad_format "Expecting a constraint, got %s" (kind x)
-
-let make_constraint = function
-  | (name,_), None       -> String name
-  | (name,_), Some (r,v) -> Option (String name, [Symbol r; String v])
-
 let string_of_relop = function
   | `Eq  -> "="
   | `Geq -> ">="
@@ -367,11 +357,33 @@ let string_of_relop = function
   | `Lt  -> "<"
   | _    -> invalid_arg "parse_relop"
 
-let make_constraint (r, v) =
-  List [
-    Symbol (string_of_relop r);
-    String (OpamVersion.Compiler.to_string v);
-  ]
+let rec parse_compiler_constraint t =
+  let module F = OpamFormula in
+  match t with
+  | []                     -> F.Empty
+  | [Symbol r; String v ]  ->
+    (try F.Atom (parse_relop r, OpamVersion.Compiler.of_string v)
+     with _ -> bad_format "Expecting a relop, got %s" r)
+  | [Group g]              -> parse_compiler_constraint g
+  | e1::e2 :: Symbol "|" :: e3 -> F.Or (parse_compiler_constraint [e1;e2], parse_compiler_constraint e3)
+  | e1::e2 :: Symbol "&" :: e3 -> F.And (parse_compiler_constraint [e1;e2], parse_compiler_constraint e3)
+  | x -> bad_format "Expecting a compiler constraint, got %s" (kinds x)
+
+let parse_compiler_constraint = function
+  | List l -> parse_compiler_constraint l
+  | x      -> bad_format "Expecting a list, got %s" (kind x)
+
+let rec make_compiler_constraint t =
+  let module F = OpamFormula in
+  match t with
+  | F.Empty       -> []
+  | F.Atom (r, v) -> [Symbol (string_of_relop r); String (OpamVersion.Compiler.to_string  v)]
+  | F.Block f     -> [Group (make_compiler_constraint f)]
+  | F.And(e,f)    -> make_compiler_constraint e @ [Symbol "|"] @ make_compiler_constraint f
+  | F.Or(e,f)     -> make_compiler_constraint e @ [Symbol "|"] @ make_compiler_constraint f
+
+let make_compiler_constraint t =
+  List (make_compiler_constraint t)
 
 let parse_env_variable v =
   let l = parse_sequence [

src/opamFormat.mli

@@ -192,11 +192,11 @@ val parse_opt_formula : value -> formula
 (** Build a formula where OR are implicit. *)
 val make_opt_formula : formula -> value
 
-(** Parse a simple constraint *)
-val parse_constraint: value -> compiler_constraint
+(** Parse compiler constraints *)
+val parse_compiler_constraint: value -> compiler_constraint
 
-(** Build a simple constraint *)
-val make_constraint: compiler_constraint -> value
+(** Build a compiler constraint *)
+val make_compiler_constraint: compiler_constraint -> value
 
 (** {2 Environment variables} *)
 

src/opamFormula.ml

@@ -68,6 +68,13 @@ let rec fold_left f i = function
 
 type t = (OpamPackage.Name.t * (string * OpamPackage.Version.t) formula) formula
 
+let rec eval atom = function
+  | Empty    -> true
+  | Atom x   -> atom x
+  | Block x  -> eval atom x
+  | And(x,y) -> eval atom x && eval atom y
+  | Or(x,y)  -> eval atom x && eval atom y
+
 let to_string t =
   let string_of_constraint (relop, version) =
     Printf.sprintf "%s %s" relop (OpamPackage.Version.to_string version) in

src/opamFormula.mli

@@ -35,6 +35,9 @@ type 'a formula =
   | And of 'a formula * 'a formula
   | Or of 'a formula * 'a formula
 
+(** Eval a formula *)
+val eval: ('a -> bool) -> 'a formula -> bool
+
 (** Pretty print a formula *)
 val string_of_formula: ('a -> string) -> 'a formula -> string
 

src/opamVersion.ml

@@ -21,7 +21,7 @@ module Compiler = struct
 
   include OpamMisc.Base
 
-  type constr = relop * t
+  type constr = (relop * t) OpamFormula.formula
 
   let current () =
     match OpamSystem.ocaml_version () with

src/opamVersion.mli

@@ -24,7 +24,7 @@ module Compiler: sig
   include OpamMisc.ABSTRACT
 
   (** Compiler constraint *)
-  type constr = relop * t
+  type constr = (relop * t) OpamFormula.formula
 
   (** Return the version of the compiler currently installed *)
   val current: unit -> t option