Program slicing for ambiguous dates computation

catala.opam

@@ -31,7 +31,7 @@ depends: [
   "ocaml" {>= "4.13.0"}
   "ocamlfind" {!= "1.9.5"}
   "ocamlgraph" {>= "1.8.8"}
-  "ppx_yojson_conv" {>= "0.14.0"}
+  "ppx_yojson_conv" {= "v0.15.1"}
   "re" {>= "1.9.0"}
   "sedlex" {>= "2.4"}
   "uutf" {>= "1.0.3"}

compiler/driver.ml

@@ -370,8 +370,7 @@ let driver source_file (options : Cli.options) : int =
                 | None -> None
                 | Some _ -> Some scope_uid)
             in
-
-            Verification.Solver.solve_vc prgm.decl_ctx vcs
+            Verification.Solver.solve_vcs prgm.decl_ctx vcs
           | `Interpret ->
             Message.emit_debug "Starting interpretation (dcalc)...";
             let results =

compiler/shared_ast/print.ml

@@ -542,7 +542,10 @@ let rec expr_aux :
     pr colors fmt e;
     Format.pp_close_box fmt ()
   | EApp { f = EOp { op; _ }, _; args = [arg1] } ->
-    Format.fprintf fmt "@[<hv 2>%a@ %a@]" (operator ~debug) op (rhs exprc) arg1
+    (* FIXME: I'd like to have an imperative style printing of function calls
+       (ie f(a,b,c) rather than (f a b c)) for Mopsa export. How to concialiate
+       both? *)
+    Format.fprintf fmt "@[<hv 2>%a(%a)@]" (operator ~debug) op (rhs exprc) arg1
   | EApp { f; args } ->
     Format.fprintf fmt "@[<hv 2>%a@ %a@]" (lhs exprc) f
       (Format.pp_print_list

compiler/shared_ast/var.ml

@@ -76,6 +76,11 @@ module Set = struct
   let of_list l = of_list (List.map t l)
   let elements s = elements s |> List.map get
   let diff s1 s2 = diff s1 s2
+  let choose_opt s = Option.map get (choose_opt s)
+  let filter f s = filter (fun v -> f (get v)) s
+  let exists f s = exists (fun v -> f (get v)) s
+  let inter s1 s2 = inter s1 s2
+  let fold f s init = fold (fun v acc -> f (get v) acc) s init
 
   (* Add more as needed *)
 end
@@ -95,9 +100,14 @@ module Map = struct
   let find v m = find (t v) m
   let find_opt v m = find_opt (t v) m
   let bindings m = bindings m |> List.map (fun (v, x) -> get v, x)
+  let map f m = map f m
+  let mapi f m = mapi (fun v x -> f (get v) x) m
   let mem x m = mem (t x) m
   let union f m1 m2 = union (fun v x1 x2 -> f (get v) x1 x2) m1 m2
   let fold f m acc = fold (fun v x acc -> f (get v) x acc) m acc
+  let filter f m = filter (fun k v -> f (get k) v) m
+  let exists f m = exists (fun k v -> f (get k) v) m
+  let remove x s = remove (t x) s
 
   (* Add more as needed *)
 end

compiler/shared_ast/var.mli

@@ -49,6 +49,11 @@ module Set : sig
   val of_list : 'e var list -> 'e t
   val elements : 'e t -> 'e var list
   val diff : 'e t -> 'e t -> 'e t
+  val choose_opt : 'e t -> 'e var option
+  val filter : ('e var -> bool) -> 'e t -> 'e t
+  val exists : ('e var -> bool) -> 'e t -> bool
+  val inter : 'e t -> 'e t -> 'e t
+  val fold : ('e var -> 'x -> 'x) -> 'e t -> 'x -> 'x
 end
 
 (** Wrapper over [Map.S] but with a type variable for the AST type parameters.
@@ -59,14 +64,19 @@ module Map : sig
   val empty : ('e, 'x) t
   val singleton : 'e var -> 'x -> ('e, 'x) t
   val add : 'e var -> 'x -> ('e, 'x) t -> ('e, 'x) t
+  val remove : 'e var -> ('e, 'x) t -> ('e, 'x) t
   val update : 'e var -> ('x option -> 'x option) -> ('e, 'x) t -> ('e, 'x) t
   val find : 'e var -> ('e, 'x) t -> 'x
   val find_opt : 'e var -> ('e, 'x) t -> 'x option
   val bindings : ('e, 'x) t -> ('e var * 'x) list
   val mem : 'e var -> ('e, 'x) t -> bool
+  val map : ('x -> 'y) -> ('e, 'x) t -> ('e, 'y) t
+  val mapi : ('e var -> 'x -> 'y) -> ('e, 'x) t -> ('e, 'y) t
+  val filter : ('e var -> 'x -> bool) -> ('e, 'x) t -> ('e, 'x) t
 
   val union :
     ('e var -> 'x -> 'x -> 'x option) -> ('e, 'x) t -> ('e, 'x) t -> ('e, 'x) t
 
   val fold : ('e var -> 'x -> 'acc -> 'acc) -> ('e, 'x) t -> 'acc -> 'acc
+  val exists : ('e var -> 'x -> bool) -> ('e, 'x) t -> bool
 end