From c61b32393508479657b51b777a0b4816815a55a5 Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Thu, 31 Aug 2023 19:10:00 +0200
Subject: Make progress on Extract and ExtractBase

---
 compiler/ExtractBase.ml | 33 ++++++++++++++++++++++-----------
 1 file changed, 22 insertions(+), 11 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index d733c763..96ecfd42 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -586,6 +586,8 @@ type extraction_ctx = {
           in case a Rust function only has one backward translation
           and we filter the forward function because it returns unit.
         *)
+  trait_decl_id : trait_decl_id option;
+      (** If we are extracting a trait declaration, identifies it *)
 }
 
 (** Debugging function, used when communicating name collisions to the user,
@@ -885,12 +887,24 @@ let ctx_add_const_generic_params (vars : const_generic_var list)
       ctx_add_const_generic_var var.name var.index ctx)
     ctx vars
 
-let ctx_add_type_const_generic_params (tvars : type_var list)
-    (cgvars : const_generic_var list) (ctx : extraction_ctx) :
-    extraction_ctx * string list * string list =
-  let ctx, tys = ctx_add_type_params tvars ctx in
-  let ctx, cgs = ctx_add_const_generic_params cgvars ctx in
-  (ctx, tys, cgs)
+let ctx_add_trait_clauses (clauses : trait_clause list) (ctx : extraction_ctx) :
+    extraction_ctx * string list =
+  List.fold_left_map
+    (fun ctx (c : trait_clause) -> ctx_add_trait_clause c ctx)
+    ctx clauses
+
+(** Returns the lists of names for:
+    - the type variables
+    - the const generic variables
+    - the trait clauses
+  *)
+let ctx_add_generic_params (generics : generic_params) (ctx : extraction_ctx) :
+    extraction_ctx * string list * string list * string list =
+  let { types; const_generics; trait_clauses } = generics in
+  let ctx, tys = ctx_add_type_params types ctx in
+  let ctx, cgs = ctx_add_const_generic_params const_generics ctx in
+  let ctx, tcs = ctx_add_trait_clauses trait_clauses ctx in
+  (ctx, tys, cgs, tcs)
 
 let ctx_add_type_decl_struct (def : type_decl) (ctx : extraction_ctx) :
     extraction_ctx * string =
@@ -1003,14 +1017,11 @@ let ctx_add_fun_decl (trans_group : bool * pure_fun_translation)
     | None -> None
     | Some rg_id ->
         let rg = T.RegionGroupId.nth sg.regions_hierarchy rg_id in
-        let regions =
+        let region_names =
           List.map
-            (fun rid -> T.RegionVarId.nth sg.region_params rid)
+            (fun rid -> (T.RegionVarId.nth sg.generics.regions rid).name)
             rg.regions
         in
-        let region_names =
-          List.map (fun (r : T.region_var) -> r.name) regions
-        in
         Some { id = rg_id; region_names }
   in
   let is_opaque = def.body = None in
-- 
cgit v1.3.1


From 0023f814ce638cd9b04ead9ec2e0c194d5efaefd Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Fri, 1 Sep 2023 18:22:15 +0200
Subject: Make good progress on Extract.ml

---
 compiler/Extract.ml     | 414 ++++++++++++++++++++++--------------------------
 compiler/ExtractBase.ml |  47 +++++-
 2 files changed, 237 insertions(+), 224 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/compiler/Extract.ml b/compiler/Extract.ml
index 4238a152..3c4feca5 100644
--- a/compiler/Extract.ml
+++ b/compiler/Extract.ml
@@ -836,6 +836,11 @@ let mk_formatter (ctx : trans_ctx) (crate_name : string)
         to_snake_case basename
     | Coq | Lean -> basename
   in
+  let trait_clause_basename (_varset : StringSet.t) (_clause : trait_clause) :
+      string =
+    (* TODO: actually use the clause to derive the name *)
+    "cl"
+  in
   let append_index (basename : string) (i : int) : string =
     basename ^ string_of_int i
   in
@@ -931,6 +936,7 @@ let mk_formatter (ctx : trans_ctx) (crate_name : string)
     var_basename;
     type_var_basename;
     const_generic_var_basename;
+    trait_clause_basename;
     append_index;
     extract_literal;
     extract_unop;
@@ -1246,16 +1252,18 @@ and extract_trait_ref (ctx : extraction_ctx) (fmt : F.formatter)
 and extract_generic_args (ctx : extraction_ctx) (fmt : F.formatter)
     (no_params_tys : TypeDeclId.Set.t) (generics : generic_args) : unit =
   let { types; const_generics; trait_refs } = generics in
-  if types <> [] then (
-    F.pp_print_space fmt ();
-    Collections.List.iter_link (F.pp_print_space fmt)
-      (extract_ty ctx fmt no_params_tys true)
-      types);
-  if const_generics <> [] then (
-    F.pp_print_space fmt ();
-    Collections.List.iter_link (F.pp_print_space fmt)
-      (extract_const_generic ctx fmt true)
-      const_generics);
+  if !backend <> HOL4 then (
+    if types <> [] then (
+      F.pp_print_space fmt ();
+      Collections.List.iter_link (F.pp_print_space fmt)
+        (extract_ty ctx fmt no_params_tys true)
+        types);
+    if const_generics <> [] then (
+      assert (!backend <> HOL4);
+      F.pp_print_space fmt ();
+      Collections.List.iter_link (F.pp_print_space fmt)
+        (extract_const_generic ctx fmt true)
+        const_generics));
   if trait_refs <> [] then (
     F.pp_print_space fmt ();
     Collections.List.iter_link (F.pp_print_space fmt)
@@ -1588,6 +1596,93 @@ let extract_comment (fmt : F.formatter) (sl : string list) : unit =
   F.pp_print_string fmt rd;
   F.pp_close_box fmt ()
 
+let extract_trait_clause_type (ctx : extraction_ctx) (fmt : F.formatter)
+    (no_params_tys : TypeDeclId.Set.t) (clause : trait_clause) : unit =
+  let with_opaque_pre = false in
+  let trait_name = ctx_get_trait_decl with_opaque_pre clause.trait_id ctx in
+  F.pp_print_string fmt trait_name;
+  extract_generic_args ctx fmt no_params_tys clause.generics
+
+(** Insert a space, if necessary *)
+let insert_req_space (fmt : F.formatter) (space : bool ref) : unit =
+  if !space then space := false else F.pp_print_space fmt ()
+
+let extract_generic_params (ctx : extraction_ctx) (fmt : F.formatter)
+    (no_params_tys : TypeDeclId.Set.t) (use_forall : bool) (as_implicits : bool)
+    (space : bool ref option) (generics : generic_params)
+    (type_params : string list) (cg_params : string list)
+    (trait_clauses : string list) : unit =
+  let all_params = List.concat [ type_params; cg_params; trait_clauses ] in
+  (* HOL4 doesn't support const generics *)
+  assert (cg_params = [] || !backend <> HOL4);
+  let left_bracket () =
+    if as_implicits then F.pp_print_string fmt "{"
+    else F.pp_print_string fmt "("
+  in
+  let right_bracket () =
+    if as_implicits then F.pp_print_string fmt "}"
+    else F.pp_print_string fmt ")"
+  in
+  let insert_req_space () =
+    match space with
+    | None -> F.pp_print_space fmt ()
+    | Some space -> insert_req_space fmt space
+  in
+  (* Print the type/const generic parameters *)
+  if all_params <> [] then (
+    if use_forall then (
+      insert_req_space ();
+      F.pp_print_string fmt ":";
+      F.pp_print_space fmt ();
+      F.pp_print_string fmt "forall");
+    (* Note that in HOL4 we don't print the type parameters. *)
+    if !backend <> HOL4 then (
+      (* Print the type parameters *)
+      if type_params <> [] then (
+        insert_req_space ();
+        (* ( *)
+        left_bracket ();
+        List.iter
+          (fun s ->
+            F.pp_print_string fmt s;
+            F.pp_print_space fmt ())
+          type_params;
+        F.pp_print_string fmt ":";
+        F.pp_print_space fmt ();
+        F.pp_print_string fmt (type_keyword ());
+        (* ) *)
+        right_bracket ());
+      (* Print the const generic parameters *)
+      List.iter
+        (fun (var : const_generic_var) ->
+          insert_req_space ();
+          (* ( *)
+          left_bracket ();
+          let n = ctx_get_const_generic_var var.index ctx in
+          F.pp_print_string fmt n;
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt ":";
+          F.pp_print_space fmt ();
+          extract_literal_type ctx fmt var.ty;
+          (* ) *)
+          right_bracket ())
+        generics.const_generics);
+    (* Print the trait clauses *)
+    List.iter
+      (fun (clause : trait_clause) ->
+        insert_req_space ();
+        (* ( *)
+        left_bracket ();
+        let n = ctx_get_trait_clause_var clause.clause_id ctx in
+        F.pp_print_string fmt n;
+        F.pp_print_space fmt ();
+        F.pp_print_string fmt ":";
+        F.pp_print_space fmt ();
+        extract_trait_clause_type ctx fmt no_params_tys clause;
+        (* ) *)
+        right_bracket ())
+      generics.trait_clauses)
+
 (** Extract a type declaration.
 
     This function is for all type declarations and all backends **at the exception**
@@ -1624,7 +1719,6 @@ let extract_type_decl_gen (ctx : extraction_ctx) (fmt : F.formatter)
   let ctx_body, type_params, cg_params, trait_clauses =
     ctx_add_generic_params def.generics ctx
   in
-  let all_params = List.concat [ type_params; cg_params; trait_clauses ] in
   (* Add a break before *)
   if !backend <> HOL4 || not (decl_is_first_from_group kind) then
     F.pp_print_break fmt 0 0;
@@ -1644,40 +1738,13 @@ let extract_type_decl_gen (ctx : extraction_ctx) (fmt : F.formatter)
   (match qualif with
   | Some qualif -> F.pp_print_string fmt (qualif ^ " " ^ def_name)
   | None -> F.pp_print_string fmt def_name);
-  (* HOL4 doesn't support const generics *)
-  assert (cg_params = [] || !backend <> HOL4);
-  (* Print the type/const generic parameters *)
-  if all_params <> [] && !backend <> HOL4 then (
-    if use_forall then (
-      F.pp_print_space fmt ();
-      F.pp_print_string fmt ":";
-      F.pp_print_space fmt ();
-      F.pp_print_string fmt "forall");
-    (* Print the type parameters *)
-    if type_params <> [] then (
-      F.pp_print_space fmt ();
-      F.pp_print_string fmt "(";
-      List.iter
-        (fun s ->
-          F.pp_print_string fmt s;
-          F.pp_print_space fmt ())
-        type_params;
-      F.pp_print_string fmt ":";
-      F.pp_print_space fmt ();
-      F.pp_print_string fmt (type_keyword () ^ ")"));
-    (* Print the const generic parameters *)
-    List.iter
-      (fun (var : const_generic_var) ->
-        F.pp_print_space fmt ();
-        F.pp_print_string fmt "(";
-        let n = ctx_get_const_generic_var var.index ctx in
-        F.pp_print_string fmt n;
-        F.pp_print_space fmt ();
-        F.pp_print_string fmt ":";
-        F.pp_print_space fmt ();
-        extract_literal_type ctx fmt var.ty;
-        F.pp_print_string fmt ")")
-      def.const_generic_params);
+  (* HOL4 doesn't support const generics, and type definitions in HOL4 don't
+     support trait clauses *)
+  assert ((cg_params = [] && trait_clauses = []) || !backend <> HOL4);
+  (* Print the generic parameters *)
+  let as_implicits = false in
+  extract_generic_params ctx_body fmt type_decl_group use_forall as_implicits
+    None def.generics type_params cg_params trait_clauses;
   (* Print the "=" if we extract the body*)
   if extract_body then (
     F.pp_print_space fmt ();
@@ -1737,9 +1804,12 @@ let extract_type_decl_hol4_opaque (ctx : extraction_ctx) (fmt : F.formatter)
   let with_opaque_pre = false in
   let def_name = ctx_get_local_type with_opaque_pre def.def_id ctx in
   (* Generic parameters are unsupported *)
-  assert (def.const_generic_params = []);
+  assert (def.generics.const_generics = []);
+  (* Trait clauses on type definitions are unsupported *)
+  assert (def.generics.trait_clauses = []);
+  (* Types  *)
   (* Count the number of parameters *)
-  let num_params = List.length def.type_params in
+  let num_params = List.length def.generics.types in
   (* Generate the declaration *)
   F.pp_print_space fmt ();
   F.pp_print_string fmt
@@ -1760,8 +1830,7 @@ let extract_type_decl_hol4_empty_record (ctx : extraction_ctx)
   let with_opaque_pre = false in
   let def_name = ctx_get_local_type with_opaque_pre def.def_id ctx in
   (* Sanity check *)
-  assert (def.type_params = []);
-  assert (def.const_generic_params = []);
+  assert (def.generics = empty_generic_params);
   (* Generate the declaration *)
   F.pp_print_space fmt ();
   F.pp_print_string fmt ("Type " ^ def_name ^ " = “: unit”");
@@ -1801,13 +1870,12 @@ let extract_type_decl_coq_arguments (ctx : extraction_ctx) (fmt : F.formatter)
     (kind : decl_kind) (decl : type_decl) : unit =
   assert (!backend = Coq);
   (* Generating the [Arguments] instructions is useful only if there are type parameters *)
-  if decl.type_params = [] && decl.const_generic_params = [] then ()
+  if decl.generics.types = [] && decl.generics.const_generics = [] then ()
   else
     (* Add the type params - note that we need those bindings only for the
      * body translation (they are not top-level) *)
-    let _ctx_body, type_params, cg_params =
-      ctx_add_type_const_generic_params decl.type_params
-        decl.const_generic_params ctx
+    let _ctx_body, type_params, cg_params, trait_clauses =
+      ctx_add_generic_params decl.generics ctx
     in
     (* Auxiliary function to extract an [Arguments Cons {T} _ _.] instruction *)
     let extract_arguments_info (cons_name : string) (fields : 'a list) : unit =
@@ -1815,27 +1883,22 @@ let extract_type_decl_coq_arguments (ctx : extraction_ctx) (fmt : F.formatter)
       F.pp_print_break fmt 0 0;
       (* Open a box *)
       F.pp_open_hovbox fmt ctx.indent_incr;
-      (* Small utility *)
-      let print_vars () =
-        List.iter
-          (fun (var : string) ->
-            F.pp_print_space fmt ();
-            F.pp_print_string fmt ("{" ^ var ^ "}"))
-          (List.append type_params cg_params)
-      in
-      let print_fields () =
-        List.iter
-          (fun _ ->
-            F.pp_print_space fmt ();
-            F.pp_print_string fmt "_")
-          fields
-      in
       F.pp_print_break fmt 0 0;
       F.pp_print_string fmt "Arguments";
       F.pp_print_space fmt ();
       F.pp_print_string fmt cons_name;
-      print_vars ();
-      print_fields ();
+      (* Print the type/const params and the trait clauses (`{T}`) *)
+      List.iter
+        (fun (var : string) ->
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt ("{" ^ var ^ "}"))
+        (List.concat [ type_params; cg_params; trait_clauses ]);
+      (* Print the fields (`_`) *)
+      List.iter
+        (fun _ ->
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt "_")
+        fields;
       F.pp_print_string fmt ".";
 
       (* Close the box *)
@@ -1888,9 +1951,8 @@ let extract_type_decl_record_field_projectors (ctx : extraction_ctx)
       let is_rec = decl_is_from_rec_group kind in
       if is_rec then
         (* Add the type params *)
-        let ctx, type_params, cg_params =
-          ctx_add_type_const_generic_params decl.type_params
-            decl.const_generic_params ctx
+        let ctx, type_params, cg_params, trait_clauses =
+          ctx_add_generic_params decl.generics ctx
         in
         let ctx, record_var = ctx_add_var "x" (VarId.of_int 0) ctx in
         let ctx, field_var = ctx_add_var "x" (VarId.of_int 1) ctx in
@@ -1911,33 +1973,13 @@ let extract_type_decl_record_field_projectors (ctx : extraction_ctx)
           F.pp_print_space fmt ();
           let field_name = ctx_get_field (AdtId decl.def_id) field_id ctx in
           F.pp_print_string fmt field_name;
-          F.pp_print_space fmt ();
-          (* Print the type parameters *)
-          if type_params <> [] then (
-            F.pp_print_string fmt "{";
-            List.iter
-              (fun p ->
-                F.pp_print_string fmt p;
-                F.pp_print_space fmt ())
-              type_params;
-            F.pp_print_string fmt ":";
-            F.pp_print_space fmt ();
-            F.pp_print_string fmt "Type}";
-            F.pp_print_space fmt ());
-          (* Print the const generic parameters *)
-          if cg_params <> [] then
-            List.iter
-              (fun (v : const_generic_var) ->
-                F.pp_print_string fmt "{";
-                let n = ctx_get_const_generic_var v.index ctx in
-                F.pp_print_string fmt n;
-                F.pp_print_string fmt ":";
-                F.pp_print_space fmt ();
-                extract_literal_type ctx fmt v.ty;
-                F.pp_print_string fmt "}";
-                F.pp_print_space fmt ())
-              decl.const_generic_params;
+          (* Print the generics *)
+          let use_forall = false in
+          let as_implicits = true in
+          extract_generic_params ctx fmt TypeDeclId.Set.empty use_forall
+            as_implicits None decl.generics type_params cg_params trait_clauses;
           (* Print the record parameter *)
+          F.pp_print_space fmt ();
           F.pp_print_string fmt "(";
           F.pp_print_string fmt record_var;
           F.pp_print_space fmt ();
@@ -2183,11 +2225,11 @@ let extract_adt_g_value
     (inside : bool) (variant_id : VariantId.id option) (field_values : 'v list)
     (ty : ty) : extraction_ctx =
   match ty with
-  | Adt (Tuple, type_args, cg_args) ->
+  | Adt (Tuple, generics) ->
       (* Tuple *)
       (* For now, we only support fully applied tuple constructors *)
-      assert (List.length type_args = List.length field_values);
-      assert (cg_args = []);
+      assert (List.length generics.types = List.length field_values);
+      assert (generics.const_generics = [] && generics.trait_refs = []);
       (* This is very annoying: in Coq, we can't write [()] for the value of
          type [unit], we have to write [tt]. *)
       if !backend = Coq && field_values = [] then (
@@ -2205,7 +2247,7 @@ let extract_adt_g_value
         in
         F.pp_print_string fmt ")";
         ctx)
-  | Adt (adt_id, _, _) ->
+  | Adt (adt_id, _) ->
       (* "Regular" ADT *)
 
       (* If we are generating a pattern for a let-binding and we target Lean,
@@ -2343,14 +2385,12 @@ and extract_App (ctx : extraction_ctx) (fmt : F.formatter) (inside : bool)
       (* Top-level qualifier *)
       match qualif.id with
       | FunOrOp fun_id ->
-          extract_function_call ctx fmt inside fun_id qualif.type_args
-            qualif.const_generic_args args
+          extract_function_call ctx fmt inside fun_id qualif.generics args
       | Global global_id -> extract_global ctx fmt global_id
       | AdtCons adt_cons_id ->
-          extract_adt_cons ctx fmt inside adt_cons_id qualif.type_args
-            qualif.const_generic_args args
+          extract_adt_cons ctx fmt inside adt_cons_id qualif.generics args
       | Proj proj ->
-          extract_field_projector ctx fmt inside app proj qualif.type_args args)
+          extract_field_projector ctx fmt inside app proj qualif.generics args)
   | _ ->
       (* "Regular" expression *)
       (* Open parentheses *)
@@ -2373,8 +2413,8 @@ and extract_App (ctx : extraction_ctx) (fmt : F.formatter) (inside : bool)
 
 (** Subcase of the app case: function call *)
 and extract_function_call (ctx : extraction_ctx) (fmt : F.formatter)
-    (inside : bool) (fid : fun_or_op_id) (type_args : ty list)
-    (cg_args : const_generic list) (args : texpression list) : unit =
+    (inside : bool) (fid : fun_or_op_id) (generics : generic_args)
+    (args : texpression list) : unit =
   match (fid, args) with
   | Unop unop, [ arg ] ->
       (* A unop can have *at most* one argument (the result can't be a function!).
@@ -2396,19 +2436,9 @@ and extract_function_call (ctx : extraction_ctx) (fmt : F.formatter)
       let fun_name = ctx_get_function with_opaque_pre fun_id ctx in
       F.pp_print_string fmt fun_name;
       (* Sanity check: HOL4 doesn't support const generics *)
-      assert (cg_args = [] || !backend <> HOL4);
-      (* Print the type parameters, if the backend is not HOL4 *)
-      if !backend <> HOL4 then (
-        List.iter
-          (fun ty ->
-            F.pp_print_space fmt ();
-            extract_ty ctx fmt TypeDeclId.Set.empty true ty)
-          type_args;
-        List.iter
-          (fun cg ->
-            F.pp_print_space fmt ();
-            extract_const_generic ctx fmt true cg)
-          cg_args);
+      assert (generics.const_generics = [] || !backend <> HOL4);
+      (* Print the generics *)
+      extract_generic_args ctx fmt TypeDeclId.Set.empty generics;
       (* Print the arguments *)
       List.iter
         (fun ve ->
@@ -2430,9 +2460,9 @@ and extract_function_call (ctx : extraction_ctx) (fmt : F.formatter)
 
 (** Subcase of the app case: ADT constructor *)
 and extract_adt_cons (ctx : extraction_ctx) (fmt : F.formatter) (inside : bool)
-    (adt_cons : adt_cons_id) (type_args : ty list)
-    (cg_args : const_generic list) (args : texpression list) : unit =
-  let e_ty = Adt (adt_cons.adt_id, type_args, cg_args) in
+    (adt_cons : adt_cons_id) (generics : generic_args) (args : texpression list)
+    : unit =
+  let e_ty = Adt (adt_cons.adt_id, generics) in
   let is_single_pat = false in
   let _ =
     extract_adt_g_value
@@ -2446,7 +2476,7 @@ and extract_adt_cons (ctx : extraction_ctx) (fmt : F.formatter) (inside : bool)
 (** Subcase of the app case: ADT field projector.  *)
 and extract_field_projector (ctx : extraction_ctx) (fmt : F.formatter)
     (inside : bool) (original_app : texpression) (proj : projection)
-    (_proj_type_params : ty list) (args : texpression list) : unit =
+    (_generics : generic_args) (args : texpression list) : unit =
   (* We isolate the first argument (if there is), in order to pretty print the
    * projection ([x.field] instead of [MkAdt?.field x] *)
   match args with
@@ -2905,11 +2935,11 @@ and extract_StructUpdate (ctx : extraction_ctx) (fmt : F.formatter)
         let cs = ctx_get_struct false (Assumed Array) ctx in
         F.pp_print_string fmt cs;
         (* Print the parameters *)
-        let _, tys, cgs = ty_as_adt e_ty in
-        let ty = Collections.List.to_cons_nil tys in
+        let _, generics = ty_as_adt e_ty in
+        let ty = Collections.List.to_cons_nil generics.types in
         F.pp_print_space fmt ();
         extract_ty ctx fmt TypeDeclId.Set.empty true ty;
-        let cg = Collections.List.to_cons_nil cgs in
+        let cg = Collections.List.to_cons_nil generics.const_generics in
         F.pp_print_space fmt ();
         extract_const_generic ctx fmt true cg;
         F.pp_print_space fmt ();
@@ -2936,10 +2966,6 @@ and extract_StructUpdate (ctx : extraction_ctx) (fmt : F.formatter)
         F.pp_close_box fmt ()
     | _ -> raise (Failure "Unreachable")
 
-(** Insert a space, if necessary *)
-let insert_req_space (fmt : F.formatter) (space : bool ref) : unit =
-  if !space then space := false else F.pp_print_space fmt ()
-
 (** A small utility to print the parameters of a function signature.
 
     We return two contexts:
@@ -2947,6 +2973,8 @@ let insert_req_space (fmt : F.formatter) (space : bool ref) : unit =
     - the context augmented with bindings for the type parameters *and*
       bindings for the input values
 
+    We also return names for the type parameters, const generics, etc.
+
     TODO: do we really need the first one? We should probably always use
     the second one.
     It comes from the fact that when we print the input values for the
@@ -2954,57 +2982,22 @@ let insert_req_space (fmt : F.formatter) (space : bool ref) : unit =
     patterns, not the variables). We should figure a cleaner way.
  *)
 let extract_fun_parameters (space : bool ref) (ctx : extraction_ctx)
-    (fmt : F.formatter) (def : fun_decl) : extraction_ctx * extraction_ctx =
+    (fmt : F.formatter) (def : fun_decl) :
+    extraction_ctx * extraction_ctx * string list =
   (* Add the type parameters - note that we need those bindings only for the
    * body translation (they are not top-level) *)
-  let ctx, type_params, cg_params =
-    ctx_add_type_const_generic_params def.signature.type_params
-      def.signature.const_generic_params ctx
+  let ctx, type_params, cg_params, trait_clauses =
+    ctx_add_generic_params def.signature.generics ctx
   in
-  (* Print the parameters - rem.: we should have filtered the functions
-   * with no input parameters *)
-  (* The type parameters.
-
-     Note that in HOL4 we don't print the type parameters.
-  *)
-  if (type_params <> [] || cg_params <> []) && !backend <> HOL4 then (
-    (* Open a box for the type and const generic parameters *)
-    F.pp_open_hovbox fmt 0;
-    (* The type parameters *)
-    if type_params <> [] then (
-      insert_req_space fmt space;
-      F.pp_print_string fmt "(";
-      List.iter
-        (fun (p : type_var) ->
-          let pname = ctx_get_type_var p.index ctx in
-          F.pp_print_string fmt pname;
-          F.pp_print_space fmt ())
-        def.signature.type_params;
-      F.pp_print_string fmt ":";
-      F.pp_print_space fmt ();
-      let type_keyword =
-        match !backend with
-        | FStar -> "Type0"
-        | Coq | Lean -> "Type"
-        | HOL4 -> raise (Failure "Unreachable")
-      in
-      F.pp_print_string fmt (type_keyword ^ ")"));
-    (* The const generic parameters *)
-    if cg_params <> [] then
-      List.iter
-        (fun (p : const_generic_var) ->
-          let pname = ctx_get_const_generic_var p.index ctx in
-          insert_req_space fmt space;
-          F.pp_print_string fmt "(";
-          F.pp_print_string fmt pname;
-          F.pp_print_space fmt ();
-          F.pp_print_string fmt ":";
-          F.pp_print_space fmt ();
-          extract_literal_type ctx fmt p.ty;
-          F.pp_print_string fmt ")")
-        def.signature.const_generic_params;
-    (* Close the box for the type parameters *)
-    F.pp_close_box fmt ());
+  (* Print the generics *)
+  (* Open a box for the generics *)
+  F.pp_open_hovbox fmt 0;
+  let use_forall = false in
+  let as_implicits = false in
+  extract_generic_params ctx fmt TypeDeclId.Set.empty use_forall as_implicits
+    (Some space) def.signature.generics type_params cg_params trait_clauses;
+  (* Close the box for the generics *)
+  F.pp_close_box fmt ();
   (* The input parameters - note that doing this adds bindings to the context *)
   let ctx_body =
     match def.body with
@@ -3027,7 +3020,7 @@ let extract_fun_parameters (space : bool ref) (ctx : extraction_ctx)
             ctx)
           ctx body.inputs_lvs
   in
-  (ctx, ctx_body)
+  (ctx, ctx_body, List.concat [ type_params; cg_params; trait_clauses ])
 
 (** A small utility to print the types of the input parameters in the form:
     [u32 -> list u32 -> ...]
@@ -3096,7 +3089,7 @@ let extract_template_fstar_decreases_clause (ctx : extraction_ctx)
   F.pp_print_space fmt ();
   (* Extract the parameters *)
   let space = ref true in
-  let _, _ = extract_fun_parameters space ctx fmt def in
+  let _, _, _ = extract_fun_parameters space ctx fmt def in
   insert_req_space fmt space;
   F.pp_print_string fmt ":";
   (* Print the signature *)
@@ -3158,7 +3151,7 @@ let extract_template_lean_termination_and_decreasing (ctx : extraction_ctx)
   F.pp_print_space fmt ();
   (* Extract the parameters *)
   let space = ref true in
-  let _, ctx_body = extract_fun_parameters space ctx fmt def in
+  let _, ctx_body, _ = extract_fun_parameters space ctx fmt def in
   (* Print the ":=" *)
   F.pp_print_space fmt ();
   F.pp_print_string fmt ":=";
@@ -3298,9 +3291,7 @@ let extract_fun_decl_gen (ctx : extraction_ctx) (fmt : F.formatter)
   *)
   let is_opaque_coq = !backend = Coq && is_opaque in
   let use_forall =
-    is_opaque_coq
-    && (def.signature.type_params <> []
-       || def.signature.const_generic_params <> [])
+    is_opaque_coq && def.signature.generics <> empty_generic_params
   in
   (* Print the qualifier ("assume", etc.).
 
@@ -3326,7 +3317,7 @@ let extract_fun_decl_gen (ctx : extraction_ctx) (fmt : F.formatter)
   (* Open a box for "(PARAMS) :" *)
   F.pp_open_hovbox fmt 0;
   let space = ref true in
-  let ctx, ctx_body = extract_fun_parameters space ctx fmt def in
+  let ctx, ctx_body, all_params = extract_fun_parameters space ctx fmt def in
   (* Print the return type - note that we have to be careful when
    * printing the input values for the decrease clause, because
    * it introduces bindings in the context... We thus "forget"
@@ -3374,20 +3365,13 @@ let extract_fun_decl_gen (ctx : extraction_ctx) (fmt : F.formatter)
       (* The name of the decrease clause *)
       let decr_name = ctx_get_termination_measure def.def_id def.loop_id ctx in
       F.pp_print_string fmt decr_name;
-      (* Print the type/const generic parameters - TODO: we do this many
+      (* Print the generic parameters - TODO: we do this many
          times, we should have a helper to factor it out *)
       List.iter
-        (fun (p : type_var) ->
-          let pname = ctx_get_type_var p.index ctx in
-          F.pp_print_space fmt ();
-          F.pp_print_string fmt pname)
-        def.signature.type_params;
-      List.iter
-        (fun (p : const_generic_var) ->
-          let pname = ctx_get_const_generic_var p.index ctx in
+        (fun (name : string) ->
           F.pp_print_space fmt ();
-          F.pp_print_string fmt pname)
-        def.signature.const_generic_params;
+          F.pp_print_string fmt name)
+        all_params;
       (* Print the input values: we have to be careful here to print
        * only the input values which are in common with the *forward*
        * function (the additional input values "given back" to the
@@ -3474,19 +3458,12 @@ let extract_fun_decl_gen (ctx : extraction_ctx) (fmt : F.formatter)
     (* Open the box for [DECREASES] *)
     F.pp_open_hovbox fmt ctx.indent_incr;
     F.pp_print_string fmt terminates_name;
-    (* Print the type/const generic params - TODO: factor out *)
+    (* Print the generic params - TODO: factor out *)
     List.iter
-      (fun (p : type_var) ->
-        let pname = ctx_get_type_var p.index ctx in
+      (fun (name : string) ->
         F.pp_print_space fmt ();
-        F.pp_print_string fmt pname)
-      def.signature.type_params;
-    List.iter
-      (fun (p : const_generic_var) ->
-        let pname = ctx_get_const_generic_var p.index ctx in
-        F.pp_print_space fmt ();
-        F.pp_print_string fmt pname)
-      def.signature.const_generic_params;
+        F.pp_print_string fmt name)
+      all_params;
     (* Print the variables *)
     List.iter
       (fun v ->
@@ -3544,13 +3521,10 @@ let extract_fun_decl_hol4_opaque (ctx : extraction_ctx) (fmt : F.formatter)
     ctx_get_local_function with_opaque_pre def.def_id def.loop_id def.back_id
       ctx
   in
-  assert (def.signature.const_generic_params = []);
+  assert (def.signature.generics.const_generics = []);
   (* Add the type/const gen parameters - note that we need those bindings
      only for the generation of the type (they are not top-level) *)
-  let ctx, _, _ =
-    ctx_add_type_const_generic_params def.signature.type_params
-      def.signature.const_generic_params ctx
-  in
+  let ctx, _, _, _ = ctx_add_generic_params def.signature.generics ctx in
   (* Add breaks to insert new lines between definitions *)
   F.pp_print_break fmt 0 0;
   (* Open a box for the whole definition *)
@@ -3726,10 +3700,9 @@ let extract_global_decl (ctx : extraction_ctx) (fmt : F.formatter)
     (global : A.global_decl) (body : fun_decl) (interface : bool) : unit =
   assert body.is_global_decl_body;
   assert (Option.is_none body.back_id);
-  assert (List.length body.signature.inputs = 0);
+  assert (body.signature.inputs = []);
   assert (List.length body.signature.doutputs = 1);
-  assert (List.length body.signature.type_params = 0);
-  assert (List.length body.signature.const_generic_params = 0);
+  assert (body.signature.generics = empty_generic_params);
 
   (* Add a break then the name of the corresponding LLBC declaration *)
   F.pp_print_break fmt 0 0;
@@ -3799,8 +3772,7 @@ let extract_unit_test_if_unit_fun (ctx : extraction_ctx) (fmt : F.formatter)
   (* Check if this is a unit function *)
   let sg = def.signature in
   if
-    sg.type_params = []
-    && sg.const_generic_params = []
+    sg.generics = empty_generic_params
     && (sg.inputs = [ mk_unit_ty ] || sg.inputs = [])
     && sg.output = mk_result_ty mk_unit_ty
   then (
diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index 96ecfd42..2c704d3e 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -111,10 +111,10 @@ let decl_is_first_from_group (kind : decl_kind) : bool =
 let decl_is_not_last_from_group (kind : decl_kind) : bool =
   not (decl_is_last_from_group kind)
 
-(* TODO: this should a module we give to a functor! *)
-
 type type_decl_kind = Enum | Struct
 
+(* TODO: this should be a module we give to a functor! *)
+
 (** A formatter's role is twofold:
     1. Come up with name suggestions.
     For instance, provided some information about a function (its basename,
@@ -125,6 +125,9 @@ type type_decl_kind = Enum | Struct
     snake case, adding prefixes/suffixes, etc.
 
     2. Format some specific terms, like constants.
+
+    TODO: unclear that this is useful now that all the backends are so much
+    entangled in Extract.ml
  *)
 type formatter = {
   bool_name : string;
@@ -288,6 +291,13 @@ type formatter = {
       (** Generates a type variable basename. *)
   const_generic_var_basename : StringSet.t -> string -> string;
       (** Generates a const generic variable basename. *)
+  trait_clause_basename : StringSet.t -> trait_clause -> string;
+      (** Return a base name for a trait clause. We might add a suffix to prevent
+          collisions.
+
+          In the traduction we explicitely manipulate the trait clause instances,
+          that is we introduce one input variable for each trait clause.
+       *)
   append_index : string -> int -> string;
       (** Appends an index to a name - we use this to generate unique
           names: when doing so, the role of the formatter is just to concatenate
@@ -396,6 +406,9 @@ type id =
   | TypeVarId of TypeVarId.id
   | ConstGenericVarId of ConstGenericVarId.id
   | VarId of VarId.id
+  | TraitDeclId of TraitDeclId.id
+  | TraitImplId of TraitImplId.id
+  | TraitClauseId of TraitClauseId.id
   | UnknownId
       (** Used for stored various strings like keywords, definitions which
           should always be in context, etc. and which can't be linked to one
@@ -718,6 +731,9 @@ let id_to_string (id : id) (ctx : extraction_ctx) : string =
   | ConstGenericVarId id ->
       "const_generic_var_id: " ^ ConstGenericVarId.to_string id
   | VarId id -> "var_id: " ^ VarId.to_string id
+  | TraitDeclId id -> "trait_decl_id: " ^ TraitDeclId.to_string id
+  | TraitImplId id -> "trait_impl_id: " ^ TraitImplId.to_string id
+  | TraitClauseId id -> "trait_clause_id: " ^ TraitClauseId.to_string id
 
 (** We might not check for collisions for some specific ids (ex.: field names) *)
 let allow_collisions (id : id) : bool =
@@ -787,6 +803,14 @@ let ctx_get_assumed_type (id : assumed_ty) (ctx : extraction_ctx) : string =
   let is_opaque = false in
   ctx_get_type is_opaque (Assumed id) ctx
 
+let ctx_get_trait_decl (with_opaque_pre : bool) (id : trait_decl_id)
+    (ctx : extraction_ctx) : string =
+  ctx_get with_opaque_pre (TraitDeclId id) ctx
+
+let ctx_get_trait_impl (with_opaque_pre : bool) (id : trait_impl_id)
+    (ctx : extraction_ctx) : string =
+  ctx_get with_opaque_pre (TraitImplId id) ctx
+
 let ctx_get_var (id : VarId.id) (ctx : extraction_ctx) : string =
   let is_opaque = false in
   ctx_get is_opaque (VarId id) ctx
@@ -800,6 +824,11 @@ let ctx_get_const_generic_var (id : ConstGenericVarId.id) (ctx : extraction_ctx)
   let is_opaque = false in
   ctx_get is_opaque (ConstGenericVarId id) ctx
 
+let ctx_get_trait_clause_var (id : TraitClauseId.id) (ctx : extraction_ctx) :
+    string =
+  let is_opaque = false in
+  ctx_get is_opaque (TraitClauseId id) ctx
+
 let ctx_get_field (type_id : type_id) (field_id : FieldId.id)
     (ctx : extraction_ctx) : string =
   let is_opaque = false in
@@ -865,6 +894,16 @@ let ctx_add_var (basename : string) (id : VarId.id) (ctx : extraction_ctx) :
   let ctx = ctx_add is_opaque (VarId id) name ctx in
   (ctx, name)
 
+(** Generate a unique trait clause name and add it to the context *)
+let ctx_add_trait_clause (basename : string) (id : TraitClauseId.id)
+    (ctx : extraction_ctx) : extraction_ctx * string =
+  let is_opaque = false in
+  let name =
+    basename_to_unique ctx.names_map.names_set ctx.fmt.append_index basename
+  in
+  let ctx = ctx_add is_opaque (TraitClauseId id) name ctx in
+  (ctx, name)
+
 (** See {!ctx_add_var} *)
 let ctx_add_vars (vars : var list) (ctx : extraction_ctx) :
     extraction_ctx * string list =
@@ -890,7 +929,9 @@ let ctx_add_const_generic_params (vars : const_generic_var list)
 let ctx_add_trait_clauses (clauses : trait_clause list) (ctx : extraction_ctx) :
     extraction_ctx * string list =
   List.fold_left_map
-    (fun ctx (c : trait_clause) -> ctx_add_trait_clause c ctx)
+    (fun ctx (c : trait_clause) ->
+      let basename = ctx.fmt.trait_clause_basename ctx.names_map.names_set c in
+      ctx_add_trait_clause basename c.clause_id ctx)
     ctx clauses
 
 (** Returns the lists of names for:
-- 
cgit v1.3.1


From 4cf1217f593b46a17130403df85b5f39f9e3eb85 Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Sun, 3 Sep 2023 10:04:14 +0200
Subject: Improve the collision detection

---
 compiler/ExtractBase.ml | 70 ++++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 54 insertions(+), 16 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index 2c704d3e..02ff266e 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -458,21 +458,34 @@ type names_map = {
        *)
 }
 
-let names_map_add (id_to_string : id -> string) (is_opaque : bool) (id : id)
-    (name : string) (nm : names_map) : names_map =
-  (* Check if there is a clash *)
-  (match StringMap.find_opt name nm.name_to_id with
+(** Small helper to report name collision *)
+let report_name_collision (id_to_string : id -> string) (id1 : id) (id2 : id)
+    (name : string) : unit =
+  let id1 = "\n- " ^ id_to_string id1 in
+  let id2 = "\n- " ^ id_to_string id2 in
+  let err =
+    "Name clash detected: the following identifiers are bound to the same name \
+     \"" ^ name ^ "\":" ^ id1 ^ id2
+    ^ "\nYou may want to rename some of your definitions, or report an issue."
+  in
+  log#serror err;
+  raise (Failure err)
+
+let names_map_get_id_from_name (name : string) (nm : names_map) : id option =
+  StringMap.find_opt name nm.name_to_id
+
+let names_map_check_collision (id_to_string : id -> string) (id : id)
+    (name : string) (nm : names_map) : unit =
+  match names_map_get_id_from_name name nm with
   | None -> () (* Ok *)
   | Some clash ->
       (* There is a clash: print a nice debugging message for the user *)
-      let id1 = "\n- " ^ id_to_string clash in
-      let id2 = "\n- " ^ id_to_string id in
-      let err =
-        "Name clash detected: the following identifiers are bound to the same \
-         name \"" ^ name ^ "\":" ^ id1 ^ id2
-      in
-      log#serror err;
-      raise (Failure err));
+      report_name_collision id_to_string clash id name
+
+let names_map_add (id_to_string : id -> string) (is_opaque : bool) (id : id)
+    (name : string) (nm : names_map) : names_map =
+  (* Check if there is a clash *)
+  names_map_check_collision id_to_string id name nm;
   (* Sanity check *)
   assert (not (StringSet.mem name nm.names_set));
   (* Insert *)
@@ -743,17 +756,42 @@ let allow_collisions (id : id) : bool =
 
 let ctx_add (is_opaque : bool) (id : id) (name : string) (ctx : extraction_ctx)
     : extraction_ctx =
-  (* We do not use the same name map if we allow/disallow collisions *)
+  (* The id_to_string function to print nice debugging messages if there are
+   * collisions *)
+  let id_to_string (id : id) : string = id_to_string id ctx in
+  (* We do not use the same name map if we allow/disallow collisions.
+     We notably use it for field names: some backends like Lean can use the
+     type information to disambiguate field projections.
+
+     Remark: what we do is actually subtle. Taking the example of fields:
+     - we allow fields from different ADT definitions to collide
+     - we do *not* allow field names to collide with other names
+     For instance, we don't allow naming a field "let". We enforce this by
+     not checking collision between ids for which we permit collisions (ex.:
+     between fields), but still checking collisions between those ids and the
+     others (ex.: fields and keywords).
+  *)
   if allow_collisions id then (
     assert (not is_opaque);
+    (* Check with the other ids *)
+    names_map_check_collision id_to_string id name ctx.names_map;
     {
       ctx with
       unsafe_names_map = unsafe_names_map_add id name ctx.unsafe_names_map;
     })
   else
-    (* The id_to_string function to print nice debugging messages if there are
-     * collisions *)
-    let id_to_string (id : id) : string = id_to_string id ctx in
+    (* Remark: we don't check that there are no collisions with the unsafe ids.
+       Importantly, we don't want some safe ids like keywords to clash with
+       unsafe ids like fields names. For this, we leverage the fact that we register
+       keywords *first*, then unsafe ids (meaning the clash will be detected with
+       the check in the other branch of the if ... then ... else ..., and we do
+       have to check for all possible collisions, which may be slightly too
+       restrictive).
+
+       TODO: this is a bit hacky, we might want to improve the way we detect
+       clashes by being more precise. Overall, there is only an issue with
+       field names which are allowed to clash with each other.
+    *)
     let names_map =
       names_map_add id_to_string is_opaque id name ctx.names_map
     in
-- 
cgit v1.3.1


From 0cafb31dd42c95f22e0b6680531c27fa0508e376 Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Sun, 3 Sep 2023 13:32:43 +0200
Subject: Make progress on the extraction

---
 compiler/AssociatedTypes.ml | 10 +++---
 compiler/Extract.ml         | 76 +++++++++++++++++++++++++++++----------------
 compiler/ExtractBase.ml     | 57 ++++++++++++++++++++++++++++------
 compiler/PrintPure.ml       |  4 +--
 compiler/Pure.ml            | 16 ++++++++--
 compiler/SymbolicToPure.ml  | 27 ++++++++++++----
 6 files changed, 138 insertions(+), 52 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/compiler/AssociatedTypes.ml b/compiler/AssociatedTypes.ml
index 07ab70bd..c4a9538d 100644
--- a/compiler/AssociatedTypes.ml
+++ b/compiler/AssociatedTypes.ml
@@ -100,7 +100,7 @@ let rec trait_instance_id_is_local_clause (id : 'r T.trait_instance_id) : bool =
   match id with
   | T.Self | Clause _ -> true
   | TraitImpl _ | BuiltinOrAuto _ | TraitRef _ | UnknownTrait _ -> false
-  | ParentClause (id, _) | ItemClause (id, _, _) ->
+  | ParentClause (id, _, _) | ItemClause (id, _, _, _) ->
       trait_instance_id_is_local_clause id
 
 (** About the conversion functions: for now we need them (TODO: merge ety, rty, etc.),
@@ -212,14 +212,14 @@ and ctx_normalize_trait_instance_id :
       (id, None)
   | Clause _ -> (id, None)
   | BuiltinOrAuto _ -> (id, None)
-  | ParentClause (inst_id, clause_id) -> (
+  | ParentClause (inst_id, decl_id, clause_id) -> (
       let inst_id, impl = ctx_normalize_trait_instance_id ctx inst_id in
       (* Check if the inst_id refers to a specific implementation, if yes project *)
       match impl with
       | None ->
           (* This is actually a local clause *)
           assert (trait_instance_id_is_local_clause inst_id);
-          (ParentClause (inst_id, clause_id), None)
+          (ParentClause (inst_id, decl_id, clause_id), None)
       | Some impl ->
           (* We figure out the parent clause by doing the following:
              {[
@@ -243,14 +243,14 @@ and ctx_normalize_trait_instance_id :
           (* Sanity check: the clause necessarily refers to an impl *)
           let _ = TypesUtils.trait_instance_id_as_trait_impl clause.trait_id in
           (TraitRef clause, Some clause))
-  | ItemClause (inst_id, item_name, clause_id) -> (
+  | ItemClause (inst_id, decl_id, item_name, clause_id) -> (
       let inst_id, impl = ctx_normalize_trait_instance_id ctx inst_id in
       (* Check if the inst_id refers to a specific implementation, if yes project *)
       match impl with
       | None ->
           (* This is actually a local clause *)
           assert (trait_instance_id_is_local_clause inst_id);
-          (ParentClause (inst_id, clause_id), None)
+          (ParentClause (inst_id, decl_id, clause_id), None)
       | Some impl ->
           (* We figure out the item clause by doing the following:
              {[
diff --git a/compiler/Extract.ml b/compiler/Extract.ml
index 3c4feca5..ad89a59e 100644
--- a/compiler/Extract.ml
+++ b/compiler/Extract.ml
@@ -1223,23 +1223,29 @@ let rec extract_ty (ctx : extraction_ctx) (fmt : F.formatter)
       if inside then F.pp_print_string fmt ")"
   | TraitType (trait_ref, generics, type_name) ->
       if !parameterize_trait_types then raise (Failure "Unimplemented")
-      else (
+      else if trait_ref.trait_id <> Self then (
         (* HOL4 doesn't have 1st class types *)
         assert (!backend <> HOL4);
-        if trait_ref.trait_id <> Self then (
-          F.pp_print_string fmt "(";
-          extract_trait_ref ctx fmt no_params_tys false trait_ref;
-          extract_generic_args ctx fmt no_params_tys generics;
-          (* TODO: lookup the type name *)
-          F.pp_print_string fmt (")." ^ type_name))
-        else
-          (* Can only happen when extracting the signature of a trait method
-             *declaration*. If extracting items for a trait method implementation,
-             the type should have been normalized. For trait method declarations
-             we directly reference the item. *)
-          let trait_decl_id = Option.get ctx.trait_decl_id in
-          assert (generics = empty_generic_args);
-          F.pp_print_string fmt type_name)
+        let use_brackets = generics <> empty_generic_args in
+        if use_brackets then F.pp_print_string fmt "(";
+        extract_trait_ref ctx fmt no_params_tys false trait_ref;
+        extract_generic_args ctx fmt no_params_tys generics;
+        let name =
+          ctx_get_trait_assoc_type trait_ref.trait_decl_ref.trait_decl_id
+            type_name ctx
+        in
+        if use_brackets then F.pp_print_string fmt ")";
+        F.pp_print_string fmt ("." ^ name))
+      else
+        (* Can only happen when extracting the signature of a trait method
+           *declaration* or a provided trait method (for a declaration).
+           If extracting items for a trait method implementation,
+           the type should have been normalized. For trait method declarations
+           we directly reference the item. *)
+        assert (ctx.trait_decl_id <> None);
+      assert (generics = empty_generic_args);
+      let name = ctx_get_local_trait_assoc_type type_name ctx in
+      F.pp_print_string fmt name
 
 and extract_trait_ref (ctx : extraction_ctx) (fmt : F.formatter)
     (no_params_tys : TypeDeclId.Set.t) (inside : bool) (tr : trait_ref) : unit =
@@ -1270,17 +1276,35 @@ and extract_generic_args (ctx : extraction_ctx) (fmt : F.formatter)
       (extract_trait_ref ctx fmt no_params_tys true)
       trait_refs)
 
-and extract_trait_instance_id (_ctx : extraction_ctx) (_fmt : F.formatter)
-    (_no_params_tys : TypeDeclId.Set.t) (_inside : bool)
-    (id : trait_instance_id) : unit =
+and extract_trait_instance_id (ctx : extraction_ctx) (fmt : F.formatter)
+    (no_params_tys : TypeDeclId.Set.t) (inside : bool) (id : trait_instance_id)
+    : unit =
+  let with_opaque_pre = false in
   match id with
-  | Self -> raise (Failure "TODO")
-  | TraitImpl _ -> raise (Failure "TODO")
-  | Clause _ -> raise (Failure "TODO")
-  | ParentClause _ -> raise (Failure "TODO")
-  | ItemClause _ -> raise (Failure "TODO")
-  | TraitRef _ -> raise (Failure "TODO")
-  | UnknownTrait _ -> raise (Failure "TODO")
+  | Self ->
+      (* This has specific treatment depending on the item we're extracting
+         (associated type, etc.). We should have caught this elsewhere. *)
+      raise (Failure "Unexpected")
+  | TraitImpl id ->
+      let name = ctx_get_trait_impl with_opaque_pre id ctx in
+      F.pp_print_string fmt name
+  | Clause id ->
+      let name = ctx_get_local_trait_clause id ctx in
+      F.pp_print_string fmt name
+  | ParentClause (inst_id, decl_id, clause_id) ->
+      (* Use the trait decl id to lookup the name *)
+      let name = ctx_get_trait_parent_clause decl_id clause_id ctx in
+      extract_trait_instance_id ctx fmt no_params_tys true inst_id;
+      F.pp_print_string fmt ("." ^ name)
+  | ItemClause (inst_id, decl_id, item_name, clause_id) ->
+      (* Use the trait decl id to lookup the name *)
+      let name = ctx_get_trait_item_clause decl_id item_name clause_id ctx in
+      extract_trait_instance_id ctx fmt no_params_tys true inst_id;
+      F.pp_print_string fmt ("." ^ name)
+  | TraitRef trait_ref -> extract_trait_ref ctx fmt no_params_tys true trait_ref
+  | UnknownTrait _ ->
+      (* This is an error case *)
+      raise (Failure "Unexpected")
 
 (** Compute the names for all the top-level identifiers used in a type
     definition (type name, variant names, field names, etc. but not type
@@ -1673,7 +1697,7 @@ let extract_generic_params (ctx : extraction_ctx) (fmt : F.formatter)
         insert_req_space ();
         (* ( *)
         left_bracket ();
-        let n = ctx_get_trait_clause_var clause.clause_id ctx in
+        let n = ctx_get_local_trait_clause clause.clause_id ctx in
         F.pp_print_string fmt n;
         F.pp_print_space fmt ();
         F.pp_print_string fmt ":";
diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index 02ff266e..697b1027 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -408,7 +408,11 @@ type id =
   | VarId of VarId.id
   | TraitDeclId of TraitDeclId.id
   | TraitImplId of TraitImplId.id
-  | TraitClauseId of TraitClauseId.id
+  | LocalTraitClauseId of TraitClauseId.id
+  | LocalTraitAssocTypeId of string  (** Specifically for: [Self::Ty] *)
+  | TraitAssocTypeId of TraitDeclId.id * string  (** A trait associated type *)
+  | TraitParentClauseId of TraitDeclId.id * TraitClauseId.id
+  | TraitItemClauseId of TraitDeclId.id * string * TraitClauseId.id
   | UnknownId
       (** Used for stored various strings like keywords, definitions which
           should always be in context, etc. and which can't be linked to one
@@ -746,7 +750,20 @@ let id_to_string (id : id) (ctx : extraction_ctx) : string =
   | VarId id -> "var_id: " ^ VarId.to_string id
   | TraitDeclId id -> "trait_decl_id: " ^ TraitDeclId.to_string id
   | TraitImplId id -> "trait_impl_id: " ^ TraitImplId.to_string id
-  | TraitClauseId id -> "trait_clause_id: " ^ TraitClauseId.to_string id
+  | LocalTraitClauseId id ->
+      "local_trait_clause_id: " ^ TraitClauseId.to_string id
+  | LocalTraitAssocTypeId type_name -> "local_trait_assoc_type_id: " ^ type_name
+  | TraitParentClauseId (id, clause_id) ->
+      "trait_parent_clause_id: decl_id:" ^ TraitDeclId.to_string id
+      ^ ", clause_id: "
+      ^ TraitClauseId.to_string clause_id
+  | TraitItemClauseId (id, item_name, clause_id) ->
+      "trait_item_clause_id: decl_id:" ^ TraitDeclId.to_string id
+      ^ ", item name: " ^ item_name ^ ", clause_id: "
+      ^ TraitClauseId.to_string clause_id
+  | TraitAssocTypeId (id, type_name) ->
+      "trait_assoc_type_id: decl_id:" ^ TraitDeclId.to_string id
+      ^ ", type name: " ^ type_name
 
 (** We might not check for collisions for some specific ids (ex.: field names) *)
 let allow_collisions (id : id) : bool =
@@ -849,6 +866,26 @@ let ctx_get_trait_impl (with_opaque_pre : bool) (id : trait_impl_id)
     (ctx : extraction_ctx) : string =
   ctx_get with_opaque_pre (TraitImplId id) ctx
 
+let ctx_get_trait_assoc_type (id : trait_decl_id) (type_name : string)
+    (ctx : extraction_ctx) : string =
+  let is_opaque = false in
+  ctx_get is_opaque (TraitAssocTypeId (id, type_name)) ctx
+
+let ctx_get_local_trait_assoc_type (type_name : string) (ctx : extraction_ctx) :
+    string =
+  let is_opaque = false in
+  ctx_get is_opaque (LocalTraitAssocTypeId type_name) ctx
+
+let ctx_get_trait_parent_clause (id : trait_decl_id) (clause : trait_clause_id)
+    (ctx : extraction_ctx) : string =
+  let with_opaque_pre = false in
+  ctx_get with_opaque_pre (TraitParentClauseId (id, clause)) ctx
+
+let ctx_get_trait_item_clause (id : trait_decl_id) (item : string)
+    (clause : trait_clause_id) (ctx : extraction_ctx) : string =
+  let with_opaque_pre = false in
+  ctx_get with_opaque_pre (TraitItemClauseId (id, item, clause)) ctx
+
 let ctx_get_var (id : VarId.id) (ctx : extraction_ctx) : string =
   let is_opaque = false in
   ctx_get is_opaque (VarId id) ctx
@@ -862,10 +899,10 @@ let ctx_get_const_generic_var (id : ConstGenericVarId.id) (ctx : extraction_ctx)
   let is_opaque = false in
   ctx_get is_opaque (ConstGenericVarId id) ctx
 
-let ctx_get_trait_clause_var (id : TraitClauseId.id) (ctx : extraction_ctx) :
+let ctx_get_local_trait_clause (id : TraitClauseId.id) (ctx : extraction_ctx) :
     string =
   let is_opaque = false in
-  ctx_get is_opaque (TraitClauseId id) ctx
+  ctx_get is_opaque (LocalTraitClauseId id) ctx
 
 let ctx_get_field (type_id : type_id) (field_id : FieldId.id)
     (ctx : extraction_ctx) : string =
@@ -933,13 +970,13 @@ let ctx_add_var (basename : string) (id : VarId.id) (ctx : extraction_ctx) :
   (ctx, name)
 
 (** Generate a unique trait clause name and add it to the context *)
-let ctx_add_trait_clause (basename : string) (id : TraitClauseId.id)
+let ctx_add_local_trait_clause (basename : string) (id : TraitClauseId.id)
     (ctx : extraction_ctx) : extraction_ctx * string =
   let is_opaque = false in
   let name =
     basename_to_unique ctx.names_map.names_set ctx.fmt.append_index basename
   in
-  let ctx = ctx_add is_opaque (TraitClauseId id) name ctx in
+  let ctx = ctx_add is_opaque (LocalTraitClauseId id) name ctx in
   (ctx, name)
 
 (** See {!ctx_add_var} *)
@@ -964,12 +1001,12 @@ let ctx_add_const_generic_params (vars : const_generic_var list)
       ctx_add_const_generic_var var.name var.index ctx)
     ctx vars
 
-let ctx_add_trait_clauses (clauses : trait_clause list) (ctx : extraction_ctx) :
-    extraction_ctx * string list =
+let ctx_add_local_trait_clauses (clauses : trait_clause list)
+    (ctx : extraction_ctx) : extraction_ctx * string list =
   List.fold_left_map
     (fun ctx (c : trait_clause) ->
       let basename = ctx.fmt.trait_clause_basename ctx.names_map.names_set c in
-      ctx_add_trait_clause basename c.clause_id ctx)
+      ctx_add_local_trait_clause basename c.clause_id ctx)
     ctx clauses
 
 (** Returns the lists of names for:
@@ -982,7 +1019,7 @@ let ctx_add_generic_params (generics : generic_params) (ctx : extraction_ctx) :
   let { types; const_generics; trait_clauses } = generics in
   let ctx, tys = ctx_add_type_params types ctx in
   let ctx, cgs = ctx_add_const_generic_params const_generics ctx in
-  let ctx, tcs = ctx_add_trait_clauses trait_clauses ctx in
+  let ctx, tcs = ctx_add_local_trait_clauses trait_clauses ctx in
   (ctx, tys, cgs, tcs)
 
 let ctx_add_type_decl_struct (def : type_decl) (ctx : extraction_ctx) :
diff --git a/compiler/PrintPure.ml b/compiler/PrintPure.ml
index 77d25823..fc39074d 100644
--- a/compiler/PrintPure.ml
+++ b/compiler/PrintPure.ml
@@ -273,11 +273,11 @@ and trait_instance_id_to_string (fmt : type_formatter) (inside : bool)
   | Self -> "Self"
   | TraitImpl id -> fmt.trait_impl_id_to_string id
   | Clause id -> fmt.trait_clause_id_to_string id
-  | ParentClause (inst_id, clause_id) ->
+  | ParentClause (inst_id, _decl_id, clause_id) ->
       let inst_id = trait_instance_id_to_string fmt false inst_id in
       let clause_id = fmt.trait_clause_id_to_string clause_id in
       "parent(" ^ inst_id ^ ")::" ^ clause_id
-  | ItemClause (inst_id, item_name, clause_id) ->
+  | ItemClause (inst_id, _decl_id, item_name, clause_id) ->
       let inst_id = trait_instance_id_to_string fmt false inst_id in
       let clause_id = fmt.trait_clause_id_to_string clause_id in
       "(" ^ inst_id ^ ")::" ^ item_name ^ "::[" ^ clause_id ^ "]"
diff --git a/compiler/Pure.ml b/compiler/Pure.ml
index 272ec328..725f71ad 100644
--- a/compiler/Pure.ml
+++ b/compiler/Pure.ml
@@ -276,7 +276,16 @@ type ty =
   | TraitType of trait_ref * generic_args * string
       (** The string is for the name of the associated type *)
 
-and trait_ref = { trait_id : trait_instance_id; generics : generic_args }
+and trait_ref = {
+  trait_id : trait_instance_id;
+  generics : generic_args;
+  trait_decl_ref : trait_decl_ref;
+}
+
+and trait_decl_ref = {
+  trait_decl_id : trait_decl_id;
+  decl_generics : generic_args; (* The name: annoying field collisions... *)
+}
 
 and generic_args = {
   types : ty list;
@@ -288,8 +297,9 @@ and trait_instance_id =
   | Self
   | TraitImpl of trait_impl_id
   | Clause of trait_clause_id
-  | ParentClause of trait_instance_id * trait_clause_id
-  | ItemClause of trait_instance_id * trait_item_name * trait_clause_id
+  | ParentClause of trait_instance_id * trait_decl_id * trait_clause_id
+  | ItemClause of
+      trait_instance_id * trait_decl_id * trait_item_name * trait_clause_id
   | TraitRef of trait_ref
   | UnknownTrait of string
 [@@deriving
diff --git a/compiler/SymbolicToPure.ml b/compiler/SymbolicToPure.ml
index c827475b..166f08a0 100644
--- a/compiler/SymbolicToPure.ml
+++ b/compiler/SymbolicToPure.ml
@@ -393,7 +393,15 @@ and translate_trait_ref (translate_ty : 'r T.ty -> ty) (tr : 'r T.trait_ref) :
     trait_ref =
   let trait_id = translate_trait_instance_id translate_ty tr.trait_id in
   let generics = translate_generic_args translate_ty tr.generics in
-  { trait_id; generics }
+  let trait_decl_ref =
+    translate_trait_decl_ref translate_ty tr.trait_decl_ref
+  in
+  { trait_id; generics; trait_decl_ref }
+
+and translate_trait_decl_ref (translate_ty : 'r T.ty -> ty)
+    (tr : 'r T.trait_decl_ref) : trait_decl_ref =
+  let decl_generics = translate_generic_args translate_ty tr.decl_generics in
+  { trait_decl_id = tr.trait_decl_id; decl_generics }
 
 and translate_trait_instance_id (translate_ty : 'r T.ty -> ty)
     (id : 'r T.trait_instance_id) : trait_instance_id =
@@ -405,12 +413,12 @@ and translate_trait_instance_id (translate_ty : 'r T.ty -> ty)
       (* We should have eliminated those in the prepasses *)
       raise (Failure "Unreachable")
   | Clause id -> Clause id
-  | ParentClause (inst_id, clause_id) ->
+  | ParentClause (inst_id, decl_id, clause_id) ->
       let inst_id = translate_trait_instance_id inst_id in
-      ParentClause (inst_id, clause_id)
-  | ItemClause (inst_id, item_name, clause_id) ->
+      ParentClause (inst_id, decl_id, clause_id)
+  | ItemClause (inst_id, decl_id, item_name, clause_id) ->
       let inst_id = translate_trait_instance_id inst_id in
-      ItemClause (inst_id, item_name, clause_id)
+      ItemClause (inst_id, decl_id, item_name, clause_id)
   | TraitRef tr -> TraitRef (translate_trait_ref translate_ty tr)
   | UnknownTrait s -> raise (Failure ("Unknown trait found: " ^ s))
 
@@ -2644,7 +2652,14 @@ and translate_loop (loop : S.loop) (ctx : bs_ctx) : texpression =
       let trait_refs =
         List.map
           (fun (c : trait_clause) ->
-            { trait_id = Clause c.clause_id; generics = empty_generic_args })
+            let trait_decl_ref =
+              { trait_decl_id = c.trait_id; decl_generics = empty_generic_args }
+            in
+            {
+              trait_id = Clause c.clause_id;
+              generics = empty_generic_args;
+              trait_decl_ref;
+            })
           trait_clauses
       in
       { types; const_generics; trait_refs }
-- 
cgit v1.3.1


From a2f19257651df3c8473e17ef73a5389b9cb89bbf Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Sun, 3 Sep 2023 16:35:05 +0200
Subject: Make progress on the extraction

---
 compiler/Extract.ml     | 218 ++++++++++++++++++++++++++++++++++++------------
 compiler/ExtractBase.ml |  63 ++++++++++++--
 compiler/Translate.ml   |   1 +
 3 files changed, 221 insertions(+), 61 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/compiler/Extract.ml b/compiler/Extract.ml
index e07305f1..e140ea1c 100644
--- a/compiler/Extract.ml
+++ b/compiler/Extract.ml
@@ -841,6 +841,7 @@ let mk_formatter (ctx : trans_ctx) (crate_name : string)
     (* TODO: actually use the clause to derive the name *)
     "cl"
   in
+  let trait_self_clause_basename = "self_clause" in
   let append_index (basename : string) (i : int) : string =
     basename ^ string_of_int i
   in
@@ -936,6 +937,7 @@ let mk_formatter (ctx : trans_ctx) (crate_name : string)
     var_basename;
     type_var_basename;
     const_generic_var_basename;
+    trait_self_clause_basename;
     trait_clause_basename;
     append_index;
     extract_literal;
@@ -1237,15 +1239,26 @@ let rec extract_ty (ctx : extraction_ctx) (fmt : F.formatter)
         if use_brackets then F.pp_print_string fmt ")";
         F.pp_print_string fmt ("." ^ name))
       else
-        (* Can only happen when extracting the signature of a trait method
-           *declaration* or a provided trait method (for a declaration).
-           If extracting items for a trait method implementation,
-           the type should have been normalized. For trait method declarations
-           we directly reference the item. *)
-        assert (ctx.trait_decl_id <> None);
-      assert (generics = empty_generic_args);
-      let name = ctx_get_local_trait_assoc_type type_name ctx in
-      F.pp_print_string fmt name
+        (* There are two situations:
+           - we are extracting a declared item (typically a function signature)
+             for a trait declaration. We directly refer to the item (we extract
+             trait declarations as structures, so we can refer to their fields)
+           - we are extracting a provided method for a trait declaration. We
+             refer to the item in the self trait clause (see {!SelfTraitClauseId}).
+
+           Remark: we can't get there for trait *implementations* because then the
+           types should have been normalized.
+        *)
+        let trait_decl_id = Option.get ctx.trait_decl_id in
+        let item_name = ctx_get_trait_assoc_type trait_decl_id type_name ctx in
+        assert (generics = empty_generic_args);
+        if ctx.is_provided_method then
+          (* Provided method: use the trait self clause *)
+          let self_clause = ctx_get_trait_self_clause ctx in
+          F.pp_print_string fmt (self_clause ^ "." ^ item_name)
+        else
+          (* Declaration: directly refer to the item *)
+          F.pp_print_string fmt item_name
 
 and extract_trait_ref (ctx : extraction_ctx) (fmt : F.formatter)
     (no_params_tys : TypeDeclId.Set.t) (inside : bool) (tr : trait_ref) : unit =
@@ -1632,11 +1645,37 @@ let extract_trait_clause_type (ctx : extraction_ctx) (fmt : F.formatter)
 let insert_req_space (fmt : F.formatter) (space : bool ref) : unit =
   if !space then space := false else F.pp_print_space fmt ()
 
+(** Extract the trait self clause.
+
+    We add the trait self clause for provided methods (see {!TraitSelfClauseId}).
+ *)
+let extract_trait_self_clause (insert_req_space : unit -> unit)
+    (ctx : extraction_ctx) (fmt : F.formatter) (trait_decl : A.trait_decl)
+    (params : string list) : unit =
+  insert_req_space ();
+  F.pp_print_string fmt "(";
+  let self_clause = ctx_get_trait_self_clause ctx in
+  F.pp_print_string fmt self_clause;
+  F.pp_print_string fmt ":";
+  let with_opaque_pre = false in
+  let trait_id = ctx_get_trait_decl with_opaque_pre trait_decl.def_id ctx in
+  F.pp_print_string fmt trait_id;
+  List.iter
+    (fun p ->
+      F.pp_print_space fmt ();
+      F.pp_print_string fmt p)
+    params;
+  F.pp_print_string fmt ")"
+
+(**
+ - [trait_decl]: if [Some], it means we are extracting the generics for a provided
+   method and need to insert a trait self clause (see {!TraitSelfClauseId}).
+ *)
 let extract_generic_params (ctx : extraction_ctx) (fmt : F.formatter)
     (no_params_tys : TypeDeclId.Set.t) (use_forall : bool) (as_implicits : bool)
-    (space : bool ref option) (generics : generic_params)
-    (type_params : string list) (cg_params : string list)
-    (trait_clauses : string list) : unit =
+    (space : bool ref option) (trait_decl : A.trait_decl option)
+    (generics : generic_params) (type_params : string list)
+    (cg_params : string list) (trait_clauses : string list) : unit =
   let all_params = List.concat [ type_params; cg_params; trait_clauses ] in
   (* HOL4 doesn't support const generics *)
   assert (cg_params = [] || !backend <> HOL4);
@@ -1660,53 +1699,102 @@ let extract_generic_params (ctx : extraction_ctx) (fmt : F.formatter)
       F.pp_print_string fmt ":";
       F.pp_print_space fmt ();
       F.pp_print_string fmt "forall");
-    (* Note that in HOL4 we don't print the type parameters. *)
-    if !backend <> HOL4 then (
-      (* Print the type parameters *)
-      if type_params <> [] then (
-        insert_req_space ();
-        (* ( *)
-        left_bracket ();
+    (* Small helper - we may need to split the parameters *)
+    let print_generics (type_params : string list)
+        (const_generics : const_generic_var list)
+        (trait_clauses : trait_clause list) : unit =
+      (* Note that in HOL4 we don't print the type parameters. *)
+      if !backend <> HOL4 then (
+        (* Print the type parameters *)
+        if type_params <> [] then (
+          insert_req_space ();
+          (* ( *)
+          left_bracket ();
+          List.iter
+            (fun s ->
+              F.pp_print_string fmt s;
+              F.pp_print_space fmt ())
+            type_params;
+          F.pp_print_string fmt ":";
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt (type_keyword ());
+          (* ) *)
+          right_bracket ());
+        (* Print the const generic parameters *)
         List.iter
-          (fun s ->
-            F.pp_print_string fmt s;
-            F.pp_print_space fmt ())
-          type_params;
-        F.pp_print_string fmt ":";
-        F.pp_print_space fmt ();
-        F.pp_print_string fmt (type_keyword ());
-        (* ) *)
-        right_bracket ());
-      (* Print the const generic parameters *)
+          (fun (var : const_generic_var) ->
+            insert_req_space ();
+            (* ( *)
+            left_bracket ();
+            let n = ctx_get_const_generic_var var.index ctx in
+            F.pp_print_string fmt n;
+            F.pp_print_space fmt ();
+            F.pp_print_string fmt ":";
+            F.pp_print_space fmt ();
+            extract_literal_type ctx fmt var.ty;
+            (* ) *)
+            right_bracket ())
+          const_generics);
+      (* Print the trait clauses *)
       List.iter
-        (fun (var : const_generic_var) ->
+        (fun (clause : trait_clause) ->
           insert_req_space ();
           (* ( *)
           left_bracket ();
-          let n = ctx_get_const_generic_var var.index ctx in
+          let n = ctx_get_local_trait_clause clause.clause_id ctx in
           F.pp_print_string fmt n;
           F.pp_print_space fmt ();
           F.pp_print_string fmt ":";
           F.pp_print_space fmt ();
-          extract_literal_type ctx fmt var.ty;
+          extract_trait_clause_type ctx fmt no_params_tys clause;
           (* ) *)
           right_bracket ())
-        generics.const_generics);
-    (* Print the trait clauses *)
-    List.iter
-      (fun (clause : trait_clause) ->
-        insert_req_space ();
-        (* ( *)
-        left_bracket ();
-        let n = ctx_get_local_trait_clause clause.clause_id ctx in
-        F.pp_print_string fmt n;
-        F.pp_print_space fmt ();
-        F.pp_print_string fmt ":";
-        F.pp_print_space fmt ();
-        extract_trait_clause_type ctx fmt no_params_tys clause;
-        (* ) *)
-        right_bracket ())
-      generics.trait_clauses)
+        trait_clauses
+    in
+    (* If we extract the generics for a provided method for a trait declaration
+       (indicated by the trait decl given as input), we need to split the generics:
+       - we print the generics for the trait decl
+       - we print the trait self clause
+       - we print the generics for the trait method
+    *)
+    match trait_decl with
+    | None ->
+        print_generics type_params generics.const_generics
+          generics.trait_clauses
+    | Some trait_decl ->
+        (* Split the generics between the generics specific to the trait decl
+           and those specific to the trait method *)
+        let open Collections.List in
+        let dtype_params, mtype_params =
+          split_at type_params (length trait_decl.generics.types)
+        in
+        let dcgs, mcgs =
+          split_at generics.const_generics
+            (length trait_decl.generics.const_generics)
+        in
+        let dtrait_clauses, mtrait_clauses =
+          split_at generics.trait_clauses
+            (length trait_decl.generics.trait_clauses)
+        in
+        (* Extract the trait decl generics *)
+        print_generics dtype_params dcgs dtrait_clauses;
+        (* Extract the trait self clause *)
+        let params =
+          concat
+            [
+              dtype_params;
+              map
+                (fun (cg : const_generic_var) ->
+                  ctx_get_const_generic_var cg.index ctx)
+                dcgs;
+              map
+                (fun c -> ctx_get_local_trait_clause c.clause_id ctx)
+                dtrait_clauses;
+            ]
+        in
+        extract_trait_self_clause insert_req_space ctx fmt trait_decl params;
+        (* Extract the method generics *)
+        print_generics mtype_params mcgs mtrait_clauses)
 
 (** Extract a type declaration.
 
@@ -1769,7 +1857,7 @@ let extract_type_decl_gen (ctx : extraction_ctx) (fmt : F.formatter)
   (* Print the generic parameters *)
   let as_implicits = false in
   extract_generic_params ctx_body fmt type_decl_group use_forall as_implicits
-    None def.generics type_params cg_params trait_clauses;
+    None None def.generics type_params cg_params trait_clauses;
   (* Print the "=" if we extract the body*)
   if extract_body then (
     F.pp_print_space fmt ();
@@ -2002,7 +2090,8 @@ let extract_type_decl_record_field_projectors (ctx : extraction_ctx)
           let use_forall = false in
           let as_implicits = true in
           extract_generic_params ctx fmt TypeDeclId.Set.empty use_forall
-            as_implicits None decl.generics type_params cg_params trait_clauses;
+            as_implicits None None decl.generics type_params cg_params
+            trait_clauses;
           (* Print the record parameter *)
           F.pp_print_space fmt ();
           F.pp_print_string fmt "(";
@@ -2994,8 +3083,8 @@ and extract_StructUpdate (ctx : extraction_ctx) (fmt : F.formatter)
 (** A small utility to print the parameters of a function signature.
 
     We return two contexts:
-    - the context augmented with bindings for the type parameters
-    - the context augmented with bindings for the type parameters *and*
+    - the context augmented with bindings for the generics
+    - the context augmented with bindings for the generics *and*
       bindings for the input values
 
     We also return names for the type parameters, const generics, etc.
@@ -3009,6 +3098,28 @@ and extract_StructUpdate (ctx : extraction_ctx) (fmt : F.formatter)
 let extract_fun_parameters (space : bool ref) (ctx : extraction_ctx)
     (fmt : F.formatter) (def : fun_decl) :
     extraction_ctx * extraction_ctx * string list =
+  (* First, add the associated types and constants if the function is a method
+     in a trait declaration.
+
+     About the order: we want to make sure the names are reserved for
+     those (variable names might collide with them but it is ok, we will add
+     suffixes to the variables).
+
+     TODO: micro-pass to update what happens when calling trait provided
+     functions.
+  *)
+  let ctx, trait_decl =
+    match def.kind with
+    | TraitMethodProvided (decl_id, _) ->
+        let trait_decl =
+          T.TraitDeclId.Map.find decl_id
+            ctx.trans_ctx.trait_decls_context.trait_decls
+        in
+        let ctx, _ = ctx_add_trait_self_clause ctx in
+        let ctx = { ctx with is_provided_method = true } in
+        (ctx, Some trait_decl)
+    | _ -> (ctx, None)
+  in
   (* Add the type parameters - note that we need those bindings only for the
    * body translation (they are not top-level) *)
   let ctx, type_params, cg_params, trait_clauses =
@@ -3020,7 +3131,8 @@ let extract_fun_parameters (space : bool ref) (ctx : extraction_ctx)
   let use_forall = false in
   let as_implicits = false in
   extract_generic_params ctx fmt TypeDeclId.Set.empty use_forall as_implicits
-    (Some space) def.signature.generics type_params cg_params trait_clauses;
+    (Some space) trait_decl def.signature.generics type_params cg_params
+    trait_clauses;
   (* Close the box for the generics *)
   F.pp_close_box fmt ();
   (* The input parameters - note that doing this adds bindings to the context *)
diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index 697b1027..251d8b36 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -291,6 +291,7 @@ type formatter = {
       (** Generates a type variable basename. *)
   const_generic_var_basename : StringSet.t -> string -> string;
       (** Generates a const generic variable basename. *)
+  trait_self_clause_basename : string;
   trait_clause_basename : StringSet.t -> trait_clause -> string;
       (** Return a base name for a trait clause. We might add a suffix to prevent
           collisions.
@@ -409,10 +410,44 @@ type id =
   | TraitDeclId of TraitDeclId.id
   | TraitImplId of TraitImplId.id
   | LocalTraitClauseId of TraitClauseId.id
-  | LocalTraitAssocTypeId of string  (** Specifically for: [Self::Ty] *)
   | TraitAssocTypeId of TraitDeclId.id * string  (** A trait associated type *)
   | TraitParentClauseId of TraitDeclId.id * TraitClauseId.id
   | TraitItemClauseId of TraitDeclId.id * string * TraitClauseId.id
+  | TraitSelfClauseId
+      (** Specifically for the clause: [Self : Trait].
+
+          For now, we forbid provided methods (methods in trait declarations
+          with a default implementation) from being overriden in trait implementations.
+          We extract trait provided methods such that they take an instance of
+          the trait as input: this instance is given by the trait self clause.
+
+          For instance:
+          {[
+            //
+            // Rust
+            //
+            trait ToU64 {
+              fn to_u64(&self) -> u64;
+
+              // Provided method
+              fn is_pos(&self) -> bool {
+                self.to_u64() > 0
+              }
+            }
+
+            //
+            // Generated code
+            //
+            struct ToU64 (T : Type) {
+              to_u64 : T -> u64;
+            }
+
+            //                    The trait self clause
+            //                    vvvvvvvvvvvvvvvvvvvvvv
+            let is_pos (T : Type) (trait_self : ToU64 T) (self : T) : bool =
+              trait_self.to_u64 self > 0
+          ]}
+       *)
   | UnknownId
       (** Used for stored various strings like keywords, definitions which
           should always be in context, etc. and which can't be linked to one
@@ -618,6 +653,7 @@ type extraction_ctx = {
         *)
   trait_decl_id : trait_decl_id option;
       (** If we are extracting a trait declaration, identifies it *)
+  is_provided_method : bool;
 }
 
 (** Debugging function, used when communicating name collisions to the user,
@@ -752,7 +788,6 @@ let id_to_string (id : id) (ctx : extraction_ctx) : string =
   | TraitImplId id -> "trait_impl_id: " ^ TraitImplId.to_string id
   | LocalTraitClauseId id ->
       "local_trait_clause_id: " ^ TraitClauseId.to_string id
-  | LocalTraitAssocTypeId type_name -> "local_trait_assoc_type_id: " ^ type_name
   | TraitParentClauseId (id, clause_id) ->
       "trait_parent_clause_id: decl_id:" ^ TraitDeclId.to_string id
       ^ ", clause_id: "
@@ -764,11 +799,14 @@ let id_to_string (id : id) (ctx : extraction_ctx) : string =
   | TraitAssocTypeId (id, type_name) ->
       "trait_assoc_type_id: decl_id:" ^ TraitDeclId.to_string id
       ^ ", type name: " ^ type_name
+  | TraitSelfClauseId -> "trait_self_clause"
 
 (** We might not check for collisions for some specific ids (ex.: field names) *)
 let allow_collisions (id : id) : bool =
   match id with
-  | FieldId (_, _) -> !Config.record_fields_short_names
+  | FieldId _ | TraitItemClauseId _ | TraitParentClauseId _ | TraitAssocTypeId _
+    ->
+      !Config.record_fields_short_names
   | _ -> false
 
 let ctx_add (is_opaque : bool) (id : id) (name : string) (ctx : extraction_ctx)
@@ -858,6 +896,10 @@ let ctx_get_assumed_type (id : assumed_ty) (ctx : extraction_ctx) : string =
   let is_opaque = false in
   ctx_get_type is_opaque (Assumed id) ctx
 
+let ctx_get_trait_self_clause (ctx : extraction_ctx) : string =
+  let with_opaque_pre = false in
+  ctx_get with_opaque_pre TraitSelfClauseId ctx
+
 let ctx_get_trait_decl (with_opaque_pre : bool) (id : trait_decl_id)
     (ctx : extraction_ctx) : string =
   ctx_get with_opaque_pre (TraitDeclId id) ctx
@@ -871,11 +913,6 @@ let ctx_get_trait_assoc_type (id : trait_decl_id) (type_name : string)
   let is_opaque = false in
   ctx_get is_opaque (TraitAssocTypeId (id, type_name)) ctx
 
-let ctx_get_local_trait_assoc_type (type_name : string) (ctx : extraction_ctx) :
-    string =
-  let is_opaque = false in
-  ctx_get is_opaque (LocalTraitAssocTypeId type_name) ctx
-
 let ctx_get_trait_parent_clause (id : trait_decl_id) (clause : trait_clause_id)
     (ctx : extraction_ctx) : string =
   let with_opaque_pre = false in
@@ -969,6 +1006,16 @@ let ctx_add_var (basename : string) (id : VarId.id) (ctx : extraction_ctx) :
   let ctx = ctx_add is_opaque (VarId id) name ctx in
   (ctx, name)
 
+(** Generate a unique variable name for the trait self clause and add it to the context *)
+let ctx_add_trait_self_clause (ctx : extraction_ctx) : extraction_ctx * string =
+  let is_opaque = false in
+  let basename = ctx.fmt.trait_self_clause_basename in
+  let name =
+    basename_to_unique ctx.names_map.names_set ctx.fmt.append_index basename
+  in
+  let ctx = ctx_add is_opaque TraitSelfClauseId name ctx in
+  (ctx, name)
+
 (** Generate a unique trait clause name and add it to the context *)
 let ctx_add_local_trait_clause (basename : string) (id : TraitClauseId.id)
     (ctx : extraction_ctx) : extraction_ctx * string =
diff --git a/compiler/Translate.ml b/compiler/Translate.ml
index f4f59187..790dbe14 100644
--- a/compiler/Translate.ml
+++ b/compiler/Translate.ml
@@ -1007,6 +1007,7 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
       use_dep_ite = !Config.backend = Lean && !Config.extract_decreases_clauses;
       fun_name_info = PureUtils.RegularFunIdMap.empty;
       trait_decl_id = None (* None by default *);
+      is_provided_method = false (* false by default *);
     }
   in
 
-- 
cgit v1.3.1


From 0e0f3d586e7e74003ebff129a1e91b87602467e7 Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Sun, 3 Sep 2023 16:51:36 +0200
Subject: Make more progress

---
 compiler/Extract.ml     | 19 +++++++++-----
 compiler/ExtractBase.ml |  2 ++
 compiler/Translate.ml   | 70 ++++++++++++++++++++++++++++++++++++-------------
 3 files changed, 67 insertions(+), 24 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/compiler/Extract.ml b/compiler/Extract.ml
index e140ea1c..17f850a3 100644
--- a/compiler/Extract.ml
+++ b/compiler/Extract.ml
@@ -1650,7 +1650,7 @@ let insert_req_space (fmt : F.formatter) (space : bool ref) : unit =
     We add the trait self clause for provided methods (see {!TraitSelfClauseId}).
  *)
 let extract_trait_self_clause (insert_req_space : unit -> unit)
-    (ctx : extraction_ctx) (fmt : F.formatter) (trait_decl : A.trait_decl)
+    (ctx : extraction_ctx) (fmt : F.formatter) (trait_decl : trait_decl)
     (params : string list) : unit =
   insert_req_space ();
   F.pp_print_string fmt "(";
@@ -1673,7 +1673,7 @@ let extract_trait_self_clause (insert_req_space : unit -> unit)
  *)
 let extract_generic_params (ctx : extraction_ctx) (fmt : F.formatter)
     (no_params_tys : TypeDeclId.Set.t) (use_forall : bool) (as_implicits : bool)
-    (space : bool ref option) (trait_decl : A.trait_decl option)
+    (space : bool ref option) (trait_decl : trait_decl option)
     (generics : generic_params) (type_params : string list)
     (cg_params : string list) (trait_clauses : string list) : unit =
   let all_params = List.concat [ type_params; cg_params; trait_clauses ] in
@@ -3111,10 +3111,7 @@ let extract_fun_parameters (space : bool ref) (ctx : extraction_ctx)
   let ctx, trait_decl =
     match def.kind with
     | TraitMethodProvided (decl_id, _) ->
-        let trait_decl =
-          T.TraitDeclId.Map.find decl_id
-            ctx.trans_ctx.trait_decls_context.trait_decls
-        in
+        let trait_decl = T.TraitDeclId.Map.find decl_id ctx.trans_trait_decls in
         let ctx, _ = ctx_add_trait_self_clause ctx in
         let ctx = { ctx with is_provided_method = true } in
         (ctx, Some trait_decl)
@@ -3887,6 +3884,16 @@ let extract_global_decl (ctx : extraction_ctx) (fmt : F.formatter)
       (* Add a break to insert lines between declarations *)
       F.pp_print_break fmt 0 0
 
+(** Similar to {!extract_type_decl_register_names} *)
+let extract_trait_decl_register_names (ctx : extraction_ctx) (d : trait_decl) :
+    extraction_ctx =
+  raise (Failure "TODO")
+
+(** Similar to {!extract_type_decl_register_names} *)
+let extract_trait_impl_register_names (ctx : extraction_ctx) (d : trait_impl) :
+    extraction_ctx =
+  raise (Failure "TODO")
+
 (** Extract a trait declaration *)
 let extract_trait_decl (ctx : extraction_ctx) (fmt : F.formatter)
     (trait_decl : trait_decl) : unit =
diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index 251d8b36..2855b3b9 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -654,6 +654,8 @@ type extraction_ctx = {
   trait_decl_id : trait_decl_id option;
       (** If we are extracting a trait declaration, identifies it *)
   is_provided_method : bool;
+  trans_trait_decls : Pure.trait_decl Pure.TraitDeclId.Map.t;
+  trans_trait_impls : Pure.trait_impl Pure.TraitImplId.Map.t;
 }
 
 (** Debugging function, used when communicating name collisions to the user,
diff --git a/compiler/Translate.ml b/compiler/Translate.ml
index 790dbe14..8df69961 100644
--- a/compiler/Translate.ml
+++ b/compiler/Translate.ml
@@ -301,8 +301,13 @@ let translate_function_to_pure (trans_ctx : trans_ctx)
   (* Return *)
   (pure_forward, pure_backwards)
 
+(* TODO: factor out the return type *)
 let translate_crate_to_pure (crate : A.crate) :
-    trans_ctx * Pure.type_decl list * (bool * pure_fun_translation) list =
+    trans_ctx
+    * Pure.type_decl list
+    * (bool * pure_fun_translation) list
+    * Pure.trait_decl list
+    * Pure.trait_impl list =
   (* Debug *)
   log#ldebug (lazy "translate_crate_to_pure");
 
@@ -368,13 +373,28 @@ let translate_crate_to_pure (crate : A.crate) :
       (A.FunDeclId.Map.values crate.functions)
   in
 
+  (* Translate the trait declarations *)
+  let type_infos = trans_ctx.type_context.type_infos in
+  let trait_decls =
+    List.map
+      (SymbolicToPure.translate_trait_decl type_infos)
+      (T.TraitDeclId.Map.values trans_ctx.trait_decls_context.trait_decls)
+  in
+
+  (* Translate the trait implementations *)
+  let trait_impls =
+    List.map
+      (SymbolicToPure.translate_trait_impl type_infos)
+      (T.TraitImplId.Map.values trans_ctx.trait_impls_context.trait_impls)
+  in
+
   (* Apply the micro-passes *)
   let pure_translations =
     Micro.apply_passes_to_pure_fun_translations trans_ctx pure_translations
   in
 
   (* Return *)
-  (trans_ctx, type_decls, pure_translations)
+  (trans_ctx, type_decls, pure_translations, trait_decls, trait_impls)
 
 (** Extraction context *)
 type gen_ctx = {
@@ -735,14 +755,8 @@ let export_functions_group (fmt : Format.formatter) (config : gen_config)
 let export_trait_decl (fmt : Format.formatter) (_config : gen_config)
     (ctx : gen_ctx) (trait_decl_id : Pure.trait_decl_id) : unit =
   let trait_decl =
-    T.TraitDeclId.Map.find trait_decl_id
-      ctx.extract_ctx.trans_ctx.trait_decls_context.trait_decls
+    T.TraitDeclId.Map.find trait_decl_id ctx.extract_ctx.trans_trait_decls
   in
-  (* We translate the trait declaration on the fly (note that
-     trait declarations do not directly contain functions, constants,
-     etc.: they simply refer to them). *)
-  let type_infos = ctx.extract_ctx.trans_ctx.type_context.type_infos in
-  let trait_decl = SymbolicToPure.translate_trait_decl type_infos trait_decl in
   let ctx = ctx.extract_ctx in
   let ctx = { ctx with trait_decl_id = Some trait_decl.def_id } in
   Extract.extract_trait_decl ctx fmt trait_decl
@@ -751,14 +765,8 @@ let export_trait_decl (fmt : Format.formatter) (_config : gen_config)
 let export_trait_impl (fmt : Format.formatter) (_config : gen_config)
     (ctx : gen_ctx) (trait_impl_id : Pure.trait_impl_id) : unit =
   let trait_impl =
-    T.TraitImplId.Map.find trait_impl_id
-      ctx.extract_ctx.trans_ctx.trait_impls_context.trait_impls
+    T.TraitImplId.Map.find trait_impl_id ctx.extract_ctx.trans_trait_impls
   in
-  (* We translate the trait implementation on the fly (note that
-     trait implementations do not directly contain functions, constants,
-     etc.: they simply refer to them). *)
-  let type_infos = ctx.extract_ctx.trans_ctx.type_context.type_infos in
-  let trait_impl = SymbolicToPure.translate_trait_impl type_infos trait_impl in
   Extract.extract_trait_impl ctx.extract_ctx fmt trait_impl
 
 (** A generic utility to generate the extracted definitions: as we may want to
@@ -978,7 +986,9 @@ let extract_file (config : gen_config) (ctx : gen_ctx) (fi : extract_file_info)
 let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
     unit =
   (* Translate the module to the pure AST *)
-  let trans_ctx, trans_types, trans_funs = translate_crate_to_pure crate in
+  let trans_ctx, trans_types, trans_funs, trans_trait_decls, trans_trait_impls =
+    translate_crate_to_pure crate
+  in
 
   (* Initialize the extraction context - for now we extract only to F*.
    * We initialize the names map by registering the keywords used in the
@@ -997,6 +1007,18 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
   in
   (* Put everything in the context *)
   let ctx =
+    let trans_trait_decls =
+      T.TraitDeclId.Map.of_list
+        (List.map
+           (fun (d : Pure.trait_decl) -> (d.def_id, d))
+           trans_trait_decls)
+    in
+    let trans_trait_impls =
+      T.TraitImplId.Map.of_list
+        (List.map
+           (fun (d : Pure.trait_impl) -> (d.def_id, d))
+           trans_trait_impls)
+    in
     {
       ExtractBase.trans_ctx;
       names_map;
@@ -1008,6 +1030,8 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
       fun_name_info = PureUtils.RegularFunIdMap.empty;
       trait_decl_id = None (* None by default *);
       is_provided_method = false (* false by default *);
+      trans_trait_decls;
+      trans_trait_impls;
     }
   in
 
@@ -1034,7 +1058,7 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
   in
   let rec_functions = PureUtils.FunLoopIdSet.of_list rec_functions in
 
-  (* Register unique names for all the top-level types, globals and functions.
+  (* Register unique names for all the top-level types, globals, functions...
    * Note that the order in which we generate the names doesn't matter:
    * we just need to generate a mapping from identifier to name, and make
    * sure there are no name clashes. *)
@@ -1071,6 +1095,16 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
       (A.GlobalDeclId.Map.values crate.globals)
   in
 
+  let ctx =
+    List.fold_left Extract.extract_trait_decl_register_names ctx
+      trans_trait_decls
+  in
+
+  let ctx =
+    List.fold_left Extract.extract_trait_impl_register_names ctx
+      trans_trait_impls
+  in
+
   (* Open the output file *)
   (* First compute the filename by replacing the extension and converting the
    * case (rust module names are snake case) *)
-- 
cgit v1.3.1


From 0c0b7692cc3d95adf21bccf83d5bb2f81487ca4f Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Sun, 3 Sep 2023 17:56:35 +0200
Subject: Register the names for the trait decls

---
 compiler/Extract.ml     | 90 +++++++++++++++++++++++++++++++++++++++++++++----
 compiler/ExtractBase.ml | 78 +++++++++++++++++++++++++++++++++++++-----
 2 files changed, 154 insertions(+), 14 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/compiler/Extract.ml b/compiler/Extract.ml
index 17f850a3..5eb30daa 100644
--- a/compiler/Extract.ml
+++ b/compiler/Extract.ml
@@ -720,6 +720,41 @@ let mk_formatter (ctx : trans_ctx) (crate_name : string)
     fname ^ suffix
   in
 
+  let trait_decl_name (trait_decl : trait_decl) : string =
+    type_name_to_snake_case trait_decl.name
+  in
+
+  let trait_impl_name (trait_impl : trait_impl) : string =
+    get_fun_name trait_impl.name
+  in
+
+  let trait_parent_clause_name (trait_decl : trait_decl) (clause : trait_clause)
+      : string =
+    (* TODO: improve - it would be better to not use indices *)
+    let clause = "parent_clause_" ^ TraitClauseId.to_string clause.clause_id in
+    if !Config.record_fields_short_names then clause
+    else trait_decl_name trait_decl ^ "_" ^ clause
+  in
+  let trait_type_name (trait_decl : trait_decl) (item : string) : string =
+    if !Config.record_fields_short_names then item
+    else trait_decl_name trait_decl ^ "_" ^ item
+  in
+  let trait_const_name (trait_decl : trait_decl) (item : string) : string =
+    if !Config.record_fields_short_names then item
+    else trait_decl_name trait_decl ^ "_" ^ item
+  in
+  let trait_method_name (trait_decl : trait_decl) (item : string) : string =
+    if !Config.record_fields_short_names then item
+    else trait_decl_name trait_decl ^ "_" ^ item
+  in
+  let trait_type_clause_name (trait_decl : trait_decl) (item : string)
+      (clause : trait_clause) : string =
+    (* TODO: improve - it would be better to not use indices *)
+    trait_type_name trait_decl item
+    ^ "_clause_"
+    ^ TraitClauseId.to_string clause.clause_id
+  in
+
   let termination_measure_name (_fid : A.FunDeclId.id) (fname : fun_name)
       (num_loops : int) (loop_id : LoopId.id option) : string =
     let fname = get_fun_name fname in
@@ -933,6 +968,13 @@ let mk_formatter (ctx : trans_ctx) (crate_name : string)
     fun_name;
     termination_measure_name;
     decreases_proof_name;
+    trait_decl_name;
+    trait_impl_name;
+    trait_parent_clause_name;
+    trait_const_name;
+    trait_type_name;
+    trait_method_name;
+    trait_type_clause_name;
     opaque_pre;
     var_basename;
     type_var_basename;
@@ -1233,8 +1275,8 @@ let rec extract_ty (ctx : extraction_ctx) (fmt : F.formatter)
         extract_trait_ref ctx fmt no_params_tys false trait_ref;
         extract_generic_args ctx fmt no_params_tys generics;
         let name =
-          ctx_get_trait_assoc_type trait_ref.trait_decl_ref.trait_decl_id
-            type_name ctx
+          ctx_get_trait_type trait_ref.trait_decl_ref.trait_decl_id type_name
+            ctx
         in
         if use_brackets then F.pp_print_string fmt ")";
         F.pp_print_string fmt ("." ^ name))
@@ -1250,7 +1292,7 @@ let rec extract_ty (ctx : extraction_ctx) (fmt : F.formatter)
            types should have been normalized.
         *)
         let trait_decl_id = Option.get ctx.trait_decl_id in
-        let item_name = ctx_get_trait_assoc_type trait_decl_id type_name ctx in
+        let item_name = ctx_get_trait_type trait_decl_id type_name ctx in
         assert (generics = empty_generic_args);
         if ctx.is_provided_method then
           (* Provided method: use the trait self clause *)
@@ -3885,9 +3927,45 @@ let extract_global_decl (ctx : extraction_ctx) (fmt : F.formatter)
       F.pp_print_break fmt 0 0
 
 (** Similar to {!extract_type_decl_register_names} *)
-let extract_trait_decl_register_names (ctx : extraction_ctx) (d : trait_decl) :
-    extraction_ctx =
-  raise (Failure "TODO")
+let extract_trait_decl_register_names (ctx : extraction_ctx)
+    (trait_decl : trait_decl) : extraction_ctx =
+  let {
+    def_id = _;
+    name = _;
+    generics;
+    preds = _;
+    all_trait_clauses = _;
+    consts;
+    types;
+    required_methods;
+    provided_methods = _;
+  } =
+    trait_decl
+  in
+  let ctx = ctx_add_trait_decl trait_decl ctx in
+  let ctx =
+    List.fold_left
+      (fun ctx clause -> ctx_add_trait_parent_clause trait_decl clause ctx)
+      ctx generics.trait_clauses
+  in
+  let ctx =
+    List.fold_left
+      (fun ctx (name, (_, _)) -> ctx_add_trait_const trait_decl name ctx)
+      ctx consts
+  in
+  let ctx =
+    List.fold_left
+      (fun ctx (name, (clauses, _)) ->
+        let ctx = ctx_add_trait_type trait_decl name ctx in
+        List.fold_left
+          (fun ctx clause ->
+            ctx_add_trait_type_clause trait_decl name clause ctx)
+          ctx clauses)
+      ctx types
+  in
+  List.fold_left
+    (fun ctx (name, _) -> ctx_add_trait_method trait_decl name ctx)
+    ctx required_methods
 
 (** Similar to {!extract_type_decl_register_names} *)
 let extract_trait_impl_register_names (ctx : extraction_ctx) (d : trait_impl) :
diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index 2855b3b9..7e6a2d40 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -242,6 +242,13 @@ type formatter = {
             the same purpose as in {!field:fun_name}.
           - loop identifier, if this is for a loop
        *)
+  trait_decl_name : trait_decl -> string;
+  trait_impl_name : trait_impl -> string;
+  trait_parent_clause_name : trait_decl -> trait_clause -> string;
+  trait_const_name : trait_decl -> string -> string;
+  trait_type_name : trait_decl -> string -> string;
+  trait_method_name : trait_decl -> string -> string;
+  trait_type_clause_name : trait_decl -> string -> trait_clause -> string;
   opaque_pre : unit -> string;
       (** TODO: obsolete, remove.
 
@@ -410,7 +417,7 @@ type id =
   | TraitDeclId of TraitDeclId.id
   | TraitImplId of TraitImplId.id
   | LocalTraitClauseId of TraitClauseId.id
-  | TraitAssocTypeId of TraitDeclId.id * string  (** A trait associated type *)
+  | TraitItemId of TraitDeclId.id * string  (** A trait associated item *)
   | TraitParentClauseId of TraitDeclId.id * TraitClauseId.id
   | TraitItemClauseId of TraitDeclId.id * string * TraitClauseId.id
   | TraitSelfClauseId
@@ -798,16 +805,15 @@ let id_to_string (id : id) (ctx : extraction_ctx) : string =
       "trait_item_clause_id: decl_id:" ^ TraitDeclId.to_string id
       ^ ", item name: " ^ item_name ^ ", clause_id: "
       ^ TraitClauseId.to_string clause_id
-  | TraitAssocTypeId (id, type_name) ->
-      "trait_assoc_type_id: decl_id:" ^ TraitDeclId.to_string id
-      ^ ", type name: " ^ type_name
+  | TraitItemId (id, name) ->
+      "trait_item_id: decl_id:" ^ TraitDeclId.to_string id ^ ", type name: "
+      ^ name
   | TraitSelfClauseId -> "trait_self_clause"
 
 (** We might not check for collisions for some specific ids (ex.: field names) *)
 let allow_collisions (id : id) : bool =
   match id with
-  | FieldId _ | TraitItemClauseId _ | TraitParentClauseId _ | TraitAssocTypeId _
-    ->
+  | FieldId _ | TraitItemClauseId _ | TraitParentClauseId _ | TraitItemId _ ->
       !Config.record_fields_short_names
   | _ -> false
 
@@ -910,10 +916,22 @@ let ctx_get_trait_impl (with_opaque_pre : bool) (id : trait_impl_id)
     (ctx : extraction_ctx) : string =
   ctx_get with_opaque_pre (TraitImplId id) ctx
 
-let ctx_get_trait_assoc_type (id : trait_decl_id) (type_name : string)
+let ctx_get_trait_item (id : trait_decl_id) (item_name : string)
     (ctx : extraction_ctx) : string =
   let is_opaque = false in
-  ctx_get is_opaque (TraitAssocTypeId (id, type_name)) ctx
+  ctx_get is_opaque (TraitItemId (id, item_name)) ctx
+
+let ctx_get_trait_const (id : trait_decl_id) (item_name : string)
+    (ctx : extraction_ctx) : string =
+  ctx_get_trait_item id item_name ctx
+
+let ctx_get_trait_type (id : trait_decl_id) (item_name : string)
+    (ctx : extraction_ctx) : string =
+  ctx_get_trait_item id item_name ctx
+
+let ctx_get_trait_method (id : trait_decl_id) (item_name : string)
+    (ctx : extraction_ctx) : string =
+  ctx_get_trait_item id item_name ctx
 
 let ctx_get_trait_parent_clause (id : trait_decl_id) (clause : trait_clause_id)
     (ctx : extraction_ctx) : string =
@@ -1205,6 +1223,50 @@ let ctx_add_fun_decl (trans_group : bool * pure_fun_translation)
         ctx.fun_name_info;
   }
 
+let ctx_add_trait_decl (d : trait_decl) (ctx : extraction_ctx) : extraction_ctx
+    =
+  let is_opaque = false in
+  let name = ctx.fmt.trait_decl_name d in
+  ctx_add is_opaque (TraitDeclId d.def_id) name ctx
+
+let ctx_add_trait_impl (d : trait_impl) (ctx : extraction_ctx) : extraction_ctx
+    =
+  let is_opaque = false in
+  let name = ctx.fmt.trait_impl_name d in
+  ctx_add is_opaque (TraitImplId d.def_id) name ctx
+
+let ctx_add_trait_const (d : trait_decl) (item : string) (ctx : extraction_ctx)
+    : extraction_ctx =
+  let is_opaque = false in
+  let name = ctx.fmt.trait_const_name d item in
+  ctx_add is_opaque (TraitItemId (d.def_id, item)) name ctx
+
+let ctx_add_trait_type (d : trait_decl) (item : string) (ctx : extraction_ctx) :
+    extraction_ctx =
+  let is_opaque = false in
+  let name = ctx.fmt.trait_type_name d item in
+  ctx_add is_opaque (TraitItemId (d.def_id, item)) name ctx
+
+let ctx_add_trait_method (d : trait_decl) (item : string) (ctx : extraction_ctx)
+    : extraction_ctx =
+  let is_opaque = false in
+  let name = ctx.fmt.trait_method_name d item in
+  ctx_add is_opaque (TraitItemId (d.def_id, item)) name ctx
+
+let ctx_add_trait_parent_clause (d : trait_decl) (clause : trait_clause)
+    (ctx : extraction_ctx) : extraction_ctx =
+  let is_opaque = false in
+  let name = ctx.fmt.trait_parent_clause_name d clause in
+  ctx_add is_opaque (TraitParentClauseId (d.def_id, clause.clause_id)) name ctx
+
+let ctx_add_trait_type_clause (d : trait_decl) (item : string)
+    (clause : trait_clause) (ctx : extraction_ctx) : extraction_ctx =
+  let is_opaque = false in
+  let name = ctx.fmt.trait_type_clause_name d item clause in
+  ctx_add is_opaque
+    (TraitItemClauseId (d.def_id, item, clause.clause_id))
+    name ctx
+
 type names_map_init = {
   keywords : string list;
   assumed_adts : (assumed_ty * string) list;
-- 
cgit v1.3.1


From 9fe9fc0ab70b8629722d60748bbede554017172c Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Sun, 3 Sep 2023 18:59:19 +0200
Subject: Make progress on extracting trait decls and merge gen_ctx and
 extraction_ctx

---
 compiler/Extract.ml     | 150 ++++++++++++++++++++++++++++++++++++++++++--
 compiler/ExtractBase.ml |   4 ++
 compiler/Translate.ml   | 163 +++++++++++++++++++++---------------------------
 3 files changed, 219 insertions(+), 98 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/compiler/Extract.ml b/compiler/Extract.ml
index 5eb30daa..f911290e 100644
--- a/compiler/Extract.ml
+++ b/compiler/Extract.ml
@@ -3943,16 +3943,19 @@ let extract_trait_decl_register_names (ctx : extraction_ctx)
     trait_decl
   in
   let ctx = ctx_add_trait_decl trait_decl ctx in
+  (* Parent clauses *)
   let ctx =
     List.fold_left
       (fun ctx clause -> ctx_add_trait_parent_clause trait_decl clause ctx)
       ctx generics.trait_clauses
   in
+  (* Constants *)
   let ctx =
     List.fold_left
       (fun ctx (name, (_, _)) -> ctx_add_trait_const trait_decl name ctx)
       ctx consts
   in
+  (* Types *)
   let ctx =
     List.fold_left
       (fun ctx (name, (clauses, _)) ->
@@ -3963,19 +3966,156 @@ let extract_trait_decl_register_names (ctx : extraction_ctx)
           ctx clauses)
       ctx types
   in
+  (* Required methods *)
+  (* TODO: for the methods, we need to add fields for the forward/backward functions *)
+  raise (Failure "TODO");
   List.fold_left
-    (fun ctx (name, _) -> ctx_add_trait_method trait_decl name ctx)
+    (fun ctx (name, id) -> ctx_add_trait_method trait_decl name ctx)
     ctx required_methods
 
 (** Similar to {!extract_type_decl_register_names} *)
-let extract_trait_impl_register_names (ctx : extraction_ctx) (d : trait_impl) :
-    extraction_ctx =
+let extract_trait_impl_register_names (ctx : extraction_ctx)
+    (trait_impl : trait_impl) : extraction_ctx =
+  (* For now we do not support overriding provided methods *)
+  assert (trait_impl.provided_methods = []);
+  (* Everything is actually taken care of by {!extract_trait_decl_register_names} *)
+  ctx
+
+(** Small helper.
+
+    The type `ty` is to be understood in a very general sense.
+ *)
+let extract_trait_decl_item (ctx : extraction_ctx) (fmt : F.formatter)
+    (item_name : string) (ty : unit -> unit) : unit =
+  F.pp_print_space fmt ();
+  F.pp_open_vbox fmt ctx.indent_incr;
+  F.pp_print_string fmt item_name;
+  F.pp_print_space fmt ();
+  F.pp_print_string fmt ":";
+  F.pp_print_space fmt ();
+  ty ();
+  F.pp_print_string fmt ";";
+  F.pp_close_box fmt ()
+
+(** Small helper.
+
+    Extract the items for a method in a trait decl.
+ *)
+let extract_trait_decl_method_items (ctx : extraction_ctx) (fmt : F.formatter)
+    (decl : trait_decl) (name : string) (id : fun_decl_id) : unit =
+  let item_name = ctx_get_trait_const decl.def_id name ctx in
+  (* Lookup the definition *)
+  (* let def =
+     FunDeclId.Map.find ctx.
+     in *)
   raise (Failure "TODO")
 
 (** Extract a trait declaration *)
 let extract_trait_decl (ctx : extraction_ctx) (fmt : F.formatter)
-    (trait_decl : trait_decl) : unit =
-  raise (Failure "TODO")
+    (decl : trait_decl) : unit =
+  (* Retrieve the trait name *)
+  let with_opaque_pre = false in
+  let decl_name = ctx_get_trait_decl with_opaque_pre decl.def_id ctx in
+  (* Add a break before *)
+  F.pp_print_break fmt 0 0;
+  (* Print a comment to link the extracted type to its original rust definition *)
+  extract_comment fmt [ "[" ^ Print.name_to_string decl.name ^ "]" ];
+  F.pp_print_break fmt 0 0;
+  (* Open two boxes for the definition, so that whenever possible it gets printed on
+   * one line and indents are correct *)
+  F.pp_open_hvbox fmt 0;
+  F.pp_open_vbox fmt ctx.indent_incr;
+
+  (* `struct Trait (....) =` *)
+  (* Open the box for the name + generics *)
+  F.pp_open_vbox fmt ctx.indent_incr;
+  let qualif =
+    Option.get (ctx.fmt.type_decl_kind_to_qualif SingleNonRec (Some Struct))
+  in
+  F.pp_print_string fmt qualif;
+  F.pp_print_space fmt ();
+  F.pp_print_string fmt decl_name;
+
+  (* Print the generics *)
+  (* We ignore the trait clauses, which we extract as *fields* *)
+  let generics = { decl.generics with trait_clauses = [] } in
+  (* Add the type and const generic params - note that we need those bindings only for the
+   * body translation (they are not top-level) *)
+  let ctx, type_params, cg_params, trait_clauses =
+    ctx_add_generic_params generics ctx
+  in
+  let use_forall = false in
+  let as_implicits = false in
+  extract_generic_params ctx fmt TypeDeclId.Set.empty use_forall as_implicits
+    None None decl.generics type_params cg_params trait_clauses;
+
+  F.pp_print_space fmt ();
+  F.pp_print_string fmt "{";
+
+  (* Close the box for the name + generics *)
+  F.pp_close_box fmt ();
+
+  (*
+   * Extract the items
+   *)
+
+  (* The parent clauses *)
+  List.iter
+    (fun clause ->
+      let item_name =
+        ctx_get_trait_parent_clause decl.def_id clause.clause_id ctx
+      in
+      let ty () =
+        extract_trait_clause_type ctx fmt TypeDeclId.Set.empty clause
+      in
+      extract_trait_decl_item ctx fmt item_name ty)
+    decl.generics.trait_clauses;
+
+  (* The constants *)
+  List.iter
+    (fun (name, (ty, _)) ->
+      let item_name = ctx_get_trait_const decl.def_id name ctx in
+      let ty () =
+        let inside = false in
+        extract_ty ctx fmt TypeDeclId.Set.empty inside ty
+      in
+      extract_trait_decl_item ctx fmt item_name ty)
+    decl.consts;
+
+  (* The types *)
+  List.iter
+    (fun (name, (clauses, _)) ->
+      (* Extract the type *)
+      let item_name = ctx_get_trait_type decl.def_id name ctx in
+      let ty () = F.pp_print_string fmt (type_keyword ()) in
+      extract_trait_decl_item ctx fmt item_name ty;
+      (* Extract the clauses *)
+      List.iter
+        (fun clause ->
+          let item_name =
+            ctx_get_trait_item_clause decl.def_id name clause.clause_id ctx
+          in
+          let ty () =
+            extract_trait_clause_type ctx fmt TypeDeclId.Set.empty clause
+          in
+          extract_trait_decl_item ctx fmt item_name ty)
+        clauses)
+    decl.types;
+
+  (* The required methods *)
+  List.iter
+    (fun (name, id) -> extract_trait_decl_method_items ctx fmt decl name id)
+    decl.required_methods;
+
+  (* Close the brackets *)
+  F.pp_print_space fmt ();
+  F.pp_print_string fmt "}";
+
+  (* Close the two outer boxes for the definition *)
+  F.pp_close_box fmt ();
+  F.pp_close_box fmt ();
+  (* Add breaks to insert new lines between definitions *)
+  F.pp_print_break fmt 0 0
 
 (** Extract a trait implementation *)
 let extract_trait_impl (ctx : extraction_ctx) (fmt : F.formatter)
diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index 7e6a2d40..26940c0c 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -621,6 +621,7 @@ type fun_name_info = { keep_fwd : bool; num_backs : int }
     functions, etc.
  *)
 type extraction_ctx = {
+  crate : A.crate;
   trans_ctx : trans_ctx;
   names_map : names_map;
       (** The map for id to names, where we forbid name collisions
@@ -661,6 +662,9 @@ type extraction_ctx = {
   trait_decl_id : trait_decl_id option;
       (** If we are extracting a trait declaration, identifies it *)
   is_provided_method : bool;
+  trans_types : Pure.type_decl Pure.TypeDeclId.Map.t;
+  trans_funs : (bool * pure_fun_translation) A.FunDeclId.Map.t;
+  functions_with_decreases_clause : PureUtils.FunLoopIdSet.t;
   trans_trait_decls : Pure.trait_decl Pure.TraitDeclId.Map.t;
   trans_trait_impls : Pure.trait_impl Pure.TraitImplId.Map.t;
 }
diff --git a/compiler/Translate.ml b/compiler/Translate.ml
index 8df69961..b26ce23b 100644
--- a/compiler/Translate.ml
+++ b/compiler/Translate.ml
@@ -396,14 +396,7 @@ let translate_crate_to_pure (crate : A.crate) :
   (* Return *)
   (trans_ctx, type_decls, pure_translations, trait_decls, trait_impls)
 
-(** Extraction context *)
-type gen_ctx = {
-  crate : A.crate;
-  extract_ctx : ExtractBase.extraction_ctx;
-  trans_types : Pure.type_decl Pure.TypeDeclId.Map.t;
-  trans_funs : (bool * pure_fun_translation) A.FunDeclId.Map.t;
-  functions_with_decreases_clause : PureUtils.FunLoopIdSet.t;
-}
+type gen_ctx = ExtractBase.extraction_ctx
 
 type gen_config = {
   extract_types : bool;
@@ -482,9 +475,9 @@ let export_type (fmt : Format.formatter) (config : gen_config) (ctx : gen_ctx)
     || ((not is_opaque) && config.extract_transparent)
   then (
     if extract_decl then
-      Extract.extract_type_decl ctx.extract_ctx fmt type_decl_group kind def;
+      Extract.extract_type_decl ctx fmt type_decl_group kind def;
     if extract_extra_info then
-      Extract.extract_type_decl_extra_info ctx.extract_ctx fmt kind def)
+      Extract.extract_type_decl_extra_info ctx fmt kind def)
 
 (** Export a group of types.
 
@@ -536,7 +529,7 @@ let export_types_group (fmt : Format.formatter) (config : gen_config)
        End
      ]}
   *)
-  Extract.start_type_decl_group ctx.extract_ctx fmt is_rec defs;
+  Extract.start_type_decl_group ctx fmt is_rec defs;
   List.iteri
     (fun i def ->
       let kind = kind_from_index i in
@@ -557,7 +550,7 @@ let export_types_group (fmt : Format.formatter) (config : gen_config)
  *)
 let export_global (fmt : Format.formatter) (config : gen_config) (ctx : gen_ctx)
     (id : A.GlobalDeclId.id) : unit =
-  let global_decls = ctx.extract_ctx.trans_ctx.global_context.global_decls in
+  let global_decls = ctx.trans_ctx.global_context.global_decls in
   let global = A.GlobalDeclId.Map.find id global_decls in
   let _, ((body, loop_fwds), body_backs) =
     A.FunDeclId.Map.find global.body_id ctx.trans_funs
@@ -576,7 +569,7 @@ let export_global (fmt : Format.formatter) (config : gen_config) (ctx : gen_ctx)
        groups are always singletons, so the [extract_global_decl] function
        takes care of generating the delimiters.
     *)
-    Extract.extract_global_decl ctx.extract_ctx fmt global body config.interface
+    Extract.extract_global_decl ctx fmt global body config.interface
 
 (** Utility.
 
@@ -657,14 +650,13 @@ let export_functions_group_scc (fmt : Format.formatter) (config : gen_config)
         then
           Some
             (fun () ->
-              Extract.extract_fun_decl ctx.extract_ctx fmt kind has_decr_clause
-                def)
+              Extract.extract_fun_decl ctx fmt kind has_decr_clause def)
         else None)
       decls
   in
   let extract_defs = List.filter_map (fun x -> x) extract_defs in
   if extract_defs <> [] then (
-    Extract.start_fun_decl_group ctx.extract_ctx fmt is_rec decls;
+    Extract.start_fun_decl_group ctx fmt is_rec decls;
     List.iter (fun f -> f ()) extract_defs;
     Extract.end_fun_decl_group fmt is_rec decls)
 
@@ -700,11 +692,10 @@ let export_functions_group (fmt : Format.formatter) (config : gen_config)
           if has_decr_clause then
             match !Config.backend with
             | Lean ->
-                Extract.extract_template_lean_termination_and_decreasing
-                  ctx.extract_ctx fmt decl
+                Extract.extract_template_lean_termination_and_decreasing ctx fmt
+                  decl
             | FStar ->
-                Extract.extract_template_fstar_decreases_clause ctx.extract_ctx
-                  fmt decl
+                Extract.extract_template_fstar_decreases_clause ctx fmt decl
             | Coq ->
                 raise (Failure "Coq doesn't have decreases/termination clauses")
             | HOL4 ->
@@ -747,27 +738,21 @@ let export_functions_group (fmt : Format.formatter) (config : gen_config)
   if config.test_trans_unit_functions then
     List.iter
       (fun (keep_fwd, ((fwd, _), _)) ->
-        if keep_fwd then
-          Extract.extract_unit_test_if_unit_fun ctx.extract_ctx fmt fwd)
+        if keep_fwd then Extract.extract_unit_test_if_unit_fun ctx fmt fwd)
       pure_ls
 
 (** Export a trait declaration. *)
 let export_trait_decl (fmt : Format.formatter) (_config : gen_config)
     (ctx : gen_ctx) (trait_decl_id : Pure.trait_decl_id) : unit =
-  let trait_decl =
-    T.TraitDeclId.Map.find trait_decl_id ctx.extract_ctx.trans_trait_decls
-  in
-  let ctx = ctx.extract_ctx in
+  let trait_decl = T.TraitDeclId.Map.find trait_decl_id ctx.trans_trait_decls in
   let ctx = { ctx with trait_decl_id = Some trait_decl.def_id } in
   Extract.extract_trait_decl ctx fmt trait_decl
 
 (** Export a trait implementation. *)
 let export_trait_impl (fmt : Format.formatter) (_config : gen_config)
     (ctx : gen_ctx) (trait_impl_id : Pure.trait_impl_id) : unit =
-  let trait_impl =
-    T.TraitImplId.Map.find trait_impl_id ctx.extract_ctx.trans_trait_impls
-  in
-  Extract.extract_trait_impl ctx.extract_ctx fmt trait_impl
+  let trait_impl = T.TraitImplId.Map.find trait_impl_id ctx.trans_trait_impls in
+  Extract.extract_trait_impl ctx fmt trait_impl
 
 (** A generic utility to generate the extracted definitions: as we may want to
     split the definitions between different files (or not), we can control
@@ -790,7 +775,7 @@ let extract_definitions (fmt : Format.formatter) (config : gen_config)
     let kind =
       if config.interface then ExtractBase.Declared else ExtractBase.Assumed
     in
-    Extract.extract_state_type fmt ctx.extract_ctx kind
+    Extract.extract_state_type fmt ctx kind
   in
 
   let export_decl_group (dg : A.declaration_group) : unit =
@@ -856,7 +841,7 @@ let extract_definitions (fmt : Format.formatter) (config : gen_config)
       if config.extract_transparent then "Definitions" else "OpaqueDefs"
     in
     Format.pp_print_break fmt 0 0;
-    Format.pp_open_vbox fmt ctx.extract_ctx.indent_incr;
+    Format.pp_open_vbox fmt ctx.indent_incr;
     Format.pp_print_string fmt ("structure " ^ struct_name ^ " where");
     Format.pp_print_break fmt 0 0);
   List.iter export_decl_group ctx.crate.declarations;
@@ -1005,6 +990,43 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
     mk_formatter_and_names_map trans_ctx crate.name
       variant_concatenate_type_name
   in
+
+  (* We need to compute which functions are recursive, in order to know
+   * whether we should generate a decrease clause or not. *)
+  let rec_functions =
+    List.map
+      (fun (_, ((fwd, loop_fwds), _)) ->
+        let fwd =
+          if fwd.Pure.signature.info.effect_info.is_rec then
+            [ (fwd.def_id, None) ]
+          else []
+        in
+        let loop_fwds =
+          List.map
+            (fun (def : Pure.fun_decl) -> [ (def.def_id, def.loop_id) ])
+            loop_fwds
+        in
+        fwd :: loop_fwds)
+      trans_funs
+  in
+  let rec_functions : PureUtils.fun_loop_id list =
+    List.concat (List.concat rec_functions)
+  in
+  let rec_functions = PureUtils.FunLoopIdSet.of_list rec_functions in
+
+  (* Put the translated definitions in maps *)
+  let trans_types =
+    Pure.TypeDeclId.Map.of_list
+      (List.map (fun (d : Pure.type_decl) -> (d.def_id, d)) trans_types)
+  in
+  let trans_funs =
+    A.FunDeclId.Map.of_list
+      (List.map
+         (fun ((keep_fwd, (fd, bdl)) : bool * pure_fun_translation) ->
+           ((fst fd).def_id, (keep_fwd, (fd, bdl))))
+         trans_funs)
+  in
+
   (* Put everything in the context *)
   let ctx =
     let trans_trait_decls =
@@ -1020,7 +1042,8 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
            trans_trait_impls)
     in
     {
-      ExtractBase.trans_ctx;
+      ExtractBase.crate;
+      trans_ctx;
       names_map;
       unsafe_names_map = { id_to_name = ExtractBase.IdMap.empty };
       fmt;
@@ -1032,32 +1055,12 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
       is_provided_method = false (* false by default *);
       trans_trait_decls;
       trans_trait_impls;
+      trans_types;
+      trans_funs;
+      functions_with_decreases_clause = rec_functions;
     }
   in
 
-  (* We need to compute which functions are recursive, in order to know
-   * whether we should generate a decrease clause or not. *)
-  let rec_functions =
-    List.map
-      (fun (_, ((fwd, loop_fwds), _)) ->
-        let fwd =
-          if fwd.Pure.signature.info.effect_info.is_rec then
-            [ (fwd.def_id, None) ]
-          else []
-        in
-        let loop_fwds =
-          List.map
-            (fun (def : Pure.fun_decl) -> [ (def.def_id, def.loop_id) ])
-            loop_fwds
-        in
-        fwd :: loop_fwds)
-      trans_funs
-  in
-  let rec_functions : PureUtils.fun_loop_id list =
-    List.concat (List.concat rec_functions)
-  in
-  let rec_functions = PureUtils.FunLoopIdSet.of_list rec_functions in
-
   (* Register unique names for all the top-level types, globals, functions...
    * Note that the order in which we generate the names doesn't matter:
    * we just need to generate a mapping from identifier to name, and make
@@ -1065,7 +1068,8 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
   let ctx =
     List.fold_left
       (fun ctx def -> Extract.extract_type_decl_register_names ctx def)
-      ctx trans_types
+      ctx
+      (Pure.TypeDeclId.Map.values trans_types)
   in
 
   let ctx =
@@ -1087,7 +1091,8 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
         else
           Extract.extract_fun_decl_register_names ctx keep_fwd gen_decr_clause
             defs)
-      ctx trans_funs
+      ctx
+      (A.FunDeclId.Map.values trans_funs)
   in
 
   let ctx =
@@ -1133,19 +1138,6 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
         (namespace, crate_name, Filename.concat dest_dir crate_name)
   in
 
-  (* Put the translated definitions in maps *)
-  let trans_types =
-    Pure.TypeDeclId.Map.of_list
-      (List.map (fun (d : Pure.type_decl) -> (d.def_id, d)) trans_types)
-  in
-  let trans_funs =
-    A.FunDeclId.Map.of_list
-      (List.map
-         (fun ((keep_fwd, (fd, bdl)) : bool * pure_fun_translation) ->
-           ((fst fd).def_id, (keep_fwd, (fd, bdl))))
-         trans_funs)
-  in
-
   let mkdir_if dest_dir =
     if not (Sys.file_exists dest_dir) then (
       log#linfo (lazy ("Creating missing directory: " ^ dest_dir));
@@ -1201,16 +1193,6 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
   in
 
   (* Extract the file(s) *)
-  let gen_ctx =
-    {
-      crate;
-      extract_ctx = ctx;
-      trans_types;
-      trans_funs;
-      functions_with_decreases_clause = rec_functions;
-    }
-  in
-
   let module_delimiter =
     match !Config.backend with
     | FStar -> "."
@@ -1257,7 +1239,7 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
 
      (* Check if there are opaque types and functions - in which case we need
       * to split *)
-     let has_opaque_types, has_opaque_funs = module_has_opaque_decls gen_ctx in
+     let has_opaque_types, has_opaque_funs = module_has_opaque_decls ctx in
      let has_opaque_types = has_opaque_types || !Config.use_state in
 
      (* Extract the types *)
@@ -1296,7 +1278,7 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
          custom_includes = [];
        }
      in
-     extract_file types_config gen_ctx file_info;
+     extract_file types_config ctx file_info;
 
      (* Extract the template clauses *)
      (if needs_clauses_module && !Config.extract_template_decreases_clauses then
@@ -1324,7 +1306,7 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
             custom_includes = [];
           }
         in
-        extract_file template_clauses_config gen_ctx file_info);
+        extract_file template_clauses_config ctx file_info);
 
      (* Extract the opaque functions, if needed *)
      let opaque_funs_module =
@@ -1359,12 +1341,7 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
              interface = true;
            }
          in
-         let gen_ctx =
-           {
-             gen_ctx with
-             extract_ctx = { gen_ctx.extract_ctx with use_opaque_pre = false };
-           }
-         in
+         let ctx = { ctx with use_opaque_pre = false } in
          let file_info =
            {
              filename = opaque_filename;
@@ -1378,7 +1355,7 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
              custom_includes = [ types_module ];
            }
          in
-         extract_file opaque_config gen_ctx file_info;
+         extract_file opaque_config ctx file_info;
          (* Return the additional dependencies *)
          [ opaque_imported_module ])
        else []
@@ -1417,7 +1394,7 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
            [ types_module ] @ opaque_funs_module @ clauses_module;
        }
      in
-     extract_file fun_config gen_ctx file_info)
+     extract_file fun_config ctx file_info)
    else
      let gen_config =
        {
@@ -1447,7 +1424,7 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
          custom_includes = [];
        }
      in
-     extract_file gen_config gen_ctx file_info);
+     extract_file gen_config ctx file_info);
 
   (* Generate the build file *)
   match !Config.backend with
-- 
cgit v1.3.1


From cce09bb0fb64b07b07613d7db59857651e040c20 Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Sun, 3 Sep 2023 19:29:11 +0200
Subject: Update TranslateCore.pure_fun_translation

---
 compiler/Extract.ml         |  3 ++-
 compiler/ExtractBase.ml     |  2 +-
 compiler/PureMicroPasses.ml | 20 ++++++++++----------
 compiler/Translate.ml       | 40 +++++++++++++++++++---------------------
 compiler/TranslateCore.ml   |  2 +-
 5 files changed, 33 insertions(+), 34 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/compiler/Extract.ml b/compiler/Extract.ml
index 73a081a7..5c0a08ad 100644
--- a/compiler/Extract.ml
+++ b/compiler/Extract.ml
@@ -2329,7 +2329,8 @@ let extract_state_type (fmt : F.formatter) (ctx : extraction_ctx)
 let extract_fun_decl_register_names (ctx : extraction_ctx) (keep_fwd : bool)
     (has_decreases_clause : fun_decl -> bool) (def : pure_fun_translation) :
     extraction_ctx =
-  let { f = fwd; loops = loop_fwds }, back_ls = def in
+  let { f = fwd; loops = loop_fwds } = def.fwd in
+  let back_ls = def.backs in
   (* Register the decrease clauses, if necessary *)
   let register_decreases ctx def =
     if has_decreases_clause def then
diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index 26940c0c..7a21d42d 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -1197,7 +1197,7 @@ let ctx_add_fun_decl (trans_group : bool * pure_fun_translation)
   in
   let sg = llbc_def.signature in
   let num_rgs = List.length sg.regions_hierarchy in
-  let keep_fwd, (_, backs) = trans_group in
+  let keep_fwd, { fwd = _; backs } = trans_group in
   let num_backs = List.length backs in
   let rg_info =
     match def.back_id with
diff --git a/compiler/PureMicroPasses.ml b/compiler/PureMicroPasses.ml
index 72e3d05e..e97a9cd7 100644
--- a/compiler/PureMicroPasses.ml
+++ b/compiler/PureMicroPasses.ml
@@ -1461,12 +1461,12 @@ let decompose_loops (def : fun_decl) : fun_decl * fun_decl list =
     altogether.
   *)
 let keep_forward (trans : pure_fun_translation) : bool =
-  let { f = fwd; _ }, backs = trans in
+  let { fwd; backs } = trans in
   (* Note that at this point, the output types are no longer seen as tuples:
    * they should be lists of length 1. *)
   if
     !Config.filter_useless_functions
-    && fwd.signature.output = mk_result_ty mk_unit_ty
+    && fwd.f.signature.output = mk_result_ty mk_unit_ty
     && backs <> []
   then false
   else true
@@ -1996,8 +1996,8 @@ let filter_loop_inputs (transl : (bool * pure_fun_translation) list) :
       (List.concat
          (List.concat
             (List.map
-               (fun (_, ({ f = fwd; loops = loops_fwd }, backs)) ->
-                 [ fwd :: loops_fwd ]
+               (fun (_, { fwd; backs }) ->
+                 [ fwd.f :: fwd.loops ]
                  :: List.map
                       (fun { f = back; loops = loops_back } ->
                         [ back :: loops_back ])
@@ -2246,13 +2246,13 @@ let filter_loop_inputs (transl : (bool * pure_fun_translation) list) :
   in
   let transl =
     List.map
-      (fun (b, (fwd, backs)) ->
+      (fun (b, { fwd; backs }) ->
         let filter_fun_and_loops f =
           { f = filter_in_one f.f; loops = List.map filter_in_one f.loops }
         in
         let fwd = filter_fun_and_loops fwd in
         let backs = List.map filter_fun_and_loops backs in
-        (b, (fwd, backs)))
+        (b, { fwd; backs }))
       transl
   in
 
@@ -2278,10 +2278,10 @@ let apply_passes_to_pure_fun_translations (ctx : trans_ctx)
   let apply_to_one (trans : fun_decl * fun_decl list) :
       bool * pure_fun_translation =
     (* Apply the passes to the individual functions *)
-    let forward, backwards = trans in
-    let forward = Option.get (apply_passes_to_def ctx forward) in
-    let backwards = List.filter_map (apply_passes_to_def ctx) backwards in
-    let trans = (forward, backwards) in
+    let fwd, backs = trans in
+    let fwd = Option.get (apply_passes_to_def ctx fwd) in
+    let backs = List.filter_map (apply_passes_to_def ctx) backs in
+    let trans = { fwd; backs } in
     (* Compute whether we need to filter the forward function or not *)
     (keep_forward trans, trans)
   in
diff --git a/compiler/Translate.ml b/compiler/Translate.ml
index 2f751693..7122e462 100644
--- a/compiler/Translate.ml
+++ b/compiler/Translate.ml
@@ -439,8 +439,8 @@ let module_has_opaque_decls (ctx : gen_ctx) : bool * bool =
   in
   let has_opaque_funs =
     A.FunDeclId.Map.exists
-      (fun _ ((_, (fwd, _)) : bool * pure_fun_translation) ->
-        Option.is_none fwd.f.body)
+      (fun _ ((_, trans) : bool * pure_fun_translation) ->
+        Option.is_none trans.fwd.f.body)
       ctx.trans_funs
   in
   (has_opaque_types, has_opaque_funs)
@@ -552,11 +552,10 @@ let export_global (fmt : Format.formatter) (config : gen_config) (ctx : gen_ctx)
     (id : A.GlobalDeclId.id) : unit =
   let global_decls = ctx.trans_ctx.global_context.global_decls in
   let global = A.GlobalDeclId.Map.find id global_decls in
-  let _, ({ f = body; loops = loop_fwds }, body_backs) =
-    A.FunDeclId.Map.find global.body_id ctx.trans_funs
-  in
-  assert (body_backs = []);
-  assert (loop_fwds = []);
+  let _, trans = A.FunDeclId.Map.find global.body_id ctx.trans_funs in
+  assert (trans.fwd.loops = []);
+  assert (trans.backs = []);
+  let body = trans.fwd.f in
 
   let is_opaque = Option.is_none body.Pure.body in
   if
@@ -676,7 +675,7 @@ let export_functions_group (fmt : Format.formatter) (config : gen_config)
   (* Extract the decrease clauses template bodies *)
   if config.extract_template_decreases_clauses then
     List.iter
-      (fun (_, (fwd, _)) ->
+      (fun (_, { fwd; _ }) ->
         (* We only generate decreases clauses for the forward functions, because
            the termination argument should only depend on the forward inputs.
            The backward functions thus use the same decreases clauses as the
@@ -711,15 +710,13 @@ let export_functions_group (fmt : Format.formatter) (config : gen_config)
   let decls =
     List.concat
       (List.map
-         (fun (keep_fwd, (fwd, (back_ls : fun_and_loops list))) ->
+         (fun (keep_fwd, { fwd; backs }) ->
            let fwd = if keep_fwd then List.append fwd.loops [ fwd.f ] else [] in
-           let back : Pure.fun_decl list =
+           let backs : Pure.fun_decl list =
              List.concat
-               (List.map
-                  (fun back -> List.append back.loops [ back.f ])
-                  back_ls)
+               (List.map (fun back -> List.append back.loops [ back.f ]) backs)
            in
-           List.append fwd back)
+           List.append fwd backs)
          pure_ls)
   in
 
@@ -737,8 +734,9 @@ let export_functions_group (fmt : Format.formatter) (config : gen_config)
   (* Insert unit tests if necessary *)
   if config.test_trans_unit_functions then
     List.iter
-      (fun (keep_fwd, (fwd, _)) ->
-        if keep_fwd then Extract.extract_unit_test_if_unit_fun ctx fmt fwd.f)
+      (fun (keep_fwd, trans) ->
+        if keep_fwd then
+          Extract.extract_unit_test_if_unit_fun ctx fmt trans.fwd.f)
       pure_ls
 
 (** Export a trait declaration. *)
@@ -790,7 +788,7 @@ let extract_definitions (fmt : Format.formatter) (config : gen_config)
            extract their type directly in the records we generate for
            the trait declarations themselves, there is no point in having
            separate type definitions) *)
-        match (fst (snd pure_fun)).f.Pure.kind with
+        match (snd pure_fun).fwd.f.Pure.kind with
         | TraitMethodDecl _ -> ()
         | _ ->
             (* Translate *)
@@ -995,7 +993,7 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
    * whether we should generate a decrease clause or not. *)
   let rec_functions =
     List.map
-      (fun (_, (fwd, _)) ->
+      (fun (_, { fwd; _ }) ->
         let fwd_f =
           if fwd.f.Pure.signature.info.effect_info.is_rec then
             [ (fwd.f.def_id, None) ]
@@ -1022,8 +1020,8 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
   let trans_funs : (bool * pure_fun_translation) A.FunDeclId.Map.t =
     A.FunDeclId.Map.of_list
       (List.map
-         (fun ((keep_fwd, (fwd, bdl)) : bool * pure_fun_translation) ->
-           (fwd.f.def_id, (keep_fwd, (fwd, bdl))))
+         (fun ((keep_fwd, { fwd; backs }) : bool * pure_fun_translation) ->
+           (fwd.f.def_id, (keep_fwd, { fwd; backs })))
          trans_funs)
   in
 
@@ -1077,7 +1075,7 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
       (fun ctx ((keep_fwd, defs) : bool * pure_fun_translation) ->
         (* If requested by the user, register termination measures and decreases
            proofs for all the recursive functions *)
-        let fwd_def = (fst defs).f in
+        let fwd_def = defs.fwd.f in
         let gen_decr_clause (def : Pure.fun_decl) =
           !Config.extract_decreases_clauses
           && PureUtils.FunLoopIdSet.mem
diff --git a/compiler/TranslateCore.ml b/compiler/TranslateCore.ml
index 9694c95e..9fd27c59 100644
--- a/compiler/TranslateCore.ml
+++ b/compiler/TranslateCore.ml
@@ -33,7 +33,7 @@ type trans_ctx = {
 
 type fun_and_loops = { f : Pure.fun_decl; loops : Pure.fun_decl list }
 type pure_fun_translation_no_loops = Pure.fun_decl * Pure.fun_decl list
-type pure_fun_translation = fun_and_loops * fun_and_loops list
+type pure_fun_translation = { fwd : fun_and_loops; backs : fun_and_loops list }
 
 let trans_ctx_to_type_formatter (ctx : trans_ctx)
     (type_params : Pure.type_var list)
-- 
cgit v1.3.1


From dfcbfab4030be2f03b159a4b298ed75ac2f236ae Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Sun, 3 Sep 2023 19:41:03 +0200
Subject: Add the keep_fwd field in TranslateCore.pure_fun_translation

---
 compiler/ExtractBase.ml     |  2 +-
 compiler/PureMicroPasses.ml | 28 +++++++++++++---------------
 compiler/Translate.ml       | 34 ++++++++++++++++------------------
 compiler/TranslateCore.ml   | 13 ++++++++++++-
 4 files changed, 42 insertions(+), 35 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index 7a21d42d..885467c2 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -663,7 +663,7 @@ type extraction_ctx = {
       (** If we are extracting a trait declaration, identifies it *)
   is_provided_method : bool;
   trans_types : Pure.type_decl Pure.TypeDeclId.Map.t;
-  trans_funs : (bool * pure_fun_translation) A.FunDeclId.Map.t;
+  trans_funs : pure_fun_translation A.FunDeclId.Map.t;
   functions_with_decreases_clause : PureUtils.FunLoopIdSet.t;
   trans_trait_decls : Pure.trait_decl Pure.TraitDeclId.Map.t;
   trans_trait_impls : Pure.trait_impl Pure.TraitImplId.Map.t;
diff --git a/compiler/PureMicroPasses.ml b/compiler/PureMicroPasses.ml
index e97a9cd7..6c9c3a91 100644
--- a/compiler/PureMicroPasses.ml
+++ b/compiler/PureMicroPasses.ml
@@ -1460,8 +1460,7 @@ let decompose_loops (def : fun_decl) : fun_decl * fun_decl list =
     In such situation, we can remove the forward function definition
     altogether.
   *)
-let keep_forward (trans : pure_fun_translation) : bool =
-  let { fwd; backs } = trans in
+let keep_forward (fwd : fun_and_loops) (backs : fun_and_loops list) : bool =
   (* Note that at this point, the output types are no longer seen as tuples:
    * they should be lists of length 1. *)
   if
@@ -1977,8 +1976,8 @@ end
 module FunLoopIdMap = Collections.MakeMap (FunLoopIdOrderedType)
 
 (** Filter the useless loop input parameters. *)
-let filter_loop_inputs (transl : (bool * pure_fun_translation) list) :
-    (bool * pure_fun_translation) list =
+let filter_loop_inputs (transl : pure_fun_translation list) :
+    pure_fun_translation list =
   (* We need to explore groups of mutually recursive functions. In order
      to compute which parameters are useless, we need to explore the
      functions by groups of mutually recursive definitions.
@@ -1996,7 +1995,7 @@ let filter_loop_inputs (transl : (bool * pure_fun_translation) list) :
       (List.concat
          (List.concat
             (List.map
-               (fun (_, { fwd; backs }) ->
+               (fun { fwd; backs; _ } ->
                  [ fwd.f :: fwd.loops ]
                  :: List.map
                       (fun { f = back; loops = loops_back } ->
@@ -2246,13 +2245,13 @@ let filter_loop_inputs (transl : (bool * pure_fun_translation) list) :
   in
   let transl =
     List.map
-      (fun (b, { fwd; backs }) ->
+      (fun trans ->
         let filter_fun_and_loops f =
           { f = filter_in_one f.f; loops = List.map filter_in_one f.loops }
         in
-        let fwd = filter_fun_and_loops fwd in
-        let backs = List.map filter_fun_and_loops backs in
-        (b, { fwd; backs }))
+        let fwd = filter_fun_and_loops trans.fwd in
+        let backs = List.map filter_fun_and_loops trans.backs in
+        { trans with fwd; backs })
       transl
   in
 
@@ -2273,18 +2272,17 @@ let filter_loop_inputs (transl : (bool * pure_fun_translation) list) :
     but convenient.
  *)
 let apply_passes_to_pure_fun_translations (ctx : trans_ctx)
-    (transl : (fun_decl * fun_decl list) list) :
-    (bool * pure_fun_translation) list =
-  let apply_to_one (trans : fun_decl * fun_decl list) :
-      bool * pure_fun_translation =
+    (transl : (fun_decl * fun_decl list) list) : pure_fun_translation list =
+  let apply_to_one (trans : fun_decl * fun_decl list) : pure_fun_translation =
     (* Apply the passes to the individual functions *)
     let fwd, backs = trans in
     let fwd = Option.get (apply_passes_to_def ctx fwd) in
     let backs = List.filter_map (apply_passes_to_def ctx) backs in
-    let trans = { fwd; backs } in
     (* Compute whether we need to filter the forward function or not *)
-    (keep_forward trans, trans)
+    let keep_fwd = keep_forward fwd backs in
+    { keep_fwd; fwd; backs }
   in
+
   let transl = List.map apply_to_one transl in
 
   (* Filter the useless inputs in the loop functions *)
diff --git a/compiler/Translate.ml b/compiler/Translate.ml
index 7122e462..835edd46 100644
--- a/compiler/Translate.ml
+++ b/compiler/Translate.ml
@@ -305,7 +305,7 @@ let translate_function_to_pure (trans_ctx : trans_ctx)
 let translate_crate_to_pure (crate : A.crate) :
     trans_ctx
     * Pure.type_decl list
-    * (bool * pure_fun_translation) list
+    * pure_fun_translation list
     * Pure.trait_decl list
     * Pure.trait_impl list =
   (* Debug *)
@@ -439,8 +439,7 @@ let module_has_opaque_decls (ctx : gen_ctx) : bool * bool =
   in
   let has_opaque_funs =
     A.FunDeclId.Map.exists
-      (fun _ ((_, trans) : bool * pure_fun_translation) ->
-        Option.is_none trans.fwd.f.body)
+      (fun _ (trans : pure_fun_translation) -> Option.is_none trans.fwd.f.body)
       ctx.trans_funs
   in
   (has_opaque_types, has_opaque_funs)
@@ -552,7 +551,7 @@ let export_global (fmt : Format.formatter) (config : gen_config) (ctx : gen_ctx)
     (id : A.GlobalDeclId.id) : unit =
   let global_decls = ctx.trans_ctx.global_context.global_decls in
   let global = A.GlobalDeclId.Map.find id global_decls in
-  let _, trans = A.FunDeclId.Map.find global.body_id ctx.trans_funs in
+  let trans = A.FunDeclId.Map.find global.body_id ctx.trans_funs in
   assert (trans.fwd.loops = []);
   assert (trans.backs = []);
   let body = trans.fwd.f in
@@ -665,7 +664,7 @@ let export_functions_group_scc (fmt : Format.formatter) (config : gen_config)
     check if the forward and backward functions are mutually recursive.
  *)
 let export_functions_group (fmt : Format.formatter) (config : gen_config)
-    (ctx : gen_ctx) (pure_ls : (bool * pure_fun_translation) list) : unit =
+    (ctx : gen_ctx) (pure_ls : pure_fun_translation list) : unit =
   (* Utility to check a function has a decrease clause *)
   let has_decreases_clause (def : Pure.fun_decl) : bool =
     PureUtils.FunLoopIdSet.mem (def.def_id, def.loop_id)
@@ -675,7 +674,7 @@ let export_functions_group (fmt : Format.formatter) (config : gen_config)
   (* Extract the decrease clauses template bodies *)
   if config.extract_template_decreases_clauses then
     List.iter
-      (fun (_, { fwd; _ }) ->
+      (fun { fwd; _ } ->
         (* We only generate decreases clauses for the forward functions, because
            the termination argument should only depend on the forward inputs.
            The backward functions thus use the same decreases clauses as the
@@ -710,7 +709,7 @@ let export_functions_group (fmt : Format.formatter) (config : gen_config)
   let decls =
     List.concat
       (List.map
-         (fun (keep_fwd, { fwd; backs }) ->
+         (fun { keep_fwd; fwd; backs } ->
            let fwd = if keep_fwd then List.append fwd.loops [ fwd.f ] else [] in
            let backs : Pure.fun_decl list =
              List.concat
@@ -734,8 +733,8 @@ let export_functions_group (fmt : Format.formatter) (config : gen_config)
   (* Insert unit tests if necessary *)
   if config.test_trans_unit_functions then
     List.iter
-      (fun (keep_fwd, trans) ->
-        if keep_fwd then
+      (fun trans ->
+        if trans.keep_fwd then
           Extract.extract_unit_test_if_unit_fun ctx fmt trans.fwd.f)
       pure_ls
 
@@ -788,7 +787,7 @@ let extract_definitions (fmt : Format.formatter) (config : gen_config)
            extract their type directly in the records we generate for
            the trait declarations themselves, there is no point in having
            separate type definitions) *)
-        match (snd pure_fun).fwd.f.Pure.kind with
+        match pure_fun.fwd.f.Pure.kind with
         | TraitMethodDecl _ -> ()
         | _ ->
             (* Translate *)
@@ -993,7 +992,7 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
    * whether we should generate a decrease clause or not. *)
   let rec_functions =
     List.map
-      (fun (_, { fwd; _ }) ->
+      (fun { fwd; _ } ->
         let fwd_f =
           if fwd.f.Pure.signature.info.effect_info.is_rec then
             [ (fwd.f.def_id, None) ]
@@ -1017,11 +1016,10 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
     Pure.TypeDeclId.Map.of_list
       (List.map (fun (d : Pure.type_decl) -> (d.def_id, d)) trans_types)
   in
-  let trans_funs : (bool * pure_fun_translation) A.FunDeclId.Map.t =
+  let trans_funs : pure_fun_translation A.FunDeclId.Map.t =
     A.FunDeclId.Map.of_list
       (List.map
-         (fun ((keep_fwd, { fwd; backs }) : bool * pure_fun_translation) ->
-           (fwd.f.def_id, (keep_fwd, { fwd; backs })))
+         (fun (trans : pure_fun_translation) -> (trans.fwd.f.def_id, trans))
          trans_funs)
   in
 
@@ -1072,10 +1070,10 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
 
   let ctx =
     List.fold_left
-      (fun ctx ((keep_fwd, defs) : bool * pure_fun_translation) ->
+      (fun ctx (trans : pure_fun_translation) ->
         (* If requested by the user, register termination measures and decreases
            proofs for all the recursive functions *)
-        let fwd_def = defs.fwd.f in
+        let fwd_def = trans.fwd.f in
         let gen_decr_clause (def : Pure.fun_decl) =
           !Config.extract_decreases_clauses
           && PureUtils.FunLoopIdSet.mem
@@ -1087,8 +1085,8 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
         let is_global = fwd_def.Pure.is_global_decl_body in
         if is_global then ctx
         else
-          Extract.extract_fun_decl_register_names ctx keep_fwd gen_decr_clause
-            defs)
+          Extract.extract_fun_decl_register_names ctx trans.keep_fwd
+            gen_decr_clause trans)
       ctx
       (A.FunDeclId.Map.values trans_funs)
   in
diff --git a/compiler/TranslateCore.ml b/compiler/TranslateCore.ml
index 9fd27c59..f31dc458 100644
--- a/compiler/TranslateCore.ml
+++ b/compiler/TranslateCore.ml
@@ -33,7 +33,18 @@ type trans_ctx = {
 
 type fun_and_loops = { f : Pure.fun_decl; loops : Pure.fun_decl list }
 type pure_fun_translation_no_loops = Pure.fun_decl * Pure.fun_decl list
-type pure_fun_translation = { fwd : fun_and_loops; backs : fun_and_loops list }
+
+type pure_fun_translation = {
+  keep_fwd : bool;
+      (** Should we extract the forward function?
+
+          If the forward function returns `()` and there is exactly one
+          backward function, we may merge the forward into the backward
+          function and thus don't extract the forward function)?
+       *)
+  fwd : fun_and_loops;
+  backs : fun_and_loops list;
+}
 
 let trans_ctx_to_type_formatter (ctx : trans_ctx)
     (type_params : Pure.type_var list)
-- 
cgit v1.3.1


From e090e09725e3fd5c7f2a92813955ce2d81560227 Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Sun, 3 Sep 2023 19:44:39 +0200
Subject: Do more cleanup

---
 compiler/Extract.ml     | 8 +++++---
 compiler/ExtractBase.ml | 6 +++---
 compiler/Translate.ml   | 4 +---
 3 files changed, 9 insertions(+), 9 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/compiler/Extract.ml b/compiler/Extract.ml
index 5c0a08ad..204fee04 100644
--- a/compiler/Extract.ml
+++ b/compiler/Extract.ml
@@ -2326,7 +2326,7 @@ let extract_state_type (fmt : F.formatter) (ctx : extraction_ctx)
 (** Compute the names for all the pure functions generated from a rust function
     (forward function and backward functions).
  *)
-let extract_fun_decl_register_names (ctx : extraction_ctx) (keep_fwd : bool)
+let extract_fun_decl_register_names (ctx : extraction_ctx)
     (has_decreases_clause : fun_decl -> bool) (def : pure_fun_translation) :
     extraction_ctx =
   let { f = fwd; loops = loop_fwds } = def.fwd in
@@ -2344,7 +2344,7 @@ let extract_fun_decl_register_names (ctx : extraction_ctx) (keep_fwd : bool)
     else ctx
   in
   let ctx = List.fold_left register_decreases ctx (fwd :: loop_fwds) in
-  let register_fun ctx f = ctx_add_fun_decl (keep_fwd, def) f ctx in
+  let register_fun ctx f = ctx_add_fun_decl def f ctx in
   let register_funs ctx fl = List.fold_left register_fun ctx fl in
   (* Register the forward functions' names *)
   let ctx = register_funs ctx (fwd :: loop_fwds) in
@@ -3971,7 +3971,9 @@ let extract_trait_decl_register_names (ctx : extraction_ctx)
   (* TODO: for the methods, we need to add fields for the forward/backward functions *)
   raise (Failure "TODO");
   List.fold_left
-    (fun ctx (name, id) -> ctx_add_trait_method trait_decl name ctx)
+    (fun ctx (name, id) ->
+      (* We add one field per required forward/backward function *)
+      ctx_add_trait_method trait_decl name ctx)
     ctx required_methods
 
 (** Similar to {!extract_type_decl_register_names} *)
diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index 885467c2..17f5b693 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -1185,8 +1185,8 @@ let ctx_add_global_decl_and_body (def : A.global_decl) (ctx : extraction_ctx) :
   let ctx = ctx_add is_opaque body (name ^ "_body") ctx in
   ctx
 
-let ctx_add_fun_decl (trans_group : bool * pure_fun_translation)
-    (def : fun_decl) (ctx : extraction_ctx) : extraction_ctx =
+let ctx_add_fun_decl (trans_group : pure_fun_translation) (def : fun_decl)
+    (ctx : extraction_ctx) : extraction_ctx =
   (* Sanity check: the function should not be a global body - those are handled
    * separately *)
   assert (not def.is_global_decl_body);
@@ -1197,7 +1197,7 @@ let ctx_add_fun_decl (trans_group : bool * pure_fun_translation)
   in
   let sg = llbc_def.signature in
   let num_rgs = List.length sg.regions_hierarchy in
-  let keep_fwd, { fwd = _; backs } = trans_group in
+  let { keep_fwd; fwd = _; backs } = trans_group in
   let num_backs = List.length backs in
   let rg_info =
     match def.back_id with
diff --git a/compiler/Translate.ml b/compiler/Translate.ml
index 835edd46..a4041751 100644
--- a/compiler/Translate.ml
+++ b/compiler/Translate.ml
@@ -1084,9 +1084,7 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
          * those are handled later *)
         let is_global = fwd_def.Pure.is_global_decl_body in
         if is_global then ctx
-        else
-          Extract.extract_fun_decl_register_names ctx trans.keep_fwd
-            gen_decr_clause trans)
+        else Extract.extract_fun_decl_register_names ctx gen_decr_clause trans)
       ctx
       (A.FunDeclId.Map.values trans_funs)
   in
-- 
cgit v1.3.1


From fcd1fbe048b55a89bd8ed34afa8ed2295798d3ec Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Sun, 3 Sep 2023 20:12:59 +0200
Subject: Make progress registering the trait decl method names

---
 compiler/Extract.ml     | 50 +++++++++++++++++++++------------
 compiler/ExtractBase.ml | 74 +++++++++++++++++++++++++++++++++++++++----------
 2 files changed, 93 insertions(+), 31 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/compiler/Extract.ml b/compiler/Extract.ml
index 204fee04..2a678a27 100644
--- a/compiler/Extract.ml
+++ b/compiler/Extract.ml
@@ -2329,8 +2329,8 @@ let extract_state_type (fmt : F.formatter) (ctx : extraction_ctx)
 let extract_fun_decl_register_names (ctx : extraction_ctx)
     (has_decreases_clause : fun_decl -> bool) (def : pure_fun_translation) :
     extraction_ctx =
-  let { f = fwd; loops = loop_fwds } = def.fwd in
-  let back_ls = def.backs in
+  let fwd = def.fwd in
+  let backs = def.backs in
   (* Register the decrease clauses, if necessary *)
   let register_decreases ctx def =
     if has_decreases_clause def then
@@ -2343,22 +2343,19 @@ let extract_fun_decl_register_names (ctx : extraction_ctx)
       | Lean -> ctx_add_decreases_proof def ctx
     else ctx
   in
-  let ctx = List.fold_left register_decreases ctx (fwd :: loop_fwds) in
+  let ctx = List.fold_left register_decreases ctx (fwd.f :: fwd.loops) in
   let register_fun ctx f = ctx_add_fun_decl def f ctx in
   let register_funs ctx fl = List.fold_left register_fun ctx fl in
-  (* Register the forward functions' names *)
-  let ctx = register_funs ctx (fwd :: loop_fwds) in
-  (* Register the backward functions' names *)
+  (* Register the names of the forward functions *)
   let ctx =
-    List.fold_left
-      (fun ctx { f = back; loops = loop_backs } ->
-        let ctx = register_fun ctx back in
-        register_funs ctx loop_backs)
-      ctx back_ls
+    if def.keep_fwd then register_funs ctx (fwd.f :: fwd.loops) else ctx
   in
-
-  (* Return *)
-  ctx
+  (* Register the names of the backward functions *)
+  List.fold_left
+    (fun ctx { f = back; loops = loop_backs } ->
+      let ctx = register_fun ctx back in
+      register_funs ctx loop_backs)
+    ctx backs
 
 (** Simply add the global name to the context. *)
 let extract_global_decl_register_names (ctx : extraction_ctx)
@@ -3927,6 +3924,27 @@ let extract_global_decl (ctx : extraction_ctx) (fmt : F.formatter)
       (* Add a break to insert lines between declarations *)
       F.pp_print_break fmt 0 0
 
+(** Register the names for one trait method item *)
+let extract_trait_decl_method_register_names (ctx : extraction_ctx)
+    (trait_decl : trait_decl) (name : string) (id : fun_decl_id) :
+    extraction_ctx =
+  (* We add one field per required forward/backward function *)
+  let trans = A.FunDeclId.Map.find id ctx.trans_funs in
+
+  let register_fun ctx f = ctx_add_trait_method trait_decl name f ctx in
+  let register_funs ctx fl = List.fold_left register_fun ctx fl in
+  (* Register the names of the forward functions *)
+  let ctx =
+    if trans.keep_fwd then register_funs ctx (trans.fwd.f :: trans.fwd.loops)
+    else ctx
+  in
+  (* Register the names of the backward functions *)
+  List.fold_left
+    (fun ctx back ->
+      let ctx = register_fun ctx back.f in
+      register_funs ctx back.loops)
+    ctx trans.backs
+
 (** Similar to {!extract_type_decl_register_names} *)
 let extract_trait_decl_register_names (ctx : extraction_ctx)
     (trait_decl : trait_decl) : extraction_ctx =
@@ -3968,12 +3986,10 @@ let extract_trait_decl_register_names (ctx : extraction_ctx)
       ctx types
   in
   (* Required methods *)
-  (* TODO: for the methods, we need to add fields for the forward/backward functions *)
-  raise (Failure "TODO");
   List.fold_left
     (fun ctx (name, id) ->
       (* We add one field per required forward/backward function *)
-      ctx_add_trait_method trait_decl name ctx)
+      extract_trait_decl_method_register_names ctx trait_decl name id)
     ctx required_methods
 
 (** Similar to {!extract_type_decl_register_names} *)
diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index 17f5b693..e4d1fb7b 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -417,7 +417,14 @@ type id =
   | TraitDeclId of TraitDeclId.id
   | TraitImplId of TraitImplId.id
   | LocalTraitClauseId of TraitClauseId.id
-  | TraitItemId of TraitDeclId.id * string  (** A trait associated item *)
+  | TraitMethodId of
+      TraitDeclId.id * string * LoopId.id option * T.RegionGroupId.id option
+      (** Something peculiar with trait methods: because we have to take into
+          account forward/backward functions, we may need to generate fields
+          items per method.
+       *)
+  | TraitItemId of TraitDeclId.id * string
+      (** A trait associated item which is not a method *)
   | TraitParentClauseId of TraitDeclId.id * TraitClauseId.id
   | TraitItemClauseId of TraitDeclId.id * string * TraitClauseId.id
   | TraitSelfClauseId
@@ -677,6 +684,7 @@ let id_to_string (id : id) (ctx : extraction_ctx) : string =
   let global_decls = ctx.trans_ctx.global_context.global_decls in
   let fun_decls = ctx.trans_ctx.fun_context.fun_decls in
   let type_decls = ctx.trans_ctx.type_context.type_decls in
+  let trait_decls = ctx.trans_ctx.trait_decls_context.trait_decls in
   (* TODO: factorize the pretty-printing with what is in PrintPure *)
   let get_type_name (id : type_id) : string =
     match id with
@@ -812,6 +820,24 @@ let id_to_string (id : id) (ctx : extraction_ctx) : string =
   | TraitItemId (id, name) ->
       "trait_item_id: decl_id:" ^ TraitDeclId.to_string id ^ ", type name: "
       ^ name
+  | TraitMethodId (trait_decl_id, fun_name, lp_id, rg_id) ->
+      let trait_name =
+        Print.fun_name_to_string
+          (A.TraitDeclId.Map.find trait_decl_id trait_decls).name
+      in
+      let lp_kind =
+        match lp_id with
+        | None -> ""
+        | Some lp_id -> "loop " ^ LoopId.to_string lp_id ^ ", "
+      in
+
+      let fwd_back_kind =
+        match rg_id with
+        | None -> "forward"
+        | Some rg_id -> "backward " ^ RegionGroupId.to_string rg_id
+      in
+      "trait " ^ trait_name ^ " method name (" ^ lp_kind ^ fwd_back_kind ^ "): "
+      ^ fun_name
   | TraitSelfClauseId -> "trait_self_clause"
 
 (** We might not check for collisions for some specific ids (ex.: field names) *)
@@ -1185,11 +1211,8 @@ let ctx_add_global_decl_and_body (def : A.global_decl) (ctx : extraction_ctx) :
   let ctx = ctx_add is_opaque body (name ^ "_body") ctx in
   ctx
 
-let ctx_add_fun_decl (trans_group : pure_fun_translation) (def : fun_decl)
-    (ctx : extraction_ctx) : extraction_ctx =
-  (* Sanity check: the function should not be a global body - those are handled
-   * separately *)
-  assert (not def.is_global_decl_body);
+let ctx_compute_fun_name (trans_group : pure_fun_translation) (def : fun_decl)
+    (ctx : extraction_ctx) : string =
   (* Lookup the LLBC def to compute the region group information *)
   let def_id = def.def_id in
   let llbc_def =
@@ -1211,12 +1234,22 @@ let ctx_add_fun_decl (trans_group : pure_fun_translation) (def : fun_decl)
         in
         Some { id = rg_id; region_names }
   in
+  (* Add the function name *)
+  ctx.fmt.fun_name def.basename def.num_loops def.loop_id num_rgs rg_info
+    (keep_fwd, num_backs)
+
+let ctx_add_fun_decl (trans_group : pure_fun_translation) (def : fun_decl)
+    (ctx : extraction_ctx) : extraction_ctx =
+  (* Sanity check: the function should not be a global body - those are handled
+   * separately *)
+  assert (not def.is_global_decl_body);
+  (* Lookup the LLBC def to compute the region group information *)
+  let def_id = def.def_id in
+  let { keep_fwd; fwd = _; backs } = trans_group in
+  let num_backs = List.length backs in
   let is_opaque = def.body = None in
   (* Add the function name *)
-  let def_name =
-    ctx.fmt.fun_name def.basename def.num_loops def.loop_id num_rgs rg_info
-      (keep_fwd, num_backs)
-  in
+  let def_name = ctx_compute_fun_name trans_group def ctx in
   let fun_id = (A.Regular def_id, def.loop_id, def.back_id) in
   let ctx = ctx_add is_opaque (FunId (FromLlbc fun_id)) def_name ctx in
   (* Add the name info *)
@@ -1251,11 +1284,24 @@ let ctx_add_trait_type (d : trait_decl) (item : string) (ctx : extraction_ctx) :
   let name = ctx.fmt.trait_type_name d item in
   ctx_add is_opaque (TraitItemId (d.def_id, item)) name ctx
 
-let ctx_add_trait_method (d : trait_decl) (item : string) (ctx : extraction_ctx)
-    : extraction_ctx =
+let ctx_add_trait_method (d : trait_decl) (item_name : string) (f : fun_decl)
+    (ctx : extraction_ctx) : extraction_ctx =
+  (* We do something special: we use the base name but remove everything
+         but the crate (because [get_name] removes it) and the last ident.
+         This allows us to reuse the [ctx_compute_fun_decl] function.
+  *)
+  let basename : name =
+    match (f.basename : name) with
+    | Ident crate :: name -> Ident crate :: [ Collections.List.last name ]
+    | _ -> raise (Failure "Unexpected")
+  in
+  let f = { f with basename } in
+  let trans = A.FunDeclId.Map.find f.def_id ctx.trans_funs in
+  let name = ctx_compute_fun_name trans f ctx in
   let is_opaque = false in
-  let name = ctx.fmt.trait_method_name d item in
-  ctx_add is_opaque (TraitItemId (d.def_id, item)) name ctx
+  ctx_add is_opaque
+    (TraitMethodId (d.def_id, item_name, f.loop_id, f.back_id))
+    name ctx
 
 let ctx_add_trait_parent_clause (d : trait_decl) (clause : trait_clause)
     (ctx : extraction_ctx) : extraction_ctx =
-- 
cgit v1.3.1


From fd17736cbdb312578b2ea6de9a58febf83bd96c8 Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Sun, 3 Sep 2023 20:41:42 +0200
Subject: Extract the trait decl methods

---
 compiler/Extract.ml     | 66 +++++++++++++++++++++++++++++++++++--------------
 compiler/ExtractBase.ml | 22 ++++++-----------
 2 files changed, 54 insertions(+), 34 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/compiler/Extract.ml b/compiler/Extract.ml
index 2a678a27..138619c4 100644
--- a/compiler/Extract.ml
+++ b/compiler/Extract.ml
@@ -3213,6 +3213,11 @@ let extract_fun_input_parameters_types (ctx : extraction_ctx)
   in
   List.iter extract_param def.signature.inputs
 
+let extract_fun_inputs_output_parameters_types (ctx : extraction_ctx)
+    (fmt : F.formatter) (def : fun_decl) : unit =
+  extract_fun_input_parameters_types ctx fmt def;
+  extract_ty ctx fmt TypeDeclId.Set.empty false def.signature.output
+
 let assert_backend_supports_decreases_clauses () =
   match !backend with
   | FStar | Lean -> ()
@@ -3931,19 +3936,10 @@ let extract_trait_decl_method_register_names (ctx : extraction_ctx)
   (* We add one field per required forward/backward function *)
   let trans = A.FunDeclId.Map.find id ctx.trans_funs in
 
-  let register_fun ctx f = ctx_add_trait_method trait_decl name f ctx in
-  let register_funs ctx fl = List.fold_left register_fun ctx fl in
-  (* Register the names of the forward functions *)
-  let ctx =
-    if trans.keep_fwd then register_funs ctx (trans.fwd.f :: trans.fwd.loops)
-    else ctx
-  in
-  (* Register the names of the backward functions *)
-  List.fold_left
-    (fun ctx back ->
-      let ctx = register_fun ctx back.f in
-      register_funs ctx back.loops)
-    ctx trans.backs
+  let register_fun ctx f = ctx_add_trait_method trait_decl name f.f ctx in
+  (* Register the names *)
+  let funs = if trans.keep_fwd then trans.fwd :: trans.backs else trans.backs in
+  List.fold_left register_fun ctx funs
 
 (** Similar to {!extract_type_decl_register_names} *)
 let extract_trait_decl_register_names (ctx : extraction_ctx)
@@ -4016,18 +4012,50 @@ let extract_trait_decl_item (ctx : extraction_ctx) (fmt : F.formatter)
   F.pp_print_string fmt ";";
   F.pp_close_box fmt ()
 
+(** Small helper - TODO: move *)
+let generic_params_drop_prefix (g1 : generic_params) (g2 : generic_params) :
+    generic_params =
+  let open Collections.List in
+  let types = drop (length g1.types) g2.types in
+  let const_generics = drop (length g1.const_generics) g2.const_generics in
+  let trait_clauses = drop (length g1.trait_clauses) g2.trait_clauses in
+  { types; const_generics; trait_clauses }
+
 (** Small helper.
 
     Extract the items for a method in a trait decl.
  *)
 let extract_trait_decl_method_items (ctx : extraction_ctx) (fmt : F.formatter)
-    (decl : trait_decl) (name : string) (id : fun_decl_id) : unit =
-  let item_name = ctx_get_trait_const decl.def_id name ctx in
+    (decl : trait_decl) (item_name : string) (id : fun_decl_id) : unit =
   (* Lookup the definition *)
-  (* let def =
-     FunDeclId.Map.find ctx.
-     in *)
-  raise (Failure "TODO")
+  let trans = A.FunDeclId.Map.find id ctx.trans_funs in
+  (* Extract the items *)
+  let funs = if trans.keep_fwd then trans.fwd :: trans.backs else trans.backs in
+  let extract_method (f : fun_and_loops) =
+    let f = f.f in
+    let fun_name = ctx_get_trait_method decl.def_id item_name f.back_id ctx in
+    let ty () =
+      (* Extract the generics *)
+      (* We need to add the generics specific to the method, by removing those
+         which actually apply to the trait decl *)
+      let generics =
+        generic_params_drop_prefix decl.generics f.signature.generics
+      in
+      let ctx, type_params, cg_params, trait_clauses =
+        ctx_add_generic_params generics ctx
+      in
+      let use_forall = generics <> empty_generic_params in
+      let use_implicits = false in
+      extract_generic_params ctx fmt TypeDeclId.Set.empty use_forall
+        use_implicits None None generics type_params cg_params trait_clauses;
+      if use_forall then F.pp_print_string fmt ",";
+      (* Extract the inputs and output *)
+      F.pp_print_space fmt ();
+      extract_fun_inputs_output_parameters_types ctx fmt f
+    in
+    extract_trait_decl_item ctx fmt fun_name ty
+  in
+  List.iter extract_method funs
 
 (** Extract a trait declaration *)
 let extract_trait_decl (ctx : extraction_ctx) (fmt : F.formatter)
diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index e4d1fb7b..435aa10c 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -417,8 +417,7 @@ type id =
   | TraitDeclId of TraitDeclId.id
   | TraitImplId of TraitImplId.id
   | LocalTraitClauseId of TraitClauseId.id
-  | TraitMethodId of
-      TraitDeclId.id * string * LoopId.id option * T.RegionGroupId.id option
+  | TraitMethodId of TraitDeclId.id * string * T.RegionGroupId.id option
       (** Something peculiar with trait methods: because we have to take into
           account forward/backward functions, we may need to generate fields
           items per method.
@@ -820,23 +819,17 @@ let id_to_string (id : id) (ctx : extraction_ctx) : string =
   | TraitItemId (id, name) ->
       "trait_item_id: decl_id:" ^ TraitDeclId.to_string id ^ ", type name: "
       ^ name
-  | TraitMethodId (trait_decl_id, fun_name, lp_id, rg_id) ->
+  | TraitMethodId (trait_decl_id, fun_name, rg_id) ->
       let trait_name =
         Print.fun_name_to_string
           (A.TraitDeclId.Map.find trait_decl_id trait_decls).name
       in
-      let lp_kind =
-        match lp_id with
-        | None -> ""
-        | Some lp_id -> "loop " ^ LoopId.to_string lp_id ^ ", "
-      in
-
       let fwd_back_kind =
         match rg_id with
         | None -> "forward"
         | Some rg_id -> "backward " ^ RegionGroupId.to_string rg_id
       in
-      "trait " ^ trait_name ^ " method name (" ^ lp_kind ^ fwd_back_kind ^ "): "
+      "trait " ^ trait_name ^ " method name (" ^ fwd_back_kind ^ "): "
       ^ fun_name
   | TraitSelfClauseId -> "trait_self_clause"
 
@@ -960,8 +953,9 @@ let ctx_get_trait_type (id : trait_decl_id) (item_name : string)
   ctx_get_trait_item id item_name ctx
 
 let ctx_get_trait_method (id : trait_decl_id) (item_name : string)
-    (ctx : extraction_ctx) : string =
-  ctx_get_trait_item id item_name ctx
+    (rg_id : T.RegionGroupId.id option) (ctx : extraction_ctx) : string =
+  let with_opaque_pre = false in
+  ctx_get with_opaque_pre (TraitMethodId (id, item_name, rg_id)) ctx
 
 let ctx_get_trait_parent_clause (id : trait_decl_id) (clause : trait_clause_id)
     (ctx : extraction_ctx) : string =
@@ -1299,9 +1293,7 @@ let ctx_add_trait_method (d : trait_decl) (item_name : string) (f : fun_decl)
   let trans = A.FunDeclId.Map.find f.def_id ctx.trans_funs in
   let name = ctx_compute_fun_name trans f ctx in
   let is_opaque = false in
-  ctx_add is_opaque
-    (TraitMethodId (d.def_id, item_name, f.loop_id, f.back_id))
-    name ctx
+  ctx_add is_opaque (TraitMethodId (d.def_id, item_name, f.back_id)) name ctx
 
 let ctx_add_trait_parent_clause (d : trait_decl) (clause : trait_clause)
     (ctx : extraction_ctx) : extraction_ctx =
-- 
cgit v1.3.1


From 8b18c0da053e069b5a2d9fbf06f45eae2f05a029 Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Thu, 7 Sep 2023 15:28:06 +0200
Subject: Map some globals like u32::MAX to standard definitions

---
 backends/lean/Base/Primitives/Scalar.lean | 42 ++++++++++++++++++++++++++
 compiler/Driver.ml                        | 14 ---------
 compiler/Extract.ml                       |  8 ++++-
 compiler/ExtractAssumed.ml                | 49 +++++++++++++++++++++++++++++++
 compiler/ExtractBase.ml                   | 22 ++++++++++----
 compiler/LlbcAstUtils.ml                  | 20 +++++++++++++
 compiler/Translate.ml                     | 36 +++++++++++------------
 compiler/dune                             |  1 +
 8 files changed, 154 insertions(+), 38 deletions(-)
 create mode 100644 compiler/ExtractAssumed.ml

(limited to 'compiler/ExtractBase.ml')

diff --git a/backends/lean/Base/Primitives/Scalar.lean b/backends/lean/Base/Primitives/Scalar.lean
index ffc969f3..fa5a63cd 100644
--- a/backends/lean/Base/Primitives/Scalar.lean
+++ b/backends/lean/Base/Primitives/Scalar.lean
@@ -230,6 +230,20 @@ def Scalar.cMax (ty : ScalarTy) : Int :=
   | .Usize => Scalar.max .U32
   | _ => Scalar.max ty
 
+theorem Scalar.min_lt_max (ty : ScalarTy) : Scalar.min ty < Scalar.max ty := by
+  cases ty <;> simp [Scalar.min, Scalar.max]
+  . simp [Isize.min, Isize.max]
+    have h1 := Isize.refined_min.property
+    have h2 := Isize.refined_max.property
+    cases h1 <;> cases h2 <;> simp [*]
+  . simp [Usize.max]
+    have h := Usize.refined_max.property
+    cases h <;> simp [*]
+
+theorem Scalar.min_le_max (ty : ScalarTy) : Scalar.min ty ≤ Scalar.max ty := by
+  have := Scalar.min_lt_max ty
+  int_tac
+
 theorem Scalar.cMin_bound ty : Scalar.min ty ≤ Scalar.cMin ty := by
   cases ty <;> simp [Scalar.min, Scalar.max, Scalar.cMin, Scalar.cMax] at *
   have h := Isize.refined_min.property
@@ -395,6 +409,34 @@ def Scalar.cast {src_ty : ScalarTy} (tgt_ty : ScalarTy) (x : Scalar src_ty) : Re
 @[reducible] def U64   := Scalar .U64
 @[reducible] def U128  := Scalar .U128
 
+-- TODO: reducible?
+@[reducible] def isize_min : Isize := Scalar.ofInt Isize.min (by simp [Scalar.min, Scalar.max]; apply (Scalar.min_le_max .Isize))
+@[reducible] def isize_max : Isize := Scalar.ofInt Isize.max (by simp [Scalar.min, Scalar.max]; apply (Scalar.min_le_max .Isize))
+@[reducible] def i8_min : I8 := Scalar.ofInt I8.min
+@[reducible] def i8_max : I8 := Scalar.ofInt I8.max
+@[reducible] def i16_min : I16 := Scalar.ofInt I16.min
+@[reducible] def i16_max : I16 := Scalar.ofInt I16.max
+@[reducible] def i32_min : I32 := Scalar.ofInt I32.min
+@[reducible] def i32_max : I32 := Scalar.ofInt I32.max
+@[reducible] def i64_min : I64 := Scalar.ofInt I64.min
+@[reducible] def i64_max : I64 := Scalar.ofInt I64.max
+@[reducible] def i128_min : I128 := Scalar.ofInt I128.min
+@[reducible] def i128_max : I128 := Scalar.ofInt I128.max
+
+-- TODO: reducible?
+@[reducible] def usize_min : Usize := Scalar.ofInt Usize.min
+@[reducible] def usize_max : Usize := Scalar.ofInt Usize.max (by simp [Scalar.min, Scalar.max]; apply (Scalar.min_le_max .Usize))
+@[reducible] def u8_min : U8 := Scalar.ofInt U8.min
+@[reducible] def u8_max : U8 := Scalar.ofInt U8.max
+@[reducible] def u16_min : U16 := Scalar.ofInt U16.min
+@[reducible] def u16_max : U16 := Scalar.ofInt U16.max
+@[reducible] def u32_min : U32 := Scalar.ofInt U32.min
+@[reducible] def u32_max : U32 := Scalar.ofInt U32.max
+@[reducible] def u64_min : U64 := Scalar.ofInt U64.min
+@[reducible] def u64_max : U64 := Scalar.ofInt U64.max
+@[reducible] def u128_min : U128 := Scalar.ofInt U128.min
+@[reducible] def u128_max : U128 := Scalar.ofInt U128.max
+
 -- TODO: below: not sure this is the best way.
 -- Should we rather overload operations like +, -, etc.?
 -- Also, it is possible to automate the generation of those definitions
diff --git a/compiler/Driver.ml b/compiler/Driver.ml
index d88962db..0fde1d74 100644
--- a/compiler/Driver.ml
+++ b/compiler/Driver.ml
@@ -222,20 +222,6 @@ let () =
       in
       if has_loops then log#lwarning (lazy "Support for loops is experimental");
 
-      (* If we target Lean, we request the crates to be split into several files
-         whenever there are opaque functions *)
-      if
-        !backend = Lean
-        && A.FunDeclId.Map.exists
-             (fun _ (d : A.fun_decl) -> d.body = None)
-             m.functions
-        && not !split_files
-      then (
-        log#error
-          "For Lean, we request the -split-file option whenever using opaque \
-           functions";
-        fail ());
-
       (* We don't support mutually recursive definitions with decreases clauses in Lean *)
       if
         !backend = Lean && !extract_decreases_clauses
diff --git a/compiler/Extract.ml b/compiler/Extract.ml
index de6c2fc8..74540787 100644
--- a/compiler/Extract.ml
+++ b/compiler/Extract.ml
@@ -8,6 +8,7 @@ open Pure
 open PureUtils
 open TranslateCore
 open ExtractBase
+open ExtractAssumed
 open StringUtils
 open Config
 module F = Format
@@ -3852,8 +3853,13 @@ let extract_global_decl_hol4_opaque (ctx : extraction_ctx) (fmt : F.formatter)
   (* Print the type *)
   F.pp_open_hovbox fmt 0;
   extract_ty ctx fmt TypeDeclId.Set.empty false ty;
+  (* Close the definition *)
+  F.pp_print_string fmt ")";
+  F.pp_close_box fmt ();
+  (* Close the definition box *)
   F.pp_close_box fmt ();
-  (* Close the definition boxe *) F.pp_close_box fmt ()
+  (* Add a line *)
+  F.pp_print_space fmt ()
 
 (** Extract a global declaration.
 
diff --git a/compiler/ExtractAssumed.ml b/compiler/ExtractAssumed.ml
new file mode 100644
index 00000000..bbcedb2b
--- /dev/null
+++ b/compiler/ExtractAssumed.ml
@@ -0,0 +1,49 @@
+(** This file declares external identifiers that we catch to map them to
+    definitions coming from the standard libraries in our backends. *)
+
+open Utils
+open StringUtils
+open Names
+
+type simple_name = string list [@@deriving show, ord]
+
+let name_to_simple_name (s : name) : simple_name =
+  (* We simply ignore the disambiguators *)
+  List.filter_map (function Ident id -> Some id | Disambiguator _ -> None) s
+
+(** Small helper which cuts a string at the occurrences of "::" *)
+let string_to_simple_name (s : string) : simple_name =
+  (* No function to split by using string separator?? *)
+  let name = String.split_on_char ':' s in
+  List.filter (fun s -> s <> "") name
+
+module SimpleNameOrd = struct
+  type t = simple_name
+
+  let compare = compare_simple_name
+  let to_string = show_simple_name
+  let pp_t = pp_simple_name
+  let show_t = show_simple_name
+end
+
+module SimpleNameMap = Collections.MakeMap (SimpleNameOrd)
+
+let assumed_globals : (string * string) list =
+  [
+    ("core::num::usize::MAX", "usize_max");
+    ("core::num::u8::MAX", "u8_max");
+    ("core::num::u16::MAX", "u16_max");
+    ("core::num::u32::MAX", "u32_max");
+    ("core::num::u64::MAX", "u64_max");
+    ("core::num::u128::MAX", "u128_max");
+    ("core::num::isize::MAX", "isize_max");
+    ("core::num::i8::MAX", "i8_max");
+    ("core::num::i16::MAX", "i16_max");
+    ("core::num::i32::MAX", "i32_max");
+    ("core::num::i64::MAX", "i64_max");
+    ("core::num::i128::MAX", "i128_max");
+  ]
+
+let assumed_globals_map : string SimpleNameMap.t =
+  SimpleNameMap.of_list
+    (List.map (fun (x, y) -> (string_to_simple_name x, y)) assumed_globals)
diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index 435aa10c..9c9e08a5 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -5,6 +5,7 @@ open TranslateCore
 module C = Contexts
 module RegionVarId = T.RegionVarId
 module F = Format
+open ExtractAssumed
 
 (** The local logger *)
 let log = L.pure_to_extract_log
@@ -1198,12 +1199,23 @@ let ctx_add_global_decl_and_body (def : A.global_decl) (ctx : extraction_ctx) :
     extraction_ctx =
   (* TODO: update once the body id can be an option *)
   let is_opaque = false in
-  let name = ctx.fmt.global_name def.name in
   let decl = GlobalId def.def_id in
-  let body = FunId (FromLlbc (Regular def.body_id, None, None)) in
-  let ctx = ctx_add is_opaque decl (name ^ "_c") ctx in
-  let ctx = ctx_add is_opaque body (name ^ "_body") ctx in
-  ctx
+
+  (* Check if the global corresponds to an assumed global that we should map
+     to a custom definition in our standard library (for instance, happens
+     with "core::num::usize::MAX") *)
+  let sname = name_to_simple_name def.name in
+  match SimpleNameMap.find_opt sname assumed_globals_map with
+  | Some name ->
+      (* Yes: register the custom binding *)
+      ctx_add is_opaque decl name ctx
+  | None ->
+      (* Not the case: "standard" registration *)
+      let name = ctx.fmt.global_name def.name in
+      let body = FunId (FromLlbc (Regular def.body_id, None, None)) in
+      let ctx = ctx_add is_opaque decl (name ^ "_c") ctx in
+      let ctx = ctx_add is_opaque body (name ^ "_body") ctx in
+      ctx
 
 let ctx_compute_fun_name (trans_group : pure_fun_translation) (def : fun_decl)
     (ctx : extraction_ctx) : string =
diff --git a/compiler/LlbcAstUtils.ml b/compiler/LlbcAstUtils.ml
index 1111c297..8c8bbabe 100644
--- a/compiler/LlbcAstUtils.ml
+++ b/compiler/LlbcAstUtils.ml
@@ -12,3 +12,23 @@ let lookup_fun_name (fun_id : fun_id) (fun_decls : fun_decl FunDeclId.Map.t) :
   match fun_id with
   | Regular id -> (FunDeclId.Map.find id fun_decls).name
   | Assumed aid -> Assumed.get_assumed_name aid
+
+(** Return the opaque declarations found in the crate.
+
+    Remark: the list of functions also contains the list of opaque global bodies.
+ *)
+let crate_get_opaque_decls (k : crate) : T.type_decl list * fun_decl list =
+  let open ExtractAssumed in
+  let is_opaque_fun (d : fun_decl) : bool =
+    let sname = name_to_simple_name d.name in
+    d.body = None && not (SimpleNameMap.mem sname assumed_globals_map)
+  in
+  let is_opaque_type (d : T.type_decl) : bool = d.kind = T.Opaque in
+  (* Note that by checking the function bodies we also the globals *)
+  ( List.filter is_opaque_type (T.TypeDeclId.Map.values k.types),
+    List.filter is_opaque_fun (FunDeclId.Map.values k.functions) )
+
+(** Return true if the crate contains opaque declarations, ignoring the assumed
+    definitions. *)
+let crate_has_opaque_decls (k : crate) : bool =
+  crate_get_opaque_decls k <> ([], [])
diff --git a/compiler/Translate.ml b/compiler/Translate.ml
index a4041751..90066163 100644
--- a/compiler/Translate.ml
+++ b/compiler/Translate.ml
@@ -430,19 +430,9 @@ type gen_config = {
 }
 
 (** Returns the pair: (has opaque type decls, has opaque fun decls) *)
-let module_has_opaque_decls (ctx : gen_ctx) : bool * bool =
-  let has_opaque_types =
-    Pure.TypeDeclId.Map.exists
-      (fun _ (d : Pure.type_decl) ->
-        match d.kind with Opaque -> true | _ -> false)
-      ctx.trans_types
-  in
-  let has_opaque_funs =
-    A.FunDeclId.Map.exists
-      (fun _ (trans : pure_fun_translation) -> Option.is_none trans.fwd.f.body)
-      ctx.trans_funs
-  in
-  (has_opaque_types, has_opaque_funs)
+let crate_has_opaque_decls (ctx : gen_ctx) : bool * bool =
+  let types, funs = LlbcAstUtils.crate_get_opaque_decls ctx.crate in
+  (types <> [], funs <> [])
 
 (** Export a type declaration.
 
@@ -557,11 +547,20 @@ let export_global (fmt : Format.formatter) (config : gen_config) (ctx : gen_ctx)
   let body = trans.fwd.f in
 
   let is_opaque = Option.is_none body.Pure.body in
-  if
+  (* Check if we extract the global *)
+  let extract =
     config.extract_globals
     && (((not is_opaque) && config.extract_transparent)
        || (is_opaque && config.extract_opaque))
-  then
+  in
+  (* Check if it is an assumed global - if yes, we ignore it because we
+     map the definition to one in the standard library *)
+  let open ExtractAssumed in
+  let sname = name_to_simple_name global.name in
+  let extract =
+    extract && SimpleNameMap.find_opt sname assumed_globals_map = None
+  in
+  if extract then
     (* We don't wrap global declaration groups between calls to functions
        [{start, end}_global_decl_group] (which don't exist): global declaration
        groups are always singletons, so the [extract_global_decl] function
@@ -828,7 +827,7 @@ let extract_definitions (fmt : Format.formatter) (config : gen_config)
     config.extract_opaque && config.extract_fun_decls
     && !Config.wrap_opaque_in_sig
     &&
-    let _, opaque_funs = module_has_opaque_decls ctx in
+    let _, opaque_funs = crate_has_opaque_decls ctx in
     opaque_funs
   in
   if wrap_in_sig then (
@@ -1233,7 +1232,7 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
 
      (* Check if there are opaque types and functions - in which case we need
       * to split *)
-     let has_opaque_types, has_opaque_funs = module_has_opaque_decls ctx in
+     let has_opaque_types, has_opaque_funs = crate_has_opaque_decls ctx in
      let has_opaque_types = has_opaque_types || !Config.use_state in
 
      (* Extract the types *)
@@ -1302,7 +1301,7 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
         in
         extract_file template_clauses_config ctx file_info);
 
-     (* Extract the opaque functions, if needed *)
+     (* Extract the opaque declarations, if needed *)
      let opaque_funs_module =
        if has_opaque_funs then (
          (* In the case of Lean we generate a template file *)
@@ -1330,6 +1329,7 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
            {
              base_gen_config with
              extract_fun_decls = true;
+             extract_globals = true;
              extract_transparent = false;
              extract_opaque = true;
              interface = true;
diff --git a/compiler/dune b/compiler/dune
index db099c3c..2f5a0a44 100644
--- a/compiler/dune
+++ b/compiler/dune
@@ -22,6 +22,7 @@
   Expressions
   ExpressionsUtils
   Extract
+  ExtractAssumed
   ExtractBase
   FunsAnalysis
   Identifiers
-- 
cgit v1.3.1


From 5921be8e2e8955db5101354d8bf29ae6a3693f48 Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Mon, 11 Sep 2023 06:35:07 +0200
Subject: Make progress on correctly handling trait method calls in the
 symbolic execution

---
 compiler/Extract.ml               |   4 +-
 compiler/ExtractBase.ml           |  16 +++--
 compiler/InterpreterStatements.ml | 126 ++++++++++++++++++++++++++++++--------
 compiler/InterpreterUtils.ml      |   3 +
 compiler/Print.ml                 |   8 +++
 compiler/PrintPure.ml             |   7 ++-
 compiler/Pure.ml                  |  14 ++++-
 compiler/PureMicroPasses.ml       |  29 ++++-----
 compiler/ReorderDecls.ml          |   4 +-
 compiler/SymbolicAst.ml           |   2 +-
 compiler/SymbolicToPure.ml        |  73 ++++++++++++++++++----
 compiler/SynthesizeSymbolic.ml    |   2 +-
 12 files changed, 221 insertions(+), 67 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/compiler/Extract.ml b/compiler/Extract.ml
index d000c447..fe007d31 100644
--- a/compiler/Extract.ml
+++ b/compiler/Extract.ml
@@ -3411,7 +3411,7 @@ let extract_fun_comment (ctx : extraction_ctx) (fmt : F.formatter)
     (def : fun_decl) : unit =
   let { keep_fwd; num_backs } =
     PureUtils.RegularFunIdMap.find
-      (A.Regular def.def_id, def.loop_id, def.back_id)
+      (Pure.FunId (A.Regular def.def_id), def.loop_id, def.back_id)
       ctx.fun_name_info
   in
   let comment_pre = "[" ^ Print.fun_name_to_string def.basename ^ "]: " in
@@ -3908,7 +3908,7 @@ let extract_global_decl (ctx : extraction_ctx) (fmt : F.formatter)
   let decl_name = ctx_get_global with_opaque_pre global.def_id ctx in
   let body_name =
     ctx_get_function with_opaque_pre
-      (FromLlbc (Regular global.body_id, None, None))
+      (FromLlbc (Pure.FunId (Regular global.body_id), None, None))
       ctx
   in
 
diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index 9c9e08a5..438a3475 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -703,10 +703,13 @@ let id_to_string (id : id) (ctx : extraction_ctx) : string =
       | FromLlbc (fid, lp_id, rg_id) ->
           let fun_name =
             match fid with
-            | Regular fid ->
+            | FunId (Regular fid) ->
                 Print.fun_name_to_string
                   (A.FunDeclId.Map.find fid fun_decls).name
-            | Assumed aid -> A.show_assumed_fun_id aid
+            | FunId (Assumed aid) -> A.show_assumed_fun_id aid
+            | TraitMethod _ ->
+                (* Shouldn't happen *)
+                raise (Failure "Unexpected")
           in
 
           let lp_kind =
@@ -908,7 +911,7 @@ let ctx_get_function (with_opaque_pre : bool) (id : fun_id)
 let ctx_get_local_function (with_opaque_pre : bool) (id : A.FunDeclId.id)
     (lp : LoopId.id option) (rg : RegionGroupId.id option)
     (ctx : extraction_ctx) : string =
-  ctx_get_function with_opaque_pre (FromLlbc (Regular id, lp, rg)) ctx
+  ctx_get_function with_opaque_pre (FromLlbc (FunId (Regular id), lp, rg)) ctx
 
 let ctx_get_type (with_opaque_pre : bool) (id : type_id) (ctx : extraction_ctx)
     : string =
@@ -1212,7 +1215,7 @@ let ctx_add_global_decl_and_body (def : A.global_decl) (ctx : extraction_ctx) :
   | None ->
       (* Not the case: "standard" registration *)
       let name = ctx.fmt.global_name def.name in
-      let body = FunId (FromLlbc (Regular def.body_id, None, None)) in
+      let body = FunId (FromLlbc (FunId (Regular def.body_id), None, None)) in
       let ctx = ctx_add is_opaque decl (name ^ "_c") ctx in
       let ctx = ctx_add is_opaque body (name ^ "_body") ctx in
       ctx
@@ -1256,7 +1259,7 @@ let ctx_add_fun_decl (trans_group : pure_fun_translation) (def : fun_decl)
   let is_opaque = def.body = None in
   (* Add the function name *)
   let def_name = ctx_compute_fun_name trans_group def ctx in
-  let fun_id = (A.Regular def_id, def.loop_id, def.back_id) in
+  let fun_id = (Pure.FunId (Regular def_id), def.loop_id, def.back_id) in
   let ctx = ctx_add is_opaque (FunId (FromLlbc fun_id)) def_name ctx in
   (* Add the name info *)
   {
@@ -1381,7 +1384,8 @@ let initialize_names_map (fmt : formatter) (init : names_map_init) : names_map =
   in
   let assumed_functions =
     List.map
-      (fun (fid, rg, name) -> (FromLlbc (A.Assumed fid, None, rg), name))
+      (fun (fid, rg, name) ->
+        (FromLlbc (Pure.FunId (A.Assumed fid), None, rg), name))
       init.assumed_llbc_functions
     @ List.map (fun (fid, name) -> (Pure fid, name)) init.assumed_pure_functions
   in
diff --git a/compiler/InterpreterStatements.ml b/compiler/InterpreterStatements.ml
index 5791a359..1ea16e58 100644
--- a/compiler/InterpreterStatements.ml
+++ b/compiler/InterpreterStatements.ml
@@ -1082,12 +1082,12 @@ and eval_function_call_concrete (config : C.config) (call : A.call) : st_cm_fun
        * where we haven't panicked. Of course, the translation needs to take the
        * panic case into account... *)
       eval_assumed_function_call_concrete config fid call (cf Unit) ctx
-  | A.TraitMethod (_, _) -> raise (Failure "Unimplemented")
+  | A.TraitMethod _ -> raise (Failure "Unimplemented")
 
 and eval_function_call_symbolic (config : C.config) (call : A.call) : st_cm_fun
     =
   match call.func with
-  | A.FunId (A.Regular _) | A.TraitMethod (_, _) ->
+  | A.FunId (A.Regular _) | A.TraitMethod _ ->
       eval_transparent_function_call_symbolic config call
   | A.FunId (A.Assumed fid) ->
       eval_assumed_function_call_symbolic config fid call
@@ -1182,7 +1182,7 @@ and eval_transparent_function_call_symbolic (config : C.config) (call : A.call)
     : st_cm_fun =
  fun cf ctx ->
   (* Instantiate the signature and introduce fresh abstractions and region ids while doing so *)
-  let def, inst_sg =
+  let func, def, self_trait_ref, inst_sg =
     match call.func with
     | A.FunId (A.Regular fid) ->
         let def = C.ctx_lookup_fun_decl ctx fid in
@@ -1190,11 +1190,19 @@ and eval_transparent_function_call_symbolic (config : C.config) (call : A.call)
         let inst_sg =
           instantiate_fun_sig ctx call.generics tr_self def.A.signature
         in
-        (def, inst_sg)
+        (call.func, def, None, inst_sg)
     | A.FunId (A.Assumed _) ->
         (* Unreachable: must be a transparent function *)
         raise (Failure "Unreachable")
-    | A.TraitMethod (trait_ref, method_name) -> (
+    | A.TraitMethod (trait_ref, method_name, _) -> (
+        log#ldebug
+          (lazy
+            ("trait method call:\n- call: " ^ call_to_string ctx call
+           ^ "\n- method name: " ^ method_name ^ "\n- generics:\n"
+            ^ egeneric_args_to_string ctx call.generics
+            ^ "\n- trait and method generics:\n"
+            ^ egeneric_args_to_string ctx
+                (Option.get call.trait_and_method_generic_args)));
         (* When instantiating, we need to group the generics for the trait ref
            and the method *)
         let generics = Option.get call.trait_and_method_generic_args in
@@ -1202,31 +1210,97 @@ and eval_transparent_function_call_symbolic (config : C.config) (call : A.call)
            depending on whethere we call a top-level trait method impl or the
            method from a local clause *)
         match trait_ref.trait_id with
-        | TraitImpl impl_id ->
+        | TraitImpl impl_id -> (
             (* Lookup the trait impl *)
             let trait_impl = C.ctx_lookup_trait_impl ctx impl_id in
-            let _, method_id =
-              List.find
+            log#ldebug
+              (lazy ("trait impl: " ^ trait_impl_to_string ctx trait_impl));
+            (* First look in the required methods *)
+            let method_id =
+              List.find_opt
                 (fun (s, _) -> s = method_name)
                 trait_impl.required_methods
             in
-            let method_def = C.ctx_lookup_fun_decl ctx method_id in
-            (* Instantiate *)
-            let tr_self = T.UnknownTrait __FUNCTION__ in
-            let inst_sg =
-              instantiate_fun_sig ctx generics tr_self method_def.A.signature
-            in
-            (method_def, inst_sg)
+            match method_id with
+            | Some (_, id) ->
+                let method_def = C.ctx_lookup_fun_decl ctx id in
+                (* Instantiate *)
+                let tr_self =
+                  T.TraitRef (etrait_ref_no_regions_to_gr_trait_ref trait_ref)
+                in
+                let inst_sg =
+                  instantiate_fun_sig ctx generics tr_self
+                    method_def.A.signature
+                in
+                (call.func, method_def, None, inst_sg)
+            | None ->
+                (* If not found, lookup the methods provided by the trait *declaration*
+                   (remember: for now, we forbid overriding provided methods) *)
+                assert (trait_impl.provided_methods = []);
+                let trait_decl =
+                  C.ctx_lookup_trait_decl ctx
+                    trait_ref.trait_decl_ref.trait_decl_id
+                in
+                let _, method_id =
+                  List.find
+                    (fun (s, _) -> s = method_name)
+                    trait_decl.provided_methods
+                in
+                let method_id = Option.get method_id in
+                let method_def = C.ctx_lookup_fun_decl ctx method_id in
+                (* For the instantiation we have to do something perculiar
+                   because the method was defined for the trait declaration.
+                   We have to group:
+                   - the parameters given to the trait decl reference
+                   - the parameters given to the method itself
+                   For instance:
+                   {[
+                     trait Foo<T> {
+                       fn f<U>(...) { ... }
+                     }
+
+                     fn g<G>(x : G) where Clause0: Foo<G, bool>
+                     {
+                       x.f::<u32>(...) // The arguments to f are: <G, bool, u32>
+                     }
+                   ]}
+                *)
+                let generics =
+                  TypesUtils.merge_generic_args
+                    trait_ref.trait_decl_ref.decl_generics call.generics
+                in
+                log#ldebug
+                  (lazy
+                    ("provided method call:" ^ "\n- method name: " ^ method_name
+                   ^ "\n- generics:\n"
+                    ^ egeneric_args_to_string ctx generics));
+                let tr_self =
+                  T.TraitRef (etrait_ref_no_regions_to_gr_trait_ref trait_ref)
+                in
+                let inst_sg =
+                  instantiate_fun_sig ctx generics tr_self
+                    method_def.A.signature
+                in
+                (* We directly call the function, pretending it is not a trait method call *)
+                (* TODO: we need to add the self trait ref *)
+                let func = A.FunId (A.Regular method_def.def_id) in
+                (func, method_def, Some trait_ref, inst_sg))
         | _ ->
             (* We are using a local clause - we lookup the trait decl *)
             let trait_decl =
               C.ctx_lookup_trait_decl ctx trait_ref.trait_decl_ref.trait_decl_id
             in
-            (* Lookup the method decl *)
+            (* Lookup the method decl in the required *and* the provided methods *)
             let _, method_id =
+              let provided =
+                List.filter_map
+                  (fun (id, f) ->
+                    match f with None -> None | Some f -> Some (id, f))
+                  trait_decl.provided_methods
+              in
               List.find
                 (fun (s, _) -> s = method_name)
-                trait_decl.required_methods
+                (List.append trait_decl.required_methods provided)
             in
             let method_def = C.ctx_lookup_fun_decl ctx method_id in
             (* Instantiate *)
@@ -1238,26 +1312,30 @@ and eval_transparent_function_call_symbolic (config : C.config) (call : A.call)
             let inst_sg =
               instantiate_fun_sig ctx generics tr_self method_def.A.signature
             in
-            (method_def, inst_sg))
+            (call.func, method_def, None, inst_sg))
   in
   (* Sanity check *)
   assert (List.length call.args = List.length def.A.signature.inputs);
   (* Evaluate the function call *)
-  eval_function_call_symbolic_from_inst_sig config call.func inst_sg
+  eval_function_call_symbolic_from_inst_sig config func inst_sg self_trait_ref
     call.generics call.args call.dest cf ctx
 
 (** Evaluate a function call in symbolic mode by using the function signature.
 
     This allows us to factorize the evaluation of local and non-local function
     calls in symbolic mode: only their signatures matter.
+
+    The [self_trait_ref] trait ref refers to [Self]. We use it when calling
+    a provided trait method, because those methods have a special treatment:
+    we dot not group them with the required trait methods, and forbid (for now)
+    overriding them. We treat them as regular method, which take an additional
+    trait ref as input.
  *)
 and eval_function_call_symbolic_from_inst_sig (config : C.config)
     (fid : A.fun_id_or_trait_method_ref) (inst_sg : A.inst_fun_sig)
-    (generics : T.egeneric_args) (args : E.operand list) (dest : E.place) :
-    st_cm_fun =
+    (self_trait_ref : T.etrait_ref option) (generics : T.egeneric_args)
+    (args : E.operand list) (dest : E.place) : st_cm_fun =
  fun cf ctx ->
-  (* TODO: trait methods are not supported yet *)
-  let fid = match fid with A.FunId fid -> fid | _ -> raise (Failure "TODO") in
   (* Generate a fresh symbolic value for the return value *)
   let ret_sv_ty = inst_sg.A.output in
   let ret_spc = mk_fresh_symbolic_value V.FunCallRet ret_sv_ty in
@@ -1427,7 +1505,7 @@ and eval_assumed_function_call_symbolic (config : C.config)
 
       (* Evaluate the function call *)
       eval_function_call_symbolic_from_inst_sig config (A.FunId (A.Assumed fid))
-        inst_sig generics args dest cf ctx
+        inst_sig None generics args dest cf ctx
 
 (** Evaluate a statement seen as a function body *)
 and eval_function_body (config : C.config) (body : A.statement) : st_cm_fun =
diff --git a/compiler/InterpreterUtils.ml b/compiler/InterpreterUtils.ml
index 0986c53b..8a7e8c52 100644
--- a/compiler/InterpreterUtils.ml
+++ b/compiler/InterpreterUtils.ml
@@ -38,6 +38,9 @@ let typed_value_to_string = PA.typed_value_to_string
 let typed_avalue_to_string = PA.typed_avalue_to_string
 let place_to_string = PA.place_to_string
 let operand_to_string = PA.operand_to_string
+let egeneric_args_to_string = PA.egeneric_args_to_string
+let call_to_string = PA.call_to_string
+let trait_impl_to_string = PA.trait_impl_to_string
 let statement_to_string ctx = PA.statement_to_string ctx "" "  "
 let statement_to_string_with_tab ctx = PA.statement_to_string ctx "  " "  "
 let env_elem_to_string ctx = PA.env_elem_to_string ctx "" "  "
diff --git a/compiler/Print.ml b/compiler/Print.ml
index aebfd09c..55aa0c53 100644
--- a/compiler/Print.ml
+++ b/compiler/Print.ml
@@ -698,11 +698,19 @@ module EvalCtxLlbcAst = struct
     let fmt = PC.eval_ctx_to_ast_formatter ctx in
     PE.operand_to_string fmt op
 
+  let call_to_string (ctx : C.eval_ctx) (call : A.call) : string =
+    let fmt = PC.eval_ctx_to_ast_formatter ctx in
+    PA.call_to_string fmt "" call
+
   let statement_to_string (ctx : C.eval_ctx) (indent : string)
       (indent_incr : string) (e : A.statement) : string =
     let fmt = PC.eval_ctx_to_ast_formatter ctx in
     PA.statement_to_string fmt indent indent_incr e
 
+  let trait_impl_to_string (ctx : C.eval_ctx) (timpl : A.trait_impl) : string =
+    let fmt = PC.eval_ctx_to_ast_formatter ctx in
+    PA.trait_impl_to_string fmt "  " "  " timpl
+
   let env_elem_to_string (ctx : C.eval_ctx) (indent : string)
       (indent_incr : string) (ev : C.env_elem) : string =
     let fmt = PC.eval_ctx_to_ctx_formatter ctx in
diff --git a/compiler/PrintPure.ml b/compiler/PrintPure.ml
index c7f59ec9..d539dcf6 100644
--- a/compiler/PrintPure.ml
+++ b/compiler/PrintPure.ml
@@ -629,8 +629,11 @@ let regular_fun_id_to_string (fmt : ast_formatter) (fun_id : fun_id) : string =
   | FromLlbc (fid, lp_id, rg_id) ->
       let f =
         match fid with
-        | Regular fid -> fmt.fun_decl_id_to_string fid
-        | Assumed fid -> llbc_assumed_fun_id_to_string fid
+        | FunId (Regular fid) -> fmt.fun_decl_id_to_string fid
+        | FunId (Assumed fid) -> llbc_assumed_fun_id_to_string fid
+        | TraitMethod (trait_ref, method_name, _) ->
+            let fmt = ast_to_type_formatter fmt in
+            trait_ref_to_string fmt true trait_ref ^ "." ^ method_name
       in
       f ^ fun_suffix lp_id rg_id
   | Pure fid -> pure_assumed_fun_id_to_string fid
diff --git a/compiler/Pure.ml b/compiler/Pure.ml
index 81060c43..47c7beb4 100644
--- a/compiler/Pure.ml
+++ b/compiler/Pure.ml
@@ -306,6 +306,7 @@ and trait_instance_id =
   | UnknownTrait of string
 [@@deriving
   show,
+    ord,
     visitors
       {
         name = "iter_ty";
@@ -369,7 +370,7 @@ type trait_type_constraint = {
   type_name : trait_item_name;
   ty : ty;
 }
-[@@deriving show]
+[@@deriving show, ord]
 
 type predicates = { trait_type_constraints : trait_type_constraint list }
 [@@deriving show]
@@ -530,8 +531,15 @@ type pure_assumed_fun_id =
   | FuelEqZero  (** Test if some fuel is equal to 0 - TODO: ugly *)
 [@@deriving show, ord]
 
+type fun_id_or_trait_method_ref =
+  | FunId of A.fun_id
+  | TraitMethod of trait_ref * string * fun_decl_id
+      (** The fun decl id is not really needed and here for convenience purposes *)
+[@@deriving show, ord]
+
 (** A function id for a non-assumed function *)
-type regular_fun_id = A.fun_id * LoopId.id option * T.RegionGroupId.id option
+type regular_fun_id =
+  fun_id_or_trait_method_ref * LoopId.id option * T.RegionGroupId.id option
 [@@deriving show, ord]
 
 (** A function identifier *)
@@ -1003,7 +1011,7 @@ type trait_decl = {
   consts : (trait_item_name * (ty * global_decl_id option)) list;
   types : (trait_item_name * (trait_clause list * ty option)) list;
   required_methods : (trait_item_name * fun_decl_id) list;
-  provided_methods : trait_item_name list;
+  provided_methods : (trait_item_name * fun_decl_id option) list;
 }
 [@@deriving show]
 
diff --git a/compiler/PureMicroPasses.ml b/compiler/PureMicroPasses.ml
index 6c9c3a91..53148dbb 100644
--- a/compiler/PureMicroPasses.ml
+++ b/compiler/PureMicroPasses.ml
@@ -765,7 +765,7 @@ let inline_useless_var_reassignments (inline_named : bool) (inline_pure : bool)
     In this situation, we can remove the call [f@fwd x].
  *)
 let expression_contains_child_call_in_all_paths (ctx : trans_ctx)
-    (id0 : A.fun_id) (lp_id0 : LoopId.id option)
+    (id0 : fun_id_or_trait_method_ref) (lp_id0 : LoopId.id option)
     (rg_id0 : T.RegionGroupId.id option) (generics0 : generic_args)
     (args0 : texpression list) (e : texpression) : bool =
   let check_call (fun_id1 : fun_or_op_id) (generics1 : generic_args)
@@ -791,6 +791,11 @@ let expression_contains_child_call_in_all_paths (ctx : trans_ctx)
                   (* We need to use the regions hierarchy *)
                   (* First, lookup the signature of the LLBC function *)
                   let sg =
+                    let id0 =
+                      match id0 with
+                      | FunId fun_id -> fun_id
+                      | TraitMethod (_, _, fun_decl_id) -> A.Regular fun_decl_id
+                    in
                     LlbcAstUtils.lookup_fun_sig id0 ctx.fun_context.fun_decls
                   in
                   (* Compute the set of ancestors of the function in call1 *)
@@ -1521,7 +1526,7 @@ let eliminate_box_functions (_ctx : trans_ctx) (def : fun_decl) : fun_decl =
         match opt_destruct_function_call e with
         | Some (fun_id, _tys, args) -> (
             match fun_id with
-            | Fun (FromLlbc (A.Assumed aid, _lp_id, rg_id)) -> (
+            | Fun (FromLlbc (FunId (A.Assumed aid), _lp_id, rg_id)) -> (
                 (* Below, when dealing with the arguments: we consider the very
                  * general case, where functions could be boxed (meaning we
                  * could have: [box_new f x])
@@ -2024,7 +2029,6 @@ let filter_loop_inputs (transl : pure_fun_translation list) :
      additional parameters.
   *)
   let used_map = ref FunLoopIdMap.empty in
-  let fun_id_to_fun_loop_id (fid, loop_id, _) = (fid, loop_id) in
 
   (* We start by computing the filtering information, for each function *)
   let compute_one_filter_info (decl : fun_decl) =
@@ -2069,8 +2073,8 @@ let filter_loop_inputs (transl : pure_fun_translation list) :
               match e_app.e with
               | Qualif qualif -> (
                   match qualif.id with
-                  | FunOrOp (Fun (FromLlbc fun_id')) ->
-                      if fun_id_to_fun_loop_id fun_id' = fun_id then (
+                  | FunOrOp (Fun (FromLlbc (FunId fun_id', loop_id', _))) ->
+                      if (fun_id', loop_id') = fun_id then (
                         (* For each argument, check if it is exactly the original
                            input parameter. Note that there shouldn't be partial
                            applications of loop functions: the number of arguments
@@ -2129,9 +2133,9 @@ let filter_loop_inputs (transl : pure_fun_translation list) :
   (* We then apply the filtering to all the function definitions at once *)
   let filter_in_one (decl : fun_decl) : fun_decl =
     (* Filter the function signature *)
-    let fun_id = (A.Regular decl.def_id, decl.loop_id, decl.back_id) in
+    let fun_id = (A.Regular decl.def_id, decl.loop_id) in
     let decl =
-      match FunLoopIdMap.find_opt (fun_id_to_fun_loop_id fun_id) !used_map with
+      match FunLoopIdMap.find_opt fun_id !used_map with
       | None -> (* Nothing to filter *) decl
       | Some used_info ->
           let num_filtered =
@@ -2179,9 +2183,7 @@ let filter_loop_inputs (transl : pure_fun_translation list) :
           let { inputs; inputs_lvs; body } = body in
 
           let inputs, inputs_lvs =
-            match
-              FunLoopIdMap.find_opt (fun_id_to_fun_loop_id fun_id) !used_map
-            with
+            match FunLoopIdMap.find_opt fun_id !used_map with
             | None -> (* Nothing to filter *) (inputs, inputs_lvs)
             | Some used_info ->
                 let inputs = filter_prefix used_info inputs in
@@ -2201,11 +2203,10 @@ let filter_loop_inputs (transl : pure_fun_translation list) :
                     match e_app.e with
                     | Qualif qualif -> (
                         match qualif.id with
-                        | FunOrOp (Fun (FromLlbc fun_id)) -> (
+                        | FunOrOp (Fun (FromLlbc (FunId fun_id, loop_id, _)))
+                          -> (
                             match
-                              FunLoopIdMap.find_opt
-                                (fun_id_to_fun_loop_id fun_id)
-                                !used_map
+                              FunLoopIdMap.find_opt (fun_id, loop_id) !used_map
                             with
                             | None -> super#visit_texpression env e
                             | Some used_info ->
diff --git a/compiler/ReorderDecls.ml b/compiler/ReorderDecls.ml
index db646a87..10b68da3 100644
--- a/compiler/ReorderDecls.ml
+++ b/compiler/ReorderDecls.ml
@@ -46,8 +46,8 @@ let compute_body_fun_deps (e : texpression) : FunIdSet.t =
             | Pure _ -> ()
             | FromLlbc (fid, lp_id, rg_id) -> (
                 match fid with
-                | Assumed _ -> ()
-                | Regular fid ->
+                | FunId (Assumed _) -> ()
+                | TraitMethod (_, _, fid) | FunId (Regular fid) ->
                     let id = { def_id = fid; lp_id; rg_id } in
                     ids := FunIdSet.add id !ids))
     end
diff --git a/compiler/SymbolicAst.ml b/compiler/SymbolicAst.ml
index b170ebe5..4df8fec7 100644
--- a/compiler/SymbolicAst.ml
+++ b/compiler/SymbolicAst.ml
@@ -29,7 +29,7 @@ type mplace = {
 [@@deriving show]
 
 type call_id =
-  | Fun of A.fun_id * V.FunCallId.id
+  | Fun of A.fun_id_or_trait_method_ref * V.FunCallId.id
       (** A "regular" function (i.e., a function which is not a primitive operation) *)
   | Unop of E.unop
   | Binop of E.binop
diff --git a/compiler/SymbolicToPure.ml b/compiler/SymbolicToPure.ml
index 3312e22d..1da0521d 100644
--- a/compiler/SymbolicToPure.ml
+++ b/compiler/SymbolicToPure.ml
@@ -727,6 +727,54 @@ let type_check_texpression (ctx : bs_ctx) (e : texpression) : unit =
   let ctx = mk_type_check_ctx ctx in
   PureTypeCheck.check_texpression ctx e
 
+let translate_fun_id_or_trait_method_ref (ctx : bs_ctx)
+    (id : A.fun_id_or_trait_method_ref) : fun_id_or_trait_method_ref =
+  match id with
+  | A.FunId fun_id -> FunId fun_id
+  | TraitMethod (trait_ref, method_name, fun_decl_id) ->
+      let type_infos = ctx.type_context.type_infos in
+      let trait_ref = translate_fwd_trait_ref type_infos trait_ref in
+      TraitMethod (trait_ref, method_name, fun_decl_id)
+
+let bs_ctx_register_forward_call (call_id : V.FunCallId.id) (forward : S.call)
+    (args : texpression list) (ctx : bs_ctx) : bs_ctx =
+  let calls = ctx.calls in
+  assert (not (V.FunCallId.Map.mem call_id calls));
+  let info =
+    { forward; forward_inputs = args; backwards = T.RegionGroupId.Map.empty }
+  in
+  let calls = V.FunCallId.Map.add call_id info calls in
+  { ctx with calls }
+
+(** [back_args]: the *additional* list of inputs received by the backward function *)
+let bs_ctx_register_backward_call (abs : V.abs) (call_id : V.FunCallId.id)
+    (back_id : T.RegionGroupId.id) (back_args : texpression list) (ctx : bs_ctx)
+    : bs_ctx * fun_or_op_id =
+  (* Insert the abstraction in the call informations *)
+  let info = V.FunCallId.Map.find call_id ctx.calls in
+  assert (not (T.RegionGroupId.Map.mem back_id info.backwards));
+  let backwards =
+    T.RegionGroupId.Map.add back_id (abs, back_args) info.backwards
+  in
+  let info = { info with backwards } in
+  let calls = V.FunCallId.Map.add call_id info ctx.calls in
+  (* Insert the abstraction in the abstractions map *)
+  let abstractions = ctx.abstractions in
+  assert (not (V.AbstractionId.Map.mem abs.abs_id abstractions));
+  let abstractions =
+    V.AbstractionId.Map.add abs.abs_id (abs, back_args) abstractions
+  in
+  (* Retrieve the fun_id *)
+  let fun_id =
+    match info.forward.call_id with
+    | S.Fun (fid, _) ->
+        let fid = translate_fun_id_or_trait_method_ref ctx fid in
+        Fun (FromLlbc (fid, None, Some back_id))
+    | S.Unop _ | S.Binop _ -> raise (Failure "Unreachable")
+  in
+  (* Update the context and return *)
+  ({ ctx with calls; abstractions }, fun_id)
+
 (** List the ancestors of an abstraction *)
 let list_ancestor_abstractions_ids (ctx : bs_ctx) (abs : V.abs)
     (call_id : V.FunCallId.id) : V.AbstractionId.id list =
@@ -780,10 +828,10 @@ let mk_fuel_input_as_list (ctx : bs_ctx) (info : fun_effect_info) :
 
 (** Small utility. *)
 let get_fun_effect_info (fun_infos : FA.fun_info A.FunDeclId.Map.t)
-    (fun_id : A.fun_id) (lid : V.LoopId.id option)
+    (fun_id : A.fun_id_or_trait_method_ref) (lid : V.LoopId.id option)
     (gid : T.RegionGroupId.id option) : fun_effect_info =
   match fun_id with
-  | A.Regular fid ->
+  | A.TraitMethod (_, _, fid) | A.FunId (A.Regular fid) ->
       let info = A.FunDeclId.Map.find fid fun_infos in
       let stateful_group = info.stateful in
       let stateful =
@@ -796,7 +844,7 @@ let get_fun_effect_info (fun_infos : FA.fun_info A.FunDeclId.Map.t)
         can_diverge = info.can_diverge;
         is_rec = info.is_rec || Option.is_some lid;
       }
-  | A.Assumed aid ->
+  | A.FunId (A.Assumed aid) ->
       assert (lid = None);
       {
         can_fail = Assumed.assumed_can_fail aid;
@@ -828,7 +876,7 @@ let translate_fun_sig (fun_infos : FA.fun_info A.FunDeclId.Map.t)
   in
   (* Is the function stateful, and can it fail? *)
   let lid = None in
-  let effect_info = get_fun_effect_info fun_infos fun_id lid bid in
+  let effect_info = get_fun_effect_info fun_infos (A.FunId fun_id) lid bid in
   (* List the inputs for:
    * - the fuel
    * - the forward function
@@ -1615,7 +1663,8 @@ and translate_function_call (call : S.call) (e : S.expression) (ctx : bs_ctx) :
     match call.call_id with
     | S.Fun (fid, call_id) ->
         (* Regular function call *)
-        let func = Fun (FromLlbc (fid, None, None)) in
+        let fid_t = translate_fun_id_or_trait_method_ref ctx fid in
+        let func = Fun (FromLlbc (fid_t, None, None)) in
         (* Retrieve the effect information about this function (can fail,
          * takes a state as input, etc.) *)
         let effect_info =
@@ -2043,8 +2092,8 @@ and translate_end_abstraction_loop (ectx : C.eval_ctx) (abs : V.abs)
   | V.LoopCall ->
       let fun_id = A.Regular ctx.fun_decl.A.def_id in
       let effect_info =
-        get_fun_effect_info ctx.fun_context.fun_infos fun_id (Some vloop_id)
-          (Some rg_id)
+        get_fun_effect_info ctx.fun_context.fun_infos (A.FunId fun_id)
+          (Some vloop_id) (Some rg_id)
       in
       let loop_info = LoopId.Map.find loop_id ctx.loops in
       let generics = loop_info.generics in
@@ -2095,7 +2144,7 @@ and translate_end_abstraction_loop (ectx : C.eval_ctx) (abs : V.abs)
         if effect_info.can_fail then mk_result_ty output.ty else output.ty
       in
       let func_ty = mk_arrows input_tys ret_ty in
-      let func = Fun (FromLlbc (fun_id, Some loop_id, Some rg_id)) in
+      let func = Fun (FromLlbc (FunId fun_id, Some loop_id, Some rg_id)) in
       let func = { id = FunOrOp func; generics } in
       let func = { e = Qualif func; ty = func_ty } in
       let call = mk_apps func args in
@@ -2508,7 +2557,7 @@ and translate_forward_end (ectx : C.eval_ctx)
       (* Lookup the effect info for the loop function *)
       let fid = A.Regular ctx.fun_decl.A.def_id in
       let effect_info =
-        get_fun_effect_info ctx.fun_context.fun_infos fid None ctx.bid
+        get_fun_effect_info ctx.fun_context.fun_infos (A.FunId fid) None ctx.bid
       in
 
       (* Introduce a fresh output value for the forward function *)
@@ -2553,7 +2602,7 @@ and translate_forward_end (ectx : C.eval_ctx)
       let out_pat = mk_simpl_tuple_pattern out_pats in
 
       let loop_call =
-        let fun_id = Fun (FromLlbc (fid, Some loop_id, None)) in
+        let fun_id = Fun (FromLlbc (FunId fid, Some loop_id, None)) in
         let func = { id = FunOrOp fun_id; generics = loop_info.generics } in
         let input_tys = (List.map (fun (x : texpression) -> x.ty)) args in
         let ret_ty =
@@ -2873,8 +2922,8 @@ let translate_fun_decl (ctx : bs_ctx) (body : S.expression option) : fun_decl =
     | None -> None
     | Some body ->
         let effect_info =
-          get_fun_effect_info ctx.fun_context.fun_infos (Regular def_id) None
-            bid
+          get_fun_effect_info ctx.fun_context.fun_infos (FunId (Regular def_id))
+            None bid
         in
         let body = translate_expression body ctx in
         (* Add a match over the fuel, if necessary *)
diff --git a/compiler/SynthesizeSymbolic.ml b/compiler/SynthesizeSymbolic.ml
index cac56487..aeb6899f 100644
--- a/compiler/SynthesizeSymbolic.ml
+++ b/compiler/SynthesizeSymbolic.ml
@@ -122,7 +122,7 @@ let synthesize_global_eval (gid : A.GlobalDeclId.id) (dest : V.symbolic_value)
     (e : expression option) : expression option =
   Option.map (fun e -> EvalGlobal (gid, dest, e)) e
 
-let synthesize_regular_function_call (fun_id : A.fun_id)
+let synthesize_regular_function_call (fun_id : A.fun_id_or_trait_method_ref)
     (call_id : V.FunCallId.id) (ctx : Contexts.eval_ctx)
     (abstractions : V.AbstractionId.id list) (generics : T.egeneric_args)
     (args : V.typed_value list) (args_places : mplace option list)
-- 
cgit v1.3.1


From 378bfbd1be69ee54cfe7fad97ca3b09d0f80f62b Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Thu, 14 Sep 2023 00:24:29 +0200
Subject: Fix some issues with the name collisions

---
 compiler/ExtractBase.ml | 32 +++++++++++++++++++++++++++++---
 1 file changed, 29 insertions(+), 3 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index 438a3475..6789b5b8 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -840,7 +840,8 @@ let id_to_string (id : id) (ctx : extraction_ctx) : string =
 (** We might not check for collisions for some specific ids (ex.: field names) *)
 let allow_collisions (id : id) : bool =
   match id with
-  | FieldId _ | TraitItemClauseId _ | TraitParentClauseId _ | TraitItemId _ ->
+  | FieldId _ | TraitItemClauseId _ | TraitParentClauseId _ | TraitItemId _
+  | TraitMethodId _ ->
       !Config.record_fields_short_names
   | _ -> false
 
@@ -1285,19 +1286,29 @@ let ctx_add_trait_const (d : trait_decl) (item : string) (ctx : extraction_ctx)
     : extraction_ctx =
   let is_opaque = false in
   let name = ctx.fmt.trait_const_name d item in
+  (* Add a prefix if necessary *)
+  let name =
+    if !Config.record_fields_short_names then name
+    else ctx.fmt.trait_decl_name d ^ name
+  in
   ctx_add is_opaque (TraitItemId (d.def_id, item)) name ctx
 
 let ctx_add_trait_type (d : trait_decl) (item : string) (ctx : extraction_ctx) :
     extraction_ctx =
   let is_opaque = false in
   let name = ctx.fmt.trait_type_name d item in
+  (* Add a prefix if necessary *)
+  let name =
+    if !Config.record_fields_short_names then name
+    else ctx.fmt.trait_decl_name d ^ name
+  in
   ctx_add is_opaque (TraitItemId (d.def_id, item)) name ctx
 
 let ctx_add_trait_method (d : trait_decl) (item_name : string) (f : fun_decl)
     (ctx : extraction_ctx) : extraction_ctx =
   (* We do something special: we use the base name but remove everything
-         but the crate (because [get_name] removes it) and the last ident.
-         This allows us to reuse the [ctx_compute_fun_decl] function.
+     but the crate (because [get_name] removes it) and the last ident.
+     This allows us to reuse the [ctx_compute_fun_decl] function.
   *)
   let basename : name =
     match (f.basename : name) with
@@ -1307,6 +1318,11 @@ let ctx_add_trait_method (d : trait_decl) (item_name : string) (f : fun_decl)
   let f = { f with basename } in
   let trans = A.FunDeclId.Map.find f.def_id ctx.trans_funs in
   let name = ctx_compute_fun_name trans f ctx in
+  (* Add a prefix if necessary *)
+  let name =
+    if !Config.record_fields_short_names then name
+    else ctx.fmt.trait_decl_name d ^ name
+  in
   let is_opaque = false in
   ctx_add is_opaque (TraitMethodId (d.def_id, item_name, f.back_id)) name ctx
 
@@ -1314,12 +1330,22 @@ let ctx_add_trait_parent_clause (d : trait_decl) (clause : trait_clause)
     (ctx : extraction_ctx) : extraction_ctx =
   let is_opaque = false in
   let name = ctx.fmt.trait_parent_clause_name d clause in
+  (* Add a prefix if necessary *)
+  let name =
+    if !Config.record_fields_short_names then name
+    else ctx.fmt.trait_decl_name d ^ name
+  in
   ctx_add is_opaque (TraitParentClauseId (d.def_id, clause.clause_id)) name ctx
 
 let ctx_add_trait_type_clause (d : trait_decl) (item : string)
     (clause : trait_clause) (ctx : extraction_ctx) : extraction_ctx =
   let is_opaque = false in
   let name = ctx.fmt.trait_type_clause_name d item clause in
+  (* Add a prefix if necessary *)
+  let name =
+    if !Config.record_fields_short_names then name
+    else ctx.fmt.trait_decl_name d ^ name
+  in
   ctx_add is_opaque
     (TraitItemClauseId (d.def_id, item, clause.clause_id))
     name ctx
-- 
cgit v1.3.1


From e8aa3804ef0134631cc16b257775ad8f98690c29 Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Thu, 14 Sep 2023 00:42:46 +0200
Subject: Make progress on the extraction

---
 compiler/Config.ml      |  4 ++++
 compiler/Extract.ml     | 10 +++++++++-
 compiler/ExtractBase.ml | 16 +++++++++++-----
 3 files changed, 24 insertions(+), 6 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/compiler/Config.ml b/compiler/Config.ml
index 508746d9..62f6c300 100644
--- a/compiler/Config.ml
+++ b/compiler/Config.ml
@@ -339,3 +339,7 @@ let parameterize_trait_types = ref false
     trait associated types in the pure code.
  *)
 let type_check_pure_code = ref false
+
+(** Shall we fail hard if there is an issue at code-generation time?
+    We may not want in case outputting a code with holes helps debugging *)
+let extract_fail_hard = ref false
diff --git a/compiler/Extract.ml b/compiler/Extract.ml
index fe007d31..864d513f 100644
--- a/compiler/Extract.ml
+++ b/compiler/Extract.ml
@@ -529,7 +529,15 @@ let type_decl_kind_to_qualif (kind : decl_kind)
            *)
           Some "with"
       | (Assumed | Declared), None -> Some "Axiom"
-      | _ -> raise (Failure "Unexpected"))
+      | SingleNonRec, None ->
+          (* This is for traits *)
+          Some "Record"
+      | _ ->
+          raise
+            (Failure
+               ("Unexpected: (" ^ show_decl_kind kind ^ ", "
+               ^ Print.option_to_string show_type_decl_kind type_kind
+               ^ ")")))
   | Lean -> (
       match kind with
       | SingleNonRec ->
diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index 6789b5b8..612cf359 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -78,6 +78,7 @@ type decl_kind =
           F*:  [val x : Type0]
           Coq: [Axiom x : Type.]
        *)
+[@@deriving show]
 
 (** Return [true] if the declaration is the last from its group of declarations.
 
@@ -112,7 +113,7 @@ let decl_is_first_from_group (kind : decl_kind) : bool =
 let decl_is_not_last_from_group (kind : decl_kind) : bool =
   not (decl_is_last_from_group kind)
 
-type type_decl_kind = Enum | Struct
+type type_decl_kind = Enum | Struct [@@deriving show]
 
 (* TODO: this should be a module we give to a functor! *)
 
@@ -533,7 +534,8 @@ let names_map_check_collision (id_to_string : id -> string) (id : id)
   | None -> () (* Ok *)
   | Some clash ->
       (* There is a clash: print a nice debugging message for the user *)
-      report_name_collision id_to_string clash id name
+      if !Config.extract_fail_hard then
+        report_name_collision id_to_string clash id name
 
 let names_map_add (id_to_string : id -> string) (is_opaque : bool) (id : id)
     (name : string) (nm : names_map) : names_map =
@@ -707,9 +709,12 @@ let id_to_string (id : id) (ctx : extraction_ctx) : string =
                 Print.fun_name_to_string
                   (A.FunDeclId.Map.find fid fun_decls).name
             | FunId (Assumed aid) -> A.show_assumed_fun_id aid
-            | TraitMethod _ ->
+            | TraitMethod (_, method_name, _) ->
                 (* Shouldn't happen *)
-                raise (Failure "Unexpected")
+                if !Config.extract_fail_hard then raise (Failure "Unexpected")
+                else (
+                  log#serror ("Unexpected trait method: " ^ method_name);
+                  method_name)
           in
 
           let lp_kind =
@@ -899,7 +904,8 @@ let ctx_get (with_opaque_pre : bool) (id : id) (ctx : extraction_ctx) : string =
         if with_opaque_pre && is_opaque then ctx.fmt.opaque_pre () ^ s else s
     | None ->
         log#serror ("Could not find: " ^ id_to_string id ctx);
-        raise Not_found
+        if !Config.extract_fail_hard then raise (Failure "Not found")
+        else "(ERROR: \"" ^ id_to_string id ctx ^ "\")"
 
 let ctx_get_global (with_opaque_pre : bool) (id : A.GlobalDeclId.id)
     (ctx : extraction_ctx) : string =
-- 
cgit v1.3.1


From ee9de5ae43928fbd07d19200e6211168ed7552ab Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Sat, 16 Sep 2023 21:41:44 +0200
Subject: Fix issues with name collisions

---
 compiler/Extract.ml     | 28 +++++++++++++++++++++-------
 compiler/ExtractBase.ml | 24 ++++++++++++++++++------
 2 files changed, 39 insertions(+), 13 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/compiler/Extract.ml b/compiler/Extract.ml
index 864d513f..60455cd9 100644
--- a/compiler/Extract.ml
+++ b/compiler/Extract.ml
@@ -655,6 +655,11 @@ let mk_formatter (ctx : trans_ctx) (crate_name : string)
     | _ ->
         raise (Failure ("Unexpected name shape: " ^ Print.name_to_string name))
   in
+  let flatten_name (name : string list) : string =
+    match !backend with
+    | FStar | Coq | HOL4 -> String.concat "_" name
+    | Lean -> String.concat "." name
+  in
   let get_type_name = get_name in
   let type_name_to_camel_case name =
     let name = get_type_name name in
@@ -708,9 +713,7 @@ let mk_formatter (ctx : trans_ctx) (crate_name : string)
   let get_fun_name fname =
     let fname = get_name fname in
     (* TODO: don't convert to snake case for Coq, HOL4, F* *)
-    match !backend with
-    | FStar | Coq | HOL4 -> String.concat "_" (List.map to_snake_case fname)
-    | Lean -> String.concat "." fname
+    flatten_name fname
   in
   let global_name (name : global_name) : string =
     (* Converting to snake case also lowercases the letters (in Rust, global
@@ -732,8 +735,18 @@ let mk_formatter (ctx : trans_ctx) (crate_name : string)
     type_name_to_snake_case trait_decl.name
   in
 
-  let trait_impl_name (trait_impl : trait_impl) : string =
-    get_fun_name trait_impl.name
+  let trait_impl_name (trait_decl : trait_decl) (trait_impl : trait_impl) :
+      string =
+    (* TODO: provisional: we concatenate the trait impl name (which is its type)
+       with the trait decl name *)
+    let inst_keyword =
+      match !backend with
+      | HOL4 | FStar | Coq -> "_instance"
+      | Lean -> "Instance"
+    in
+    flatten_name
+      (get_type_name trait_impl.name
+      @ [ trait_decl_name trait_decl ^ inst_keyword ])
   in
 
   let trait_parent_clause_name (trait_decl : trait_decl) (clause : trait_clause)
@@ -4017,8 +4030,9 @@ let extract_trait_impl_register_names (ctx : extraction_ctx)
     (trait_impl : trait_impl) : extraction_ctx =
   (* For now we do not support overriding provided methods *)
   assert (trait_impl.provided_methods = []);
-  (* Everything is actually taken care of by {!extract_trait_decl_register_names} *)
-  ctx
+  (* Everything is taken care of by {!extract_trait_decl_register_names} *but*
+     the name of the implementation itself *)
+  ctx_add_trait_impl trait_impl ctx
 
 (** Small helper.
 
diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index 612cf359..1996d38f 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -245,7 +245,7 @@ type formatter = {
           - loop identifier, if this is for a loop
        *)
   trait_decl_name : trait_decl -> string;
-  trait_impl_name : trait_impl -> string;
+  trait_impl_name : trait_decl -> trait_impl -> string;
   trait_parent_clause_name : trait_decl -> trait_clause -> string;
   trait_const_name : trait_decl -> string -> string;
   trait_type_name : trait_decl -> string -> string;
@@ -523,7 +523,8 @@ let report_name_collision (id_to_string : id -> string) (id1 : id) (id2 : id)
     ^ "\nYou may want to rename some of your definitions, or report an issue."
   in
   log#serror err;
-  raise (Failure err)
+  (* If we fail hard on errors, raise an exception *)
+  if !Config.extract_fail_hard then raise (Failure err)
 
 let names_map_get_id_from_name (name : string) (nm : names_map) : id option =
   StringMap.find_opt name nm.name_to_id
@@ -534,15 +535,21 @@ let names_map_check_collision (id_to_string : id -> string) (id : id)
   | None -> () (* Ok *)
   | Some clash ->
       (* There is a clash: print a nice debugging message for the user *)
-      if !Config.extract_fail_hard then
-        report_name_collision id_to_string clash id name
+      report_name_collision id_to_string clash id name
 
 let names_map_add (id_to_string : id -> string) (is_opaque : bool) (id : id)
     (name : string) (nm : names_map) : names_map =
   (* Check if there is a clash *)
   names_map_check_collision id_to_string id name nm;
   (* Sanity check *)
-  assert (not (StringSet.mem name nm.names_set));
+  if StringSet.mem name nm.names_set then (
+    let err =
+      "Error when registering the name for id: " ^ id_to_string id
+      ^ ":\nThe chosen name is already in the names set: " ^ name
+    in
+    log#serror err;
+    (* If we fail hard on errors, raise an exception *)
+    if !Config.extract_fail_hard then raise (Failure err));
   (* Insert *)
   let id_to_name = IdMap.add id name nm.id_to_name in
   let name_to_id = StringMap.add name id nm.name_to_id in
@@ -1284,8 +1291,13 @@ let ctx_add_trait_decl (d : trait_decl) (ctx : extraction_ctx) : extraction_ctx
 
 let ctx_add_trait_impl (d : trait_impl) (ctx : extraction_ctx) : extraction_ctx
     =
+  (* We need to lookup the trait decl that is implemented by the trait impl *)
+  let decl =
+    Pure.TraitDeclId.Map.find d.impl_trait.trait_decl_id ctx.trans_trait_decls
+  in
+  (* Compute the name *)
   let is_opaque = false in
-  let name = ctx.fmt.trait_impl_name d in
+  let name = ctx.fmt.trait_impl_name decl d in
   ctx_add is_opaque (TraitImplId d.def_id) name ctx
 
 let ctx_add_trait_const (d : trait_decl) (item : string) (ctx : extraction_ctx)
-- 
cgit v1.3.1


From e6e749d47f05a6d48625c305b6af132440382efb Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Sat, 16 Sep 2023 21:54:48 +0200
Subject: Fix more issues

---
 compiler/Extract.ml     | 13 ++++++-------
 compiler/ExtractBase.ml |  2 +-
 2 files changed, 7 insertions(+), 8 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/compiler/Extract.ml b/compiler/Extract.ml
index 60455cd9..ecfb47c7 100644
--- a/compiler/Extract.ml
+++ b/compiler/Extract.ml
@@ -732,21 +732,20 @@ let mk_formatter (ctx : trans_ctx) (crate_name : string)
   in
 
   let trait_decl_name (trait_decl : trait_decl) : string =
-    type_name_to_snake_case trait_decl.name
+    type_name trait_decl.name
   in
 
   let trait_impl_name (trait_decl : trait_decl) (trait_impl : trait_impl) :
       string =
     (* TODO: provisional: we concatenate the trait impl name (which is its type)
        with the trait decl name *)
-    let inst_keyword =
+    let trait_decl =
+      let name = trait_decl.name in
       match !backend with
-      | HOL4 | FStar | Coq -> "_instance"
-      | Lean -> "Instance"
+      | FStar | Coq | HOL4 -> type_name_to_snake_case name ^ "_instance"
+      | Lean -> String.concat "" (get_type_name name) ^ "Instance"
     in
-    flatten_name
-      (get_type_name trait_impl.name
-      @ [ trait_decl_name trait_decl ^ inst_keyword ])
+    flatten_name (get_type_name trait_impl.name @ [ trait_decl ])
   in
 
   let trait_parent_clause_name (trait_decl : trait_decl) (clause : trait_clause)
diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index 1996d38f..28928325 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -1339,7 +1339,7 @@ let ctx_add_trait_method (d : trait_decl) (item_name : string) (f : fun_decl)
   (* Add a prefix if necessary *)
   let name =
     if !Config.record_fields_short_names then name
-    else ctx.fmt.trait_decl_name d ^ name
+    else ctx.fmt.trait_decl_name d ^ "_" ^ name
   in
   let is_opaque = false in
   ctx_add is_opaque (TraitMethodId (d.def_id, item_name, f.back_id)) name ctx
-- 
cgit v1.3.1


From 515d95d786fed13c300b9e0d7619711ee6aaf971 Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Sat, 16 Sep 2023 22:50:19 +0200
Subject: Add a strict_names_map in the extraction_ctx

---
 compiler/ExtractBase.ml | 55 ++++++++++++++++++++++++++++++++++---------------
 compiler/Translate.ml   | 14 +++++++++++++
 2 files changed, 52 insertions(+), 17 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index 28928325..15acc492 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -467,6 +467,8 @@ type id =
       (** Used for stored various strings like keywords, definitions which
           should always be in context, etc. and which can't be linked to one
           of the above.
+
+          TODO: rename to "keyword"
        *)
 [@@deriving show, ord]
 
@@ -512,6 +514,14 @@ type names_map = {
        *)
 }
 
+let empty_names_map : names_map =
+  {
+    id_to_name = IdMap.empty;
+    name_to_id = StringMap.empty;
+    names_set = StringSet.empty;
+    opaque_ids = IdSet.empty;
+  }
+
 (** Small helper to report name collision *)
 let report_name_collision (id_to_string : id -> string) (id1 : id) (id2 : id)
     (name : string) : unit =
@@ -645,6 +655,15 @@ type extraction_ctx = {
   unsafe_names_map : unsafe_names_map;
       (** The map for id to names, where we allow name collisions
           (ex.: we might allow record field name collisions). *)
+  strict_names_map : names_map;
+      (** This map is a sub-map of [names_map]. For the ids in this map we also
+          forbid collisions with names in the [unsafe_names_map].
+
+          We do so for keywords for instance, but also for types (in a dependently
+          typed language, we might have an issue if the field of a record has, say,
+          the name "u32", and another field of the same record refers to "u32"
+          (for instance in its type).
+       *)
   fmt : formatter;
   indent_incr : int;
       (** The indent increment we insert whenever we need to indent more *)
@@ -849,6 +868,11 @@ let id_to_string (id : id) (ctx : extraction_ctx) : string =
       ^ fun_name
   | TraitSelfClauseId -> "trait_self_clause"
 
+(** Return [true] if we are strict on collisions for this id (i.e., we forbid
+    collisions even with the ids in the unsafe names map) *)
+let strict_collisions (id : id) : bool =
+  match id with UnknownId | TypeId _ -> true | _ -> false
+
 (** We might not check for collisions for some specific ids (ex.: field names) *)
 let allow_collisions (id : id) : bool =
   match id with
@@ -866,9 +890,9 @@ let ctx_add (is_opaque : bool) (id : id) (name : string) (ctx : extraction_ctx)
      We notably use it for field names: some backends like Lean can use the
      type information to disambiguate field projections.
 
-     Remark: what we do is actually subtle. Taking the example of fields:
-     - we allow fields from different ADT definitions to collide
-     - we do *not* allow field names to collide with other names
+     Remark: we still need to check that those "unsafe" ids don't collide with
+     the ids that we mark as "strict on collision".
+
      For instance, we don't allow naming a field "let". We enforce this by
      not checking collision between ids for which we permit collisions (ex.:
      between fields), but still checking collisions between those ids and the
@@ -876,29 +900,26 @@ let ctx_add (is_opaque : bool) (id : id) (name : string) (ctx : extraction_ctx)
   *)
   if allow_collisions id then (
     assert (not is_opaque);
-    (* Check with the other ids *)
-    names_map_check_collision id_to_string id name ctx.names_map;
+    (* Check with the ids which are considered to be strict on collisions *)
+    names_map_check_collision id_to_string id name ctx.strict_names_map;
     {
       ctx with
       unsafe_names_map = unsafe_names_map_add id name ctx.unsafe_names_map;
     })
   else
-    (* Remark: we don't check that there are no collisions with the unsafe ids.
-       Importantly, we don't want some safe ids like keywords to clash with
-       unsafe ids like fields names. For this, we leverage the fact that we register
-       keywords *first*, then unsafe ids (meaning the clash will be detected with
-       the check in the other branch of the if ... then ... else ..., and we do
-       have to check for all possible collisions, which may be slightly too
-       restrictive).
-
-       TODO: this is a bit hacky, we might want to improve the way we detect
-       clashes by being more precise. Overall, there is only an issue with
-       field names which are allowed to clash with each other.
+    (* Remark: if we are strict on collisions:
+       - we add the id to the strict collisions map
+       - we check that the id doesn't collide with the unsafe map
     *)
+    let strict_names_map =
+      if strict_collisions id then
+        names_map_add id_to_string is_opaque id name ctx.strict_names_map
+      else ctx.strict_names_map
+    in
     let names_map =
       names_map_add id_to_string is_opaque id name ctx.names_map
     in
-    { ctx with names_map }
+    { ctx with strict_names_map; names_map }
 
 (** [with_opaque_pre]: if [true] and the definition is opaque, add the opaque prefix *)
 let ctx_get (with_opaque_pre : bool) (id : id) (ctx : extraction_ctx) : string =
diff --git a/compiler/Translate.ml b/compiler/Translate.ml
index 90066163..ebb0de0e 100644
--- a/compiler/Translate.ml
+++ b/compiler/Translate.ml
@@ -986,6 +986,19 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
     mk_formatter_and_names_map trans_ctx crate.name
       variant_concatenate_type_name
   in
+  let strict_names_map =
+    let open ExtractBase in
+    let ids =
+      List.filter
+        (fun (id, _) -> strict_collisions id)
+        (IdMap.bindings names_map.id_to_name)
+    in
+    let is_opaque = false in
+    List.fold_left
+      (* id_to_string: we shouldn't need to use it *)
+        (fun m (id, n) -> names_map_add show_id is_opaque id n m)
+      empty_names_map ids
+  in
 
   (* We need to compute which functions are recursive, in order to know
    * whether we should generate a decrease clause or not. *)
@@ -1041,6 +1054,7 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
       trans_ctx;
       names_map;
       unsafe_names_map = { id_to_name = ExtractBase.IdMap.empty };
+      strict_names_map;
       fmt;
       indent_incr = 2;
       use_opaque_pre = !Config.split_files;
-- 
cgit v1.3.1


From 8e86ab71527de2d997b6454dc61ab80d52bfdc56 Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Sat, 16 Sep 2023 23:36:29 +0200
Subject: Fix issues with name registration/lookup

---
 compiler/Extract.ml     | 28 ++++++++++++++++--
 compiler/ExtractBase.ml | 77 +++++++++++++++++++++++++++++++++++--------------
 2 files changed, 81 insertions(+), 24 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/compiler/Extract.ml b/compiler/Extract.ml
index ecfb47c7..aef37a86 100644
--- a/compiler/Extract.ml
+++ b/compiler/Extract.ml
@@ -2618,7 +2618,31 @@ and extract_function_call (ctx : extraction_ctx) (fmt : F.formatter)
       F.pp_open_hovbox fmt ctx.indent_incr;
       (* Print the function name *)
       let with_opaque_pre = ctx.use_opaque_pre in
-      let fun_name = ctx_get_function with_opaque_pre fun_id ctx in
+      (* For the function name: the id is not the same depending on whether
+         we call a trait method and a "regular" function (remark: trait
+         method *implementations* are considered as regular functions here;
+         only calls to method of traits which are parameterized in a where
+         clause have a special treatment.
+
+         Remark: the reason why trait method declarations have a special
+         treatment is that, as traits are extracted to records, we may
+         allow collisions between trait item names and some other names,
+         while we do not allow collisions between function names.
+
+         Remark: calls to trait methods when the implementation is known
+         (i.e., when we do not use a trait parameter) are desugared to regular
+         function calls.
+      *)
+      let fun_name =
+        match fun_id with
+        | FromLlbc
+            (TraitMethod (trait_ref, method_name, _fun_decl_id), lp_id, rg_id)
+          ->
+            assert (lp_id = None);
+            ctx_get_trait_method trait_ref.trait_decl_ref.trait_decl_id
+              method_name rg_id ctx
+        | _ -> ctx_get_function with_opaque_pre fun_id ctx
+      in
       F.pp_print_string fmt fun_name;
       (* Sanity check: HOL4 doesn't support const generics *)
       assert (generics.const_generics = [] || !backend <> HOL4);
@@ -3974,7 +3998,7 @@ let extract_trait_decl_method_register_names (ctx : extraction_ctx)
 
   let register_fun ctx f = ctx_add_trait_method trait_decl name f.f ctx in
   (* Register the names *)
-  let funs = if trans.keep_fwd then trans.fwd :: trans.backs else trans.backs in
+  let funs = trans.fwd :: trans.backs in
   List.fold_left register_fun ctx funs
 
 (** Similar to {!extract_type_decl_register_names} *)
diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index 15acc492..4238d9af 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -713,6 +713,12 @@ let id_to_string (id : id) (ctx : extraction_ctx) : string =
   let fun_decls = ctx.trans_ctx.fun_context.fun_decls in
   let type_decls = ctx.trans_ctx.type_context.type_decls in
   let trait_decls = ctx.trans_ctx.trait_decls_context.trait_decls in
+  let trait_decl_id_to_string (id : A.TraitDeclId.id) : string =
+    let trait_name =
+      Print.fun_name_to_string (A.TraitDeclId.Map.find id trait_decls).name
+    in
+    "trait_decl: " ^ trait_name ^ " (id: " ^ A.TraitDeclId.to_string id ^ ")"
+  in
   (* TODO: factorize the pretty-printing with what is in PrintPure *)
   let get_type_name (id : type_id) : string =
     match id with
@@ -735,12 +741,13 @@ let id_to_string (id : id) (ctx : extraction_ctx) : string =
                 Print.fun_name_to_string
                   (A.FunDeclId.Map.find fid fun_decls).name
             | FunId (Assumed aid) -> A.show_assumed_fun_id aid
-            | TraitMethod (_, method_name, _) ->
+            | TraitMethod (trait_ref, method_name, _) ->
                 (* Shouldn't happen *)
                 if !Config.extract_fail_hard then raise (Failure "Unexpected")
-                else (
-                  log#serror ("Unexpected trait method: " ^ method_name);
-                  method_name)
+                else
+                  "Trait method: decl: "
+                  ^ TraitDeclId.to_string trait_ref.trait_decl_ref.trait_decl_id
+                  ^ ", method_name: " ^ method_name
           in
 
           let lp_kind =
@@ -800,8 +807,16 @@ let id_to_string (id : id) (ctx : extraction_ctx) : string =
             if variant_id = option_some_id then "@option::Some"
             else if variant_id = option_none_id then "@option::None"
             else raise (Failure "Unreachable")
-        | Assumed (State | Vec | Fuel | Array | Slice | Str | Range) ->
-            raise (Failure "Unreachable")
+        | Assumed Fuel ->
+            if variant_id = fuel_zero_id then "@fuel::0"
+            else if variant_id = fuel_succ_id then "@fuel::Succ"
+            else raise (Failure "Unreachable")
+        | Assumed (State | Vec | Array | Slice | Str | Range) ->
+            raise
+              (Failure
+                 ("Unreachable: variant id ("
+                 ^ VariantId.to_string variant_id
+                 ^ ") for " ^ show_type_id id))
         | AdtId id -> (
             let def = TypeDeclId.Map.find id type_decls in
             match def.kind with
@@ -844,28 +859,22 @@ let id_to_string (id : id) (ctx : extraction_ctx) : string =
   | LocalTraitClauseId id ->
       "local_trait_clause_id: " ^ TraitClauseId.to_string id
   | TraitParentClauseId (id, clause_id) ->
-      "trait_parent_clause_id: decl_id:" ^ TraitDeclId.to_string id
-      ^ ", clause_id: "
+      "trait_parent_clause_id: " ^ trait_decl_id_to_string id ^ ", clause_id: "
       ^ TraitClauseId.to_string clause_id
   | TraitItemClauseId (id, item_name, clause_id) ->
-      "trait_item_clause_id: decl_id:" ^ TraitDeclId.to_string id
-      ^ ", item name: " ^ item_name ^ ", clause_id: "
+      "trait_item_clause_id: " ^ trait_decl_id_to_string id ^ ", item name: "
+      ^ item_name ^ ", clause_id: "
       ^ TraitClauseId.to_string clause_id
   | TraitItemId (id, name) ->
-      "trait_item_id: decl_id:" ^ TraitDeclId.to_string id ^ ", type name: "
-      ^ name
+      "trait_item_id: " ^ trait_decl_id_to_string id ^ ", type name: " ^ name
   | TraitMethodId (trait_decl_id, fun_name, rg_id) ->
-      let trait_name =
-        Print.fun_name_to_string
-          (A.TraitDeclId.Map.find trait_decl_id trait_decls).name
-      in
       let fwd_back_kind =
         match rg_id with
         | None -> "forward"
         | Some rg_id -> "backward " ^ RegionGroupId.to_string rg_id
       in
-      "trait " ^ trait_name ^ " method name (" ^ fwd_back_kind ^ "): "
-      ^ fun_name
+      trait_decl_id_to_string trait_decl_id
+      ^ ", method name (" ^ fwd_back_kind ^ "): " ^ fun_name
   | TraitSelfClauseId -> "trait_self_clause"
 
 (** Return [true] if we are strict on collisions for this id (i.e., we forbid
@@ -924,15 +933,39 @@ let ctx_add (is_opaque : bool) (id : id) (name : string) (ctx : extraction_ctx)
 (** [with_opaque_pre]: if [true] and the definition is opaque, add the opaque prefix *)
 let ctx_get (with_opaque_pre : bool) (id : id) (ctx : extraction_ctx) : string =
   (* We do not use the same name map if we allow/disallow collisions *)
-  if allow_collisions id then IdMap.find id ctx.unsafe_names_map.id_to_name
+  let map_to_string (m : string IdMap.t) : string =
+    "[\n"
+    ^ String.concat ","
+        (List.map
+           (fun (id, n) -> "\n  " ^ id_to_string id ctx ^ " -> " ^ n)
+           (IdMap.bindings m))
+    ^ "\n]"
+  in
+  if allow_collisions id then (
+    let m = ctx.unsafe_names_map.id_to_name in
+    match IdMap.find_opt id m with
+    | Some s -> s
+    | None ->
+        let err =
+          "Could not find: " ^ id_to_string id ctx ^ "\nNames map:\n"
+          ^ map_to_string m
+        in
+        log#serror err;
+        if !Config.extract_fail_hard then raise (Failure err)
+        else "(ERROR: \"" ^ id_to_string id ctx ^ "\")")
   else
-    match IdMap.find_opt id ctx.names_map.id_to_name with
+    let m = ctx.names_map.id_to_name in
+    match IdMap.find_opt id m with
     | Some s ->
         let is_opaque = IdSet.mem id ctx.names_map.opaque_ids in
         if with_opaque_pre && is_opaque then ctx.fmt.opaque_pre () ^ s else s
     | None ->
-        log#serror ("Could not find: " ^ id_to_string id ctx);
-        if !Config.extract_fail_hard then raise (Failure "Not found")
+        let err =
+          "Could not find: " ^ id_to_string id ctx ^ "\nNames map:\n"
+          ^ map_to_string m
+        in
+        log#serror err;
+        if !Config.extract_fail_hard then raise (Failure err)
         else "(ERROR: \"" ^ id_to_string id ctx ^ "\")"
 
 let ctx_get_global (with_opaque_pre : bool) (id : A.GlobalDeclId.id)
-- 
cgit v1.3.1


From d2724812981075ab7edc9cf7fb3915908024410a Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Sun, 17 Sep 2023 00:30:32 +0200
Subject: Fix several issues with the extraction

---
 compiler/Extract.ml     | 164 +++++++++++++++++++++++++++++-------------------
 compiler/ExtractBase.ml |   3 +-
 2 files changed, 100 insertions(+), 67 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/compiler/Extract.ml b/compiler/Extract.ml
index aef37a86..01bd5d38 100644
--- a/compiler/Extract.ml
+++ b/compiler/Extract.ml
@@ -681,15 +681,20 @@ let mk_formatter (ctx : trans_ctx) (crate_name : string)
   in
   let field_name (def_name : name) (field_id : FieldId.id)
       (field_name : string option) : string =
-    let field_name =
+    let field_name_s =
       match field_name with
       | Some field_name -> field_name
-      | None -> FieldId.to_string field_id
+      | None ->
+          (* TODO: extract structs with no field names to tuples *)
+          FieldId.to_string field_id
     in
-    if !Config.record_fields_short_names then field_name
+    if !Config.record_fields_short_names then
+      if field_name = None then (* TODO: this is a bit ugly *)
+        "_" ^ field_name_s
+      else field_name_s
     else
       let def_name = type_name_to_snake_case def_name ^ "_" in
-      def_name ^ field_name
+      def_name ^ field_name_s
   in
   let variant_name (def_name : name) (variant : string) : string =
     match !backend with
@@ -894,7 +899,7 @@ let mk_formatter (ctx : trans_ctx) (crate_name : string)
   let trait_clause_basename (_varset : StringSet.t) (_clause : trait_clause) :
       string =
     (* TODO: actually use the clause to derive the name *)
-    "cl"
+    "inst"
   in
   let trait_self_clause_basename = "self_clause" in
   let append_index (basename : string) (i : int) : string =
@@ -1330,6 +1335,17 @@ and extract_trait_ref (ctx : extraction_ctx) (fmt : F.formatter)
   extract_generic_args ctx fmt no_params_tys tr.generics;
   if use_brackets then F.pp_print_string fmt ")"
 
+and extract_trait_decl_ref (ctx : extraction_ctx) (fmt : F.formatter)
+    (no_params_tys : TypeDeclId.Set.t) (inside : bool) (tr : trait_decl_ref) :
+    unit =
+  let use_brackets = tr.decl_generics <> empty_generic_args && inside in
+  let is_opaque = false in
+  let name = ctx_get_trait_decl is_opaque tr.trait_decl_id ctx in
+  if use_brackets then F.pp_print_string fmt "(";
+  F.pp_print_string fmt name;
+  extract_generic_args ctx fmt no_params_tys tr.decl_generics;
+  if use_brackets then F.pp_print_string fmt ")"
+
 and extract_generic_args (ctx : extraction_ctx) (fmt : F.formatter)
     (no_params_tys : TypeDeclId.Set.t) (generics : generic_args) : unit =
   let { types; const_generics; trait_refs } = generics in
@@ -1734,8 +1750,9 @@ let extract_trait_self_clause (insert_req_space : unit -> unit)
    method and need to insert a trait self clause (see {!TraitSelfClauseId}).
  *)
 let extract_generic_params (ctx : extraction_ctx) (fmt : F.formatter)
-    (no_params_tys : TypeDeclId.Set.t) (use_forall : bool) (as_implicits : bool)
-    (space : bool ref option) (trait_decl : trait_decl option)
+    (no_params_tys : TypeDeclId.Set.t) ?(use_forall = false)
+    ?(use_forall_use_sep = true) ?(as_implicits : bool = false)
+    ?(space : bool ref option = None) ?(trait_decl : trait_decl option = None)
     (generics : generic_params) (type_params : string list)
     (cg_params : string list) (trait_clauses : string list) : unit =
   let all_params = List.concat [ type_params; cg_params; trait_clauses ] in
@@ -1757,9 +1774,10 @@ let extract_generic_params (ctx : extraction_ctx) (fmt : F.formatter)
   (* Print the type/const generic parameters *)
   if all_params <> [] then (
     if use_forall then (
+      if use_forall_use_sep then (
+        insert_req_space ();
+        F.pp_print_string fmt ":");
       insert_req_space ();
-      F.pp_print_string fmt ":";
-      F.pp_print_space fmt ();
       F.pp_print_string fmt "forall");
     (* Small helper - we may need to split the parameters *)
     let print_generics (type_params : string list)
@@ -1917,9 +1935,8 @@ let extract_type_decl_gen (ctx : extraction_ctx) (fmt : F.formatter)
      support trait clauses *)
   assert ((cg_params = [] && trait_clauses = []) || !backend <> HOL4);
   (* Print the generic parameters *)
-  let as_implicits = false in
-  extract_generic_params ctx_body fmt type_decl_group use_forall as_implicits
-    None None def.generics type_params cg_params trait_clauses;
+  extract_generic_params ctx_body fmt type_decl_group ~use_forall def.generics
+    type_params cg_params trait_clauses;
   (* Print the "=" if we extract the body*)
   if extract_body then (
     F.pp_print_space fmt ();
@@ -2149,11 +2166,9 @@ let extract_type_decl_record_field_projectors (ctx : extraction_ctx)
           let field_name = ctx_get_field (AdtId decl.def_id) field_id ctx in
           F.pp_print_string fmt field_name;
           (* Print the generics *)
-          let use_forall = false in
           let as_implicits = true in
-          extract_generic_params ctx fmt TypeDeclId.Set.empty use_forall
-            as_implicits None None decl.generics type_params cg_params
-            trait_clauses;
+          extract_generic_params ctx fmt TypeDeclId.Set.empty ~as_implicits
+            decl.generics type_params cg_params trait_clauses;
           (* Print the record parameter *)
           F.pp_print_space fmt ();
           F.pp_print_string fmt "(";
@@ -3220,11 +3235,9 @@ let extract_fun_parameters (space : bool ref) (ctx : extraction_ctx)
   (* Print the generics *)
   (* Open a box for the generics *)
   F.pp_open_hovbox fmt 0;
-  let use_forall = false in
-  let as_implicits = false in
-  extract_generic_params ctx fmt TypeDeclId.Set.empty use_forall as_implicits
-    (Some space) trait_decl def.signature.generics type_params cg_params
-    trait_clauses;
+  (let space = Some space in
+   extract_generic_params ctx fmt TypeDeclId.Set.empty ~space ~trait_decl
+     def.signature.generics type_params cg_params trait_clauses);
   (* Close the box for the generics *)
   F.pp_close_box fmt ();
   (* The input parameters - note that doing this adds bindings to the context *)
@@ -4064,14 +4077,13 @@ let extract_trait_impl_register_names (ctx : extraction_ctx)
 let extract_trait_item (ctx : extraction_ctx) (fmt : F.formatter)
     (item_name : string) (separator : string) (ty : unit -> unit) : unit =
   F.pp_print_space fmt ();
-  F.pp_open_vbox fmt ctx.indent_incr;
+  F.pp_open_hovbox fmt ctx.indent_incr;
   F.pp_print_string fmt item_name;
   F.pp_print_space fmt ();
   (* ":" or "=" *)
   F.pp_print_string fmt separator;
-  F.pp_print_space fmt ();
   ty ();
-  F.pp_print_string fmt ";";
+  (match !Config.backend with Lean -> () | _ -> F.pp_print_string fmt ";");
   F.pp_close_box fmt ()
 
 let extract_trait_decl_item (ctx : extraction_ctx) (fmt : F.formatter)
@@ -4080,7 +4092,8 @@ let extract_trait_decl_item (ctx : extraction_ctx) (fmt : F.formatter)
 
 let extract_trait_impl_item (ctx : extraction_ctx) (fmt : F.formatter)
     (item_name : string) (ty : unit -> unit) : unit =
-  extract_trait_item ctx fmt item_name "=" ty
+  let assign = match !Config.backend with Lean -> ":=" | _ -> "=" in
+  extract_trait_item ctx fmt item_name assign ty
 
 (** Small helper - TODO: move *)
 let generic_params_drop_prefix (g1 : generic_params) (g2 : generic_params) :
@@ -4115,9 +4128,9 @@ let extract_trait_decl_method_items (ctx : extraction_ctx) (fmt : F.formatter)
         ctx_add_generic_params generics ctx
       in
       let use_forall = generics <> empty_generic_params in
-      let use_implicits = false in
-      extract_generic_params ctx fmt TypeDeclId.Set.empty use_forall
-        use_implicits None None generics type_params cg_params trait_clauses;
+      let use_forall_use_sep = false in
+      extract_generic_params ctx fmt TypeDeclId.Set.empty ~use_forall
+        ~use_forall_use_sep generics type_params cg_params trait_clauses;
       if use_forall then F.pp_print_string fmt ",";
       (* Extract the inputs and output *)
       F.pp_print_space fmt ();
@@ -4136,23 +4149,29 @@ let extract_trait_decl (ctx : extraction_ctx) (fmt : F.formatter)
   (* Add a break before *)
   F.pp_print_break fmt 0 0;
   (* Print a comment to link the extracted type to its original rust definition *)
-  extract_comment fmt [ "[" ^ Print.name_to_string decl.name ^ "]" ];
+  extract_comment fmt
+    [ "Trait declaration: [" ^ Print.name_to_string decl.name ^ "]" ];
   F.pp_print_break fmt 0 0;
-  (* Open two boxes for the definition, so that whenever possible it gets printed on
-   * one line and indents are correct *)
-  F.pp_open_hvbox fmt 0;
-  F.pp_open_vbox fmt ctx.indent_incr;
+  (* Open two outer boxes for the definition, so that whenever possible it gets printed on
+     one line and indents are correct.
+
+     There is just an exception with Lean: in this backend, line breaks are important
+     for the parsing, so we always open a vertical box.
+  *)
+  if !Config.backend = Lean then F.pp_open_vbox fmt ctx.indent_incr
+  else (
+    F.pp_open_hvbox fmt 0;
+    F.pp_open_hvbox fmt ctx.indent_incr);
 
   (* `struct Trait (....) =` *)
   (* Open the box for the name + generics *)
-  F.pp_open_vbox fmt ctx.indent_incr;
+  F.pp_open_hovbox fmt ctx.indent_incr;
   let qualif =
     Option.get (ctx.fmt.type_decl_kind_to_qualif SingleNonRec (Some Struct))
   in
   F.pp_print_string fmt qualif;
   F.pp_print_space fmt ();
   F.pp_print_string fmt decl_name;
-
   (* Print the generics *)
   (* We ignore the trait clauses, which we extract as *fields* *)
   let generics = { decl.generics with trait_clauses = [] } in
@@ -4161,13 +4180,13 @@ let extract_trait_decl (ctx : extraction_ctx) (fmt : F.formatter)
   let ctx, type_params, cg_params, trait_clauses =
     ctx_add_generic_params generics ctx
   in
-  let use_forall = false in
-  let as_implicits = false in
-  extract_generic_params ctx fmt TypeDeclId.Set.empty use_forall as_implicits
-    None None generics type_params cg_params trait_clauses;
+  extract_generic_params ctx fmt TypeDeclId.Set.empty generics type_params
+    cg_params trait_clauses;
 
   F.pp_print_space fmt ();
-  F.pp_print_string fmt "{";
+  (match !backend with
+  | Lean -> F.pp_print_string fmt "where"
+  | _ -> F.pp_print_string fmt "{");
 
   (* Close the box for the name + generics *)
   F.pp_close_box fmt ();
@@ -4225,11 +4244,14 @@ let extract_trait_decl (ctx : extraction_ctx) (fmt : F.formatter)
     decl.required_methods;
 
   (* Close the brackets *)
-  F.pp_print_space fmt ();
-  F.pp_print_string fmt "}";
+  (match !Config.backend with
+  | Lean -> ()
+  | _ ->
+      F.pp_print_space fmt ();
+      F.pp_print_string fmt "}");
 
-  (* Close the two outer boxes for the definition *)
-  F.pp_close_box fmt ();
+  (* Close the outer boxes for the definition *)
+  if !Config.backend <> Lean then F.pp_close_box fmt ();
   F.pp_close_box fmt ();
   (* Add breaks to insert new lines between definitions *)
   F.pp_print_break fmt 0 0
@@ -4258,9 +4280,8 @@ let extract_trait_impl_method_items (ctx : extraction_ctx) (fmt : F.formatter)
       in
       let ctx, f_tys, f_cgs, f_tcs = ctx_add_generic_params f_generics ctx in
       let use_forall = f_generics <> empty_generic_params in
-      let use_implicits = false in
-      extract_generic_params ctx fmt TypeDeclId.Set.empty use_forall
-        use_implicits None None f_generics f_tys f_cgs f_tcs;
+      extract_generic_params ctx fmt TypeDeclId.Set.empty ~use_forall f_generics
+        f_tys f_cgs f_tcs;
       if use_forall then F.pp_print_string fmt ",";
       (* Extract the function call *)
       F.pp_print_space fmt ();
@@ -4289,19 +4310,27 @@ let extract_trait_impl (ctx : extraction_ctx) (fmt : F.formatter)
   (* Add a break before *)
   F.pp_print_break fmt 0 0;
   (* Print a comment to link the extracted type to its original rust definition *)
-  extract_comment fmt [ "[" ^ Print.name_to_string impl.name ^ "]" ];
+  extract_comment fmt
+    [ "Trait implementation: [" ^ Print.name_to_string impl.name ^ "]" ];
   F.pp_print_break fmt 0 0;
-  (* Open two boxes for the definition, so that whenever possible it gets printed on
-   * one line and indents are correct *)
-  F.pp_open_hvbox fmt 0;
-  F.pp_open_vbox fmt ctx.indent_incr;
 
-  (* `let Trait (....) =` *)
+  (* Open two outer boxes for the definition, so that whenever possible it gets printed on
+     one line and indents are correct.
+
+     There is just an exception with Lean: in this backend, line breaks are important
+     for the parsing, so we always open a vertical box.
+  *)
+  if !Config.backend = Lean then (
+    F.pp_open_vbox fmt 0;
+    F.pp_open_vbox fmt ctx.indent_incr)
+  else (
+    F.pp_open_hvbox fmt 0;
+    F.pp_open_hvbox fmt ctx.indent_incr);
+
+  (* `let (....) : Trait ... =` *)
   (* Open the box for the name + generics *)
-  F.pp_open_vbox fmt ctx.indent_incr;
-  let qualif =
-    Option.get (ctx.fmt.type_decl_kind_to_qualif SingleNonRec None)
-  in
+  F.pp_open_hovbox fmt ctx.indent_incr;
+  let qualif = Option.get (ctx.fmt.fun_decl_kind_to_qualif SingleNonRec) in
   F.pp_print_string fmt qualif;
   F.pp_print_space fmt ();
   F.pp_print_string fmt impl_name;
@@ -4313,13 +4342,18 @@ let extract_trait_impl (ctx : extraction_ctx) (fmt : F.formatter)
     ctx_add_generic_params impl.generics ctx
   in
   let all_generics = (type_params, cg_params, trait_clauses) in
-  let use_forall = false in
-  let as_implicits = false in
-  extract_generic_params ctx fmt TypeDeclId.Set.empty use_forall as_implicits
-    None None impl.generics type_params cg_params trait_clauses;
+  extract_generic_params ctx fmt TypeDeclId.Set.empty impl.generics type_params
+    cg_params trait_clauses;
+
+  (* Print the type *)
+  F.pp_print_space fmt ();
+  F.pp_print_string fmt ":";
+  F.pp_print_space fmt ();
+  extract_trait_decl_ref ctx fmt TypeDeclId.Set.empty false impl.impl_trait;
 
   F.pp_print_space fmt ();
-  F.pp_print_string fmt "{";
+  if !Config.backend = Lean then F.pp_print_string fmt ":= {"
+  else F.pp_print_string fmt "= {";
 
   (* Close the box for the name + generics *)
   F.pp_close_box fmt ();
@@ -4374,12 +4408,10 @@ let extract_trait_impl (ctx : extraction_ctx) (fmt : F.formatter)
       extract_trait_impl_method_items ctx fmt impl name id all_generics)
     impl.required_methods;
 
-  (* Close the brackets *)
+  (* Close the outer boxes for the definition, as well as the brackets *)
+  F.pp_close_box fmt ();
   F.pp_print_space fmt ();
   F.pp_print_string fmt "}";
-
-  (* Close the two outer boxes for the definition *)
-  F.pp_close_box fmt ();
   F.pp_close_box fmt ();
   (* Add breaks to insert new lines between definitions *)
   F.pp_print_break fmt 0 0
diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index 4238d9af..a81ec052 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -952,7 +952,8 @@ let ctx_get (with_opaque_pre : bool) (id : id) (ctx : extraction_ctx) : string =
         in
         log#serror err;
         if !Config.extract_fail_hard then raise (Failure err)
-        else "(ERROR: \"" ^ id_to_string id ctx ^ "\")")
+        else
+          "(%%%ERROR: unknown identifier\": " ^ id_to_string id ctx ^ "\"%%%)")
   else
     let m = ctx.names_map.id_to_name in
     match IdMap.find_opt id m with
-- 
cgit v1.3.1


From 47bc2ba74c90c1a29a081b8950022f74408f037e Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Sun, 17 Sep 2023 05:15:18 +0200
Subject: Merge trans_ctx and decls_ctx

---
 compiler/Contexts.ml        |  6 +++-
 compiler/Extract.ml         |  8 ++---
 compiler/ExtractBase.ml     | 12 +++----
 compiler/Interpreter.ml     | 12 ++++---
 compiler/PureMicroPasses.ml | 11 +++----
 compiler/Translate.ml       | 79 ++++++++++-----------------------------------
 compiler/TranslateCore.ml   | 45 +++++++-------------------
 7 files changed, 53 insertions(+), 120 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/compiler/Contexts.ml b/compiler/Contexts.ml
index 65760d94..a5bc7dc0 100644
--- a/compiler/Contexts.ml
+++ b/compiler/Contexts.ml
@@ -255,7 +255,11 @@ type type_context = {
 }
 [@@deriving show]
 
-type fun_context = { fun_decls : fun_decl FunDeclId.Map.t } [@@deriving show]
+type fun_context = {
+  fun_decls : fun_decl FunDeclId.Map.t;
+  fun_infos : FunsAnalysis.fun_info FunDeclId.Map.t;
+}
+[@@deriving show]
 
 type global_context = { global_decls : global_decl GlobalDeclId.Map.t }
 [@@deriving show]
diff --git a/compiler/Extract.ml b/compiler/Extract.ml
index e841082b..596fa013 100644
--- a/compiler/Extract.ml
+++ b/compiler/Extract.ml
@@ -856,9 +856,7 @@ let mk_formatter (ctx : trans_ctx) (crate_name : string)
             | Assumed Range -> "r"
             | Assumed State -> ConstStrings.state_basename
             | AdtId adt_id ->
-                let def =
-                  TypeDeclId.Map.find adt_id ctx.type_context.type_decls
-                in
+                let def = TypeDeclId.Map.find adt_id ctx.type_ctx.type_decls in
                 (* Derive the var name from the last ident of the type name
                  * Ex.: ["hashmap"; "HashMap"] ~~> "HashMap" -> "hash_map" -> "hm"
                  *)
@@ -3115,9 +3113,7 @@ and extract_StructUpdate (ctx : extraction_ctx) (fmt : F.formatter)
   let extract_as_unit =
     match (!backend, supd.struct_id) with
     | HOL4, AdtId adt_id ->
-        let d =
-          TypeDeclId.Map.find adt_id ctx.trans_ctx.type_context.type_decls
-        in
+        let d = TypeDeclId.Map.find adt_id ctx.trans_ctx.type_ctx.type_decls in
         d.kind = Struct []
     | _ -> false
   in
diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index a81ec052..1586e6ed 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -709,10 +709,10 @@ type extraction_ctx = {
     instance).
  *)
 let id_to_string (id : id) (ctx : extraction_ctx) : string =
-  let global_decls = ctx.trans_ctx.global_context.global_decls in
-  let fun_decls = ctx.trans_ctx.fun_context.fun_decls in
-  let type_decls = ctx.trans_ctx.type_context.type_decls in
-  let trait_decls = ctx.trans_ctx.trait_decls_context.trait_decls in
+  let global_decls = ctx.trans_ctx.global_ctx.global_decls in
+  let fun_decls = ctx.trans_ctx.fun_ctx.fun_decls in
+  let type_decls = ctx.trans_ctx.type_ctx.type_decls in
+  let trait_decls = ctx.trans_ctx.trait_decls_ctx.trait_decls in
   let trait_decl_id_to_string (id : A.TraitDeclId.id) : string =
     let trait_name =
       Print.fun_name_to_string (A.TraitDeclId.Map.find id trait_decls).name
@@ -1293,9 +1293,7 @@ let ctx_compute_fun_name (trans_group : pure_fun_translation) (def : fun_decl)
     (ctx : extraction_ctx) : string =
   (* Lookup the LLBC def to compute the region group information *)
   let def_id = def.def_id in
-  let llbc_def =
-    A.FunDeclId.Map.find def_id ctx.trans_ctx.fun_context.fun_decls
-  in
+  let llbc_def = A.FunDeclId.Map.find def_id ctx.trans_ctx.fun_ctx.fun_decls in
   let sg = llbc_def.signature in
   let num_rgs = List.length sg.regions_hierarchy in
   let { keep_fwd; fwd = _; backs } = trans_group in
diff --git a/compiler/Interpreter.ml b/compiler/Interpreter.ml
index 4ce6dae8..752d6f2f 100644
--- a/compiler/Interpreter.ml
+++ b/compiler/Interpreter.ml
@@ -26,7 +26,10 @@ let compute_contexts (m : A.crate) : C.decls_ctx =
     TypesAnalysis.analyze_type_declarations type_decls type_decls_list
   in
   let type_ctx = { C.type_decls_groups; type_decls; type_infos } in
-  let fun_ctx = { C.fun_decls } in
+  let fun_infos =
+    FunsAnalysis.analyze_module m fun_decls global_decls !Config.use_state
+  in
+  let fun_ctx = { C.fun_decls; fun_infos } in
   let global_ctx = { C.global_decls } in
   let trait_decls_ctx = { C.trait_decls } in
   let trait_impls_ctx = { C.trait_impls } in
@@ -567,7 +570,8 @@ module Test = struct
   (** Test a unit function (taking no arguments) by evaluating it in an empty
       environment.
    *)
-  let test_unit_function (crate : A.crate) (fid : A.FunDeclId.id) : unit =
+  let test_unit_function (crate : A.crate) (decls_ctx : C.decls_ctx)
+      (fid : A.FunDeclId.id) : unit =
     (* Retrieve the function declaration *)
     let fdef = A.FunDeclId.Map.find fid crate.functions in
     let body = Option.get fdef.body in
@@ -581,7 +585,6 @@ module Test = struct
     assert (body.A.arg_count = 0);
 
     (* Create the evaluation context *)
-    let decls_ctx = compute_contexts crate in
     let ctx = initialize_eval_context decls_ctx [] [] [] in
 
     (* Insert the (uninitialized) local variables *)
@@ -620,8 +623,9 @@ module Test = struct
         (fun _ -> fun_decl_is_transparent_unit)
         crate.functions
     in
+    let decls_ctx = compute_contexts crate in
     let test_unit_fun _ (def : A.fun_decl) : unit =
-      test_unit_function crate def.A.def_id
+      test_unit_function crate decls_ctx def.A.def_id
     in
     A.FunDeclId.Map.iter test_unit_fun unit_funs
 end
diff --git a/compiler/PureMicroPasses.ml b/compiler/PureMicroPasses.ml
index 53148dbb..2130d5c2 100644
--- a/compiler/PureMicroPasses.ml
+++ b/compiler/PureMicroPasses.ml
@@ -586,9 +586,7 @@ let intro_struct_updates (ctx : trans_ctx) (def : fun_decl) : fun_decl =
                   generics = _;
                 } ->
                 (* Lookup the def *)
-                let decl =
-                  TypeDeclId.Map.find adt_id ctx.type_context.type_decls
-                in
+                let decl = TypeDeclId.Map.find adt_id ctx.type_ctx.type_decls in
                 (* Check that there are as many arguments as there are fields - note
                    that the def should have a body (otherwise we couldn't use the
                    constructor) *)
@@ -597,8 +595,7 @@ let intro_struct_updates (ctx : trans_ctx) (def : fun_decl) : fun_decl =
                   (* Check if the definition is recursive *)
                   let is_rec =
                     match
-                      TypeDeclId.Map.find adt_id
-                        ctx.type_context.type_decls_groups
+                      TypeDeclId.Map.find adt_id ctx.type_ctx.type_decls_groups
                     with
                     | NonRec _ -> false
                     | Rec _ -> true
@@ -796,7 +793,7 @@ let expression_contains_child_call_in_all_paths (ctx : trans_ctx)
                       | FunId fun_id -> fun_id
                       | TraitMethod (_, _, fun_decl_id) -> A.Regular fun_decl_id
                     in
-                    LlbcAstUtils.lookup_fun_sig id0 ctx.fun_context.fun_decls
+                    LlbcAstUtils.lookup_fun_sig id0 ctx.fun_ctx.fun_decls
                   in
                   (* Compute the set of ancestors of the function in call1 *)
                   let call1_ancestors =
@@ -1094,7 +1091,7 @@ let simplify_aggregates (ctx : trans_ctx) (def : fun_decl) : fun_decl =
                 (* This is a struct *)
                 (* Retrieve the definiton, to find how many fields there are *)
                 let adt_decl =
-                  TypeDeclId.Map.find adt_id ctx.type_context.type_decls
+                  TypeDeclId.Map.find adt_id ctx.type_ctx.type_decls
                 in
                 let fields =
                   match adt_decl.kind with
diff --git a/compiler/Translate.ml b/compiler/Translate.ml
index 4a4affea..13e339ea 100644
--- a/compiler/Translate.ml
+++ b/compiler/Translate.ml
@@ -29,34 +29,12 @@ let translate_function_to_symbolics (trans_ctx : trans_ctx) (fdef : A.fun_decl)
       ("translate_function_to_symbolics: "
       ^ Print.fun_name_to_string fdef.A.name));
 
-  let {
-    type_context;
-    fun_context;
-    global_context;
-    trait_decls_context;
-    trait_impls_context;
-  } =
-    trans_ctx
-  in
-  let fun_context = { C.fun_decls = fun_context.fun_decls } in
-
-  (* TODO: we should merge trans_ctx and decls_ctx *)
-  let decls_ctx : C.decls_ctx =
-    {
-      C.type_ctx = type_context;
-      fun_ctx = fun_context;
-      global_ctx = global_context;
-      trait_decls_ctx = trait_decls_context;
-      trait_impls_ctx = trait_impls_context;
-    }
-  in
-
   match fdef.body with
   | None -> None
   | Some _ ->
       (* Evaluate *)
       let synthesize = true in
-      let inputs, symb = evaluate_function_symbolic synthesize decls_ctx fdef in
+      let inputs, symb = evaluate_function_symbolic synthesize trans_ctx fdef in
       Some (inputs, Option.get symb)
 
 (** Translate a function, by generating its forward and backward translations.
@@ -74,15 +52,6 @@ let translate_function_to_pure (trans_ctx : trans_ctx)
     (lazy
       ("translate_function_to_pure: " ^ Print.fun_name_to_string fdef.A.name));
 
-  let {
-    type_context;
-    fun_context;
-    global_context;
-    trait_decls_context;
-    trait_impls_context;
-  } =
-    trans_ctx
-  in
   let def_id = fdef.def_id in
 
   (* Compute the symbolic ASTs, if the function is transparent *)
@@ -107,25 +76,25 @@ let translate_function_to_pure (trans_ctx : trans_ctx)
       (List.filter_map
          (fun (tid, g) ->
            match g with Charon.GAst.NonRec _ -> None | Rec _ -> Some tid)
-         (T.TypeDeclId.Map.bindings trans_ctx.type_context.type_decls_groups))
+         (T.TypeDeclId.Map.bindings trans_ctx.type_ctx.type_decls_groups))
   in
   let type_context =
     {
-      SymbolicToPure.type_infos = type_context.type_infos;
-      llbc_type_decls = type_context.type_decls;
+      SymbolicToPure.type_infos = trans_ctx.type_ctx.type_infos;
+      llbc_type_decls = trans_ctx.type_ctx.type_decls;
       type_decls = pure_type_decls;
       recursive_decls = recursive_type_decls;
     }
   in
   let fun_context =
     {
-      SymbolicToPure.llbc_fun_decls = fun_context.fun_decls;
+      SymbolicToPure.llbc_fun_decls = trans_ctx.fun_ctx.fun_decls;
       fun_sigs;
-      fun_infos = fun_context.fun_infos;
+      fun_infos = trans_ctx.fun_ctx.fun_infos;
     }
   in
   let global_context =
-    { SymbolicToPure.llbc_global_decls = global_context.global_decls }
+    { SymbolicToPure.llbc_global_decls = trans_ctx.global_ctx.global_decls }
   in
 
   (* Compute the set of loops, and find better ids for them (starting at 0).
@@ -173,8 +142,8 @@ let translate_function_to_pure (trans_ctx : trans_ctx)
       type_context;
       fun_context;
       global_context;
-      trait_decls_ctx = trait_decls_context.trait_decls;
-      trait_impls_ctx = trait_impls_context.trait_impls;
+      trait_decls_ctx = trans_ctx.trait_decls_ctx.trait_decls;
+      trait_impls_ctx = trans_ctx.trait_impls_ctx.trait_impls;
       fun_decl = fdef;
       forward_inputs = [];
       (* Empty for now *)
@@ -311,22 +280,8 @@ let translate_crate_to_pure (crate : A.crate) :
   (* Debug *)
   log#ldebug (lazy "translate_crate_to_pure");
 
-  (* Compute the type and function contexts *)
-  let decls_ctx = compute_contexts crate in
-  let fun_infos =
-    FA.analyze_module crate decls_ctx.fun_ctx.C.fun_decls
-      decls_ctx.global_ctx.C.global_decls !Config.use_state
-  in
-  let fun_context = { fun_decls = decls_ctx.fun_ctx.fun_decls; fun_infos } in
-  let trans_ctx =
-    {
-      type_context = decls_ctx.type_ctx;
-      fun_context;
-      global_context = decls_ctx.global_ctx;
-      trait_decls_context = decls_ctx.trait_decls_ctx;
-      trait_impls_context = decls_ctx.trait_impls_ctx;
-    }
-  in
+  (* Compute the translation context *)
+  let trans_ctx = compute_contexts crate in
 
   (* Translate all the type definitions *)
   let type_decls =
@@ -362,8 +317,8 @@ let translate_crate_to_pure (crate : A.crate) :
   in
   let sigs = List.append assumed_sigs local_sigs in
   let fun_sigs =
-    SymbolicToPure.translate_fun_signatures fun_context.fun_infos
-      decls_ctx.type_ctx.type_infos sigs
+    SymbolicToPure.translate_fun_signatures trans_ctx.fun_ctx.fun_infos
+      trans_ctx.type_ctx.type_infos sigs
   in
 
   (* Translate all the *transparent* functions *)
@@ -374,18 +329,18 @@ let translate_crate_to_pure (crate : A.crate) :
   in
 
   (* Translate the trait declarations *)
-  let type_infos = trans_ctx.type_context.type_infos in
+  let type_infos = trans_ctx.type_ctx.type_infos in
   let trait_decls =
     List.map
       (SymbolicToPure.translate_trait_decl type_infos)
-      (T.TraitDeclId.Map.values trans_ctx.trait_decls_context.trait_decls)
+      (T.TraitDeclId.Map.values trans_ctx.trait_decls_ctx.trait_decls)
   in
 
   (* Translate the trait implementations *)
   let trait_impls =
     List.map
       (SymbolicToPure.translate_trait_impl type_infos)
-      (T.TraitImplId.Map.values trans_ctx.trait_impls_context.trait_impls)
+      (T.TraitImplId.Map.values trans_ctx.trait_impls_ctx.trait_impls)
   in
 
   (* Apply the micro-passes *)
@@ -554,7 +509,7 @@ let export_types_group (fmt : Format.formatter) (config : gen_config)
  *)
 let export_global (fmt : Format.formatter) (config : gen_config) (ctx : gen_ctx)
     (id : A.GlobalDeclId.id) : unit =
-  let global_decls = ctx.trans_ctx.global_context.global_decls in
+  let global_decls = ctx.trans_ctx.global_ctx.global_decls in
   let global = A.GlobalDeclId.Map.find id global_decls in
   let trans = A.FunDeclId.Map.find global.body_id ctx.trans_funs in
   assert (trans.fwd.loops = []);
diff --git a/compiler/TranslateCore.ml b/compiler/TranslateCore.ml
index f31dc458..3427fd43 100644
--- a/compiler/TranslateCore.ml
+++ b/compiler/TranslateCore.ml
@@ -10,27 +10,7 @@ module FA = FunsAnalysis
 (** The local logger *)
 let log = L.translate_log
 
-type type_context = C.type_context [@@deriving show]
-
-type fun_context = {
-  fun_decls : A.fun_decl A.FunDeclId.Map.t;
-  fun_infos : FA.fun_info A.FunDeclId.Map.t;
-}
-[@@deriving show]
-
-type trait_decls_context = C.trait_decls_context [@@deriving show]
-type trait_impls_context = C.trait_impls_context [@@deriving show]
-type global_context = C.global_context [@@deriving show]
-
-(* TODO: we should use Contexts.decls_ctx *)
-type trans_ctx = {
-  type_context : type_context;
-  fun_context : fun_context;
-  global_context : global_context;
-  trait_decls_context : trait_decls_context;
-  trait_impls_context : trait_impls_context;
-}
-
+type trans_ctx = C.decls_ctx [@@deriving show]
 type fun_and_loops = { f : Pure.fun_decl; loops : Pure.fun_decl list }
 type pure_fun_translation_no_loops = Pure.fun_decl * Pure.fun_decl list
 
@@ -50,10 +30,10 @@ let trans_ctx_to_type_formatter (ctx : trans_ctx)
     (type_params : Pure.type_var list)
     (const_generic_params : Pure.const_generic_var list) :
     PrintPure.type_formatter =
-  let type_decls = ctx.type_context.type_decls in
-  let global_decls = ctx.global_context.global_decls in
-  let trait_decls = ctx.trait_decls_context.trait_decls in
-  let trait_impls = ctx.trait_impls_context.trait_impls in
+  let type_decls = ctx.type_ctx.type_decls in
+  let global_decls = ctx.global_ctx.global_decls in
+  let trait_decls = ctx.trait_decls_ctx.trait_decls in
+  let trait_impls = ctx.trait_impls_ctx.trait_impls in
   PrintPure.mk_type_formatter type_decls global_decls trait_decls trait_impls
     type_params const_generic_params
 
@@ -66,17 +46,17 @@ let type_decl_to_string (ctx : trans_ctx) (def : Pure.type_decl) : string =
 
 let type_id_to_string (ctx : trans_ctx) (id : Pure.TypeDeclId.id) : string =
   Print.fun_name_to_string
-    (Pure.TypeDeclId.Map.find id ctx.type_context.type_decls).name
+    (Pure.TypeDeclId.Map.find id ctx.type_ctx.type_decls).name
 
 let trans_ctx_to_ast_formatter (ctx : trans_ctx)
     (type_params : Pure.type_var list)
     (const_generic_params : Pure.const_generic_var list) :
     PrintPure.ast_formatter =
-  let type_decls = ctx.type_context.type_decls in
-  let fun_decls = ctx.fun_context.fun_decls in
-  let global_decls = ctx.global_context.global_decls in
-  let trait_decls = ctx.trait_decls_context.trait_decls in
-  let trait_impls = ctx.trait_impls_context.trait_impls in
+  let type_decls = ctx.type_ctx.type_decls in
+  let fun_decls = ctx.fun_ctx.fun_decls in
+  let global_decls = ctx.global_ctx.global_decls in
+  let trait_decls = ctx.trait_decls_ctx.trait_decls in
+  let trait_impls = ctx.trait_impls_ctx.trait_impls in
   PrintPure.mk_ast_formatter type_decls fun_decls global_decls trait_decls
     trait_impls type_params const_generic_params
 
@@ -95,5 +75,4 @@ let fun_decl_to_string (ctx : trans_ctx) (def : Pure.fun_decl) : string =
   PrintPure.fun_decl_to_string fmt def
 
 let fun_decl_id_to_string (ctx : trans_ctx) (id : A.FunDeclId.id) : string =
-  Print.fun_name_to_string
-    (A.FunDeclId.Map.find id ctx.fun_context.fun_decls).name
+  Print.fun_name_to_string (A.FunDeclId.Map.find id ctx.fun_ctx.fun_decls).name
-- 
cgit v1.3.1


From f11d5186b467df318f7c09eedf8b5629c165b453 Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Fri, 20 Oct 2023 15:05:00 +0200
Subject: Start updating to handle function pointers

---
 compiler/AssociatedTypes.ml        | 12 +++++-
 compiler/Assumed.ml                |  2 +-
 compiler/Extract.ml                |  4 +-
 compiler/ExtractBase.ml            |  2 +-
 compiler/FunsAnalysis.ml           |  2 +-
 compiler/InterpreterExpansion.ml   |  2 +-
 compiler/InterpreterExpressions.ml |  9 +++--
 compiler/InterpreterStatements.ml  | 78 +++++++++++++++++++++-----------------
 compiler/InterpreterUtils.ml       |  5 +++
 compiler/Print.ml                  | 23 +++++++++++
 compiler/PrintPure.ml              | 22 +++++------
 compiler/PureMicroPasses.ml        | 32 ++++++++--------
 compiler/SymbolicToPure.ml         | 50 +++++++++++++-----------
 compiler/SynthesizeSymbolic.ml     |  2 +-
 compiler/Translate.ml              | 10 ++---
 compiler/TypesAnalysis.ml          |  8 ++++
 16 files changed, 163 insertions(+), 100 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/compiler/AssociatedTypes.ml b/compiler/AssociatedTypes.ml
index 992dade9..022aad2f 100644
--- a/compiler/AssociatedTypes.ml
+++ b/compiler/AssociatedTypes.ml
@@ -157,7 +157,8 @@ let ctx_add_norm_trait_types_from_preds (ctx : C.eval_ctx)
 let rec trait_instance_id_is_local_clause (id : 'r T.trait_instance_id) : bool =
   match id with
   | T.Self | Clause _ -> true
-  | TraitImpl _ | BuiltinOrAuto _ | TraitRef _ | UnknownTrait _ -> false
+  | TraitImpl _ | BuiltinOrAuto _ | TraitRef _ | UnknownTrait _ | FnPointer _ ->
+      false
   | ParentClause (id, _, _) | ItemClause (id, _, _, _) ->
       trait_instance_id_is_local_clause id
 
@@ -187,6 +188,10 @@ let rec ctx_normalize_ty : 'r. 'r norm_ctx -> 'r T.ty -> 'r T.ty =
   | Ref (r, ty, rkind) ->
       let ty = ctx_normalize_ty ctx ty in
       T.Ref (r, ty, rkind)
+  | Arrow (inputs, output) ->
+      let inputs = List.map (ctx_normalize_ty ctx) inputs in
+      let output = ctx_normalize_ty ctx output in
+      Arrow (inputs, output)
   | TraitType (trait_ref, generics, type_name) -> (
       log#ldebug
         (lazy
@@ -401,6 +406,11 @@ and ctx_normalize_trait_instance_id :
       assert (trait_instance_id_is_local_clause trait_ref.trait_id);
       assert (trait_ref.generics = TypesUtils.mk_empty_generic_args);
       (trait_ref.trait_id, None)
+  | FnPointer ty ->
+      let ty = ctx_normalize_ty ctx ty in
+      (* TODO: we might want to return the ref to the function pointer,
+         in order to later normalize a call to this function pointer *)
+      (FnPointer ty, None)
   | UnknownTrait _ ->
       (* This is actually an error case *)
       (id, None)
diff --git a/compiler/Assumed.ml b/compiler/Assumed.ml
index 109175af..b1ec0660 100644
--- a/compiler/Assumed.ml
+++ b/compiler/Assumed.ml
@@ -347,7 +347,7 @@ let assumed_infos : assumed_info list =
   let vec_pre = [ "alloc"; "vec"; "Vec" ] in
   let index_pre = [ "core"; "ops"; "index" ] in
   [
-    (A.Replace, Sig.mem_replace_sig, false, to_name [ "core"; "mem"; "replace" ]);
+    (Replace, Sig.mem_replace_sig, false, to_name [ "core"; "mem"; "replace" ]);
     (BoxNew, Sig.box_new_sig, false, to_name [ "alloc"; "boxed"; "Box"; "new" ]);
     ( BoxFree,
       Sig.box_free_sig,
diff --git a/compiler/Extract.ml b/compiler/Extract.ml
index ac81d6f3..688f6ce3 100644
--- a/compiler/Extract.ml
+++ b/compiler/Extract.ml
@@ -2696,7 +2696,7 @@ and extract_function_call (ctx : extraction_ctx) (fmt : F.formatter)
             (* Provided method: we see it as a regular function call, and use
                the function name *)
             let fun_id =
-              FromLlbc (FunId (A.Regular method_id.id), lp_id, rg_id)
+              FromLlbc (FunId (Regular method_id.id), lp_id, rg_id)
             in
             let fun_name = ctx_get_function with_opaque_pre fun_id ctx in
             F.pp_print_string fmt fun_name;
@@ -3519,7 +3519,7 @@ let extract_fun_comment (ctx : extraction_ctx) (fmt : F.formatter)
     (def : fun_decl) : unit =
   let { keep_fwd; num_backs } =
     PureUtils.RegularFunIdMap.find
-      (Pure.FunId (A.Regular def.def_id), def.loop_id, def.back_id)
+      (Pure.FunId (Regular def.def_id), def.loop_id, def.back_id)
       ctx.fun_name_info
   in
   let comment_pre = "[" ^ Print.fun_name_to_string def.basename ^ "]: " in
diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index 1586e6ed..a921515b 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -1482,7 +1482,7 @@ let initialize_names_map (fmt : formatter) (init : names_map_init) : names_map =
   let assumed_functions =
     List.map
       (fun (fid, rg, name) ->
-        (FromLlbc (Pure.FunId (A.Assumed fid), None, rg), name))
+        (FromLlbc (Pure.FunId (Assumed fid), None, rg), name))
       init.assumed_llbc_functions
     @ List.map (fun (fid, name) -> (Pure fid, name)) init.assumed_pure_functions
   in
diff --git a/compiler/FunsAnalysis.ml b/compiler/FunsAnalysis.ml
index f4406653..a09a6d05 100644
--- a/compiler/FunsAnalysis.ml
+++ b/compiler/FunsAnalysis.ml
@@ -76,7 +76,7 @@ let analyze_module (m : crate) (funs_map : fun_decl FunDeclId.Map.t)
                 can_fail := EU.binop_can_fail bop || !can_fail
 
           method! visit_Call env call =
-            (match call.func with
+            (match call.func.func with
             | FunId (Regular id) ->
                 if FunDeclId.Set.mem id fun_ids then (
                   can_diverge := true;
diff --git a/compiler/InterpreterExpansion.ml b/compiler/InterpreterExpansion.ml
index ea692386..c1041fa3 100644
--- a/compiler/InterpreterExpansion.ml
+++ b/compiler/InterpreterExpansion.ml
@@ -709,7 +709,7 @@ let greedy_expand_symbolics_with_borrows (config : C.config) : cm_fun =
             raise
               (Failure
                  "Attempted to greedily expand an ADT which can't be expanded ")
-        | T.TypeVar _ | T.Literal _ | Never | T.TraitType _ ->
+        | T.TypeVar _ | T.Literal _ | Never | T.TraitType _ | T.Arrow _ ->
             raise (Failure "Unreachable")
       in
       (* Compose and continue *)
diff --git a/compiler/InterpreterExpressions.ml b/compiler/InterpreterExpressions.ml
index 29826233..a42c552a 100644
--- a/compiler/InterpreterExpressions.ml
+++ b/compiler/InterpreterExpressions.ml
@@ -271,7 +271,7 @@ let eval_operand_no_reorganize (config : C.config) (op : E.operand)
       match cv.value with
       | E.CLiteral lit ->
           cf (literal_to_typed_value (TypesUtils.ty_as_literal cv.ty) lit) ctx
-      | E.TraitConst (trait_ref, generics, const_name) -> (
+      | E.CTraitConst (trait_ref, generics, const_name) -> (
           assert (generics = TypesUtils.mk_empty_generic_args);
           match trait_ref.trait_id with
           | T.TraitImpl _ ->
@@ -329,7 +329,8 @@ let eval_operand_no_reorganize (config : C.config) (op : E.operand)
                      None,
                      value_as_symbolic v.value,
                      SymbolicAst.ConstGenericValue vid,
-                     e ))))
+                     e )))
+      | E.CFnPtr _ -> raise (Failure "TODO"))
   | E.Copy p ->
       (* Access the value *)
       let access = Read in
@@ -426,7 +427,7 @@ let eval_unary_op_concrete (config : C.config) (unop : E.unop) (op : E.operand)
         match mk_scalar sv.int_ty i with
         | Error _ -> cf (Error EPanic)
         | Ok sv -> cf (Ok { v with V.value = V.Literal (PV.Scalar sv) }))
-    | E.Cast (src_ty, tgt_ty), V.Literal (PV.Scalar sv) -> (
+    | E.Cast (E.CastInteger (src_ty, tgt_ty)), V.Literal (PV.Scalar sv) -> (
         assert (src_ty = sv.int_ty);
         let i = sv.PV.value in
         match mk_scalar tgt_ty i with
@@ -452,7 +453,7 @@ let eval_unary_op_symbolic (config : C.config) (unop : E.unop) (op : E.operand)
       match (unop, v.V.ty) with
       | E.Not, (T.Literal Bool as lty) -> lty
       | E.Neg, (T.Literal (Integer _) as lty) -> lty
-      | E.Cast (_, tgt_ty), _ -> T.Literal (Integer tgt_ty)
+      | E.Cast (E.CastInteger (_, tgt_ty)), _ -> T.Literal (Integer tgt_ty)
       | _ -> raise (Failure "Invalid input for unop")
     in
     let res_sv =
diff --git a/compiler/InterpreterStatements.ml b/compiler/InterpreterStatements.ml
index 36bc3492..9f35c6f2 100644
--- a/compiler/InterpreterStatements.ml
+++ b/compiler/InterpreterStatements.ml
@@ -306,7 +306,7 @@ let get_assumed_function_return_type (ctx : C.eval_ctx) (fid : A.assumed_fun_id)
   assert (generics.trait_refs = []);
   (* [Box::free] has a special treatment *)
   match fid with
-  | A.BoxFree ->
+  | BoxFree ->
       assert (generics.regions = []);
       assert (List.length generics.types = 1);
       assert (generics.const_generics = []);
@@ -583,7 +583,7 @@ let eval_vec_function_concrete (_config : C.config) (_fid : A.assumed_fun_id)
 (** Evaluate a non-local function call in concrete mode *)
 let eval_assumed_function_call_concrete (config : C.config)
     (fid : A.assumed_fun_id) (call : A.call) : cm_fun =
-  let generics = call.generics in
+  let generics = call.func.generics in
   let args = call.args in
   let dest = call.dest in
   (* Sanity check: we don't fully handle the const generic vars environment
@@ -595,7 +595,7 @@ let eval_assumed_function_call_concrete (config : C.config)
      See {!eval_box_free}
   *)
   match fid with
-  | A.BoxFree ->
+  | BoxFree ->
       (* Degenerate case: box_free *)
       eval_box_free config generics args dest
   | _ ->
@@ -636,7 +636,7 @@ let eval_assumed_function_call_concrete (config : C.config)
          * access to a body. *)
         let cf_eval_body : cm_fun =
           match fid with
-          | A.Replace -> eval_replace_concrete config generics
+          | Replace -> eval_replace_concrete config generics
           | BoxNew -> eval_box_new_concrete config generics
           | BoxDeref -> eval_box_deref_concrete config generics
           | BoxDerefMut -> eval_box_deref_mut_concrete config generics
@@ -854,15 +854,14 @@ and eval_global (config : C.config) (dest : E.place) (gid : LA.GlobalDeclId.id)
   match config.mode with
   | ConcreteMode ->
       (* Treat the evaluation of the global as a call to the global body (without arguments) *)
-      let call =
+      let func =
         {
-          A.func = A.FunId (A.Regular global.body_id);
+          E.func = FunId (Regular global.body_id);
           generics = TypesUtils.mk_empty_generic_args;
           trait_and_method_generic_args = None;
-          args = [];
-          dest;
         }
       in
+      let call = { A.func; args = []; dest } in
       (eval_transparent_function_call_concrete config global.body_id call)
         cf ctx
   | SymbolicMode ->
@@ -1019,29 +1018,28 @@ and eval_function_call (config : C.config) (call : A.call) : st_cm_fun =
 and eval_function_call_concrete (config : C.config) (call : A.call) : st_cm_fun
     =
  fun cf ctx ->
-  match call.func with
-  | A.FunId (A.Regular fid) ->
+  match call.func.func with
+  | FunId (Regular fid) ->
       eval_transparent_function_call_concrete config fid call cf ctx
-  | A.FunId (A.Assumed fid) ->
+  | FunId (Assumed fid) ->
       (* Continue - note that we do as if the function call has been successful,
        * by giving {!Unit} to the continuation, because we place us in the case
        * where we haven't panicked. Of course, the translation needs to take the
        * panic case into account... *)
       eval_assumed_function_call_concrete config fid call (cf Unit) ctx
-  | A.TraitMethod _ -> raise (Failure "Unimplemented")
+  | TraitMethod _ -> raise (Failure "Unimplemented")
 
 and eval_function_call_symbolic (config : C.config) (call : A.call) : st_cm_fun
     =
-  match call.func with
-  | A.FunId (A.Regular _) | A.TraitMethod _ ->
+  match call.func.func with
+  | FunId (Regular _) | TraitMethod _ ->
       eval_transparent_function_call_symbolic config call
-  | A.FunId (A.Assumed fid) ->
-      eval_assumed_function_call_symbolic config fid call
+  | FunId (Assumed fid) -> eval_assumed_function_call_symbolic config fid call
 
 (** Evaluate a local (i.e., non-assumed) function call in concrete mode *)
 and eval_transparent_function_call_concrete (config : C.config)
     (fid : A.FunDeclId.id) (call : A.call) : st_cm_fun =
-  let generics = call.A.generics in
+  let generics = call.func.generics in
   let args = call.A.args in
   let dest = call.A.dest in
   (* Sanity check: we don't fully handle the const generic vars environment
@@ -1195,29 +1193,29 @@ and eval_transparent_function_call_symbolic (config : C.config) (call : A.call)
      to a trait clause but directly to the method provided in the trait declaration.
   *)
   let func, generics, def, inst_sg =
-    match call.func with
-    | A.FunId (A.Regular fid) ->
+    match call.func.func with
+    | FunId (Regular fid) ->
         let def = C.ctx_lookup_fun_decl ctx fid in
         let tr_self = T.UnknownTrait __FUNCTION__ in
         let inst_sg =
-          instantiate_fun_sig ctx call.generics tr_self def.A.signature
+          instantiate_fun_sig ctx call.func.generics tr_self def.A.signature
         in
-        (call.func, call.generics, def, inst_sg)
-    | A.FunId (A.Assumed _) ->
+        (call.func.func, call.func.generics, def, inst_sg)
+    | FunId (Assumed _) ->
         (* Unreachable: must be a transparent function *)
         raise (Failure "Unreachable")
-    | A.TraitMethod (trait_ref, method_name, _) -> (
+    | TraitMethod (trait_ref, method_name, _) -> (
         log#ldebug
           (lazy
             ("trait method call:\n- call: " ^ call_to_string ctx call
            ^ "\n- method name: " ^ method_name ^ "\n- call.generics:\n"
-            ^ egeneric_args_to_string ctx call.generics
+            ^ egeneric_args_to_string ctx call.func.generics
             ^ "\n- trait and method generics:\n"
             ^ egeneric_args_to_string ctx
-                (Option.get call.trait_and_method_generic_args)));
+                (Option.get call.func.trait_and_method_generic_args)));
         (* When instantiating, we need to group the generics for the trait ref
            and the method *)
-        let generics = Option.get call.trait_and_method_generic_args in
+        let generics = Option.get call.func.trait_and_method_generic_args in
         (* Lookup the trait method signature - there are several possibilities
            depending on whethere we call a top-level trait method impl or the
            method from a local clause *)
@@ -1251,7 +1249,7 @@ and eval_transparent_function_call_symbolic (config : C.config) (call : A.call)
                    which implements the method. In order to do this properly,
                    we also need to update the generics.
                 *)
-                let func = A.FunId (A.Regular id) in
+                let func = E.FunId (Regular id) in
                 (func, generics, method_def, inst_sg)
             | None ->
                 (* If not found, lookup the methods provided by the trait *declaration*
@@ -1287,7 +1285,7 @@ and eval_transparent_function_call_symbolic (config : C.config) (call : A.call)
                 *)
                 let all_generics =
                   TypesUtils.merge_generic_args
-                    trait_ref.trait_decl_ref.decl_generics call.generics
+                    trait_ref.trait_decl_ref.decl_generics call.func.generics
                 in
                 log#ldebug
                   (lazy
@@ -1304,7 +1302,7 @@ and eval_transparent_function_call_symbolic (config : C.config) (call : A.call)
                   instantiate_fun_sig ctx all_generics tr_self
                     method_def.A.signature
                 in
-                (call.func, call.generics, method_def, inst_sg))
+                (call.func.func, call.func.generics, method_def, inst_sg))
         | _ ->
             (* We are using a local clause - we lookup the trait decl *)
             let trait_decl =
@@ -1333,7 +1331,7 @@ and eval_transparent_function_call_symbolic (config : C.config) (call : A.call)
             let inst_sg =
               instantiate_fun_sig ctx generics tr_self method_def.A.signature
             in
-            (call.func, call.generics, method_def, inst_sg))
+            (call.func.func, call.func.generics, method_def, inst_sg))
   in
   (* Sanity check *)
   assert (List.length call.args = List.length def.A.signature.inputs);
@@ -1357,6 +1355,18 @@ and eval_function_call_symbolic_from_inst_sig (config : C.config)
     (generics : T.egeneric_args) (args : E.operand list) (dest : E.place) :
     st_cm_fun =
  fun cf ctx ->
+  log#ldebug
+    (lazy
+      ("eval_function_call_symbolic_from_inst_sig:\n- fid: "
+      ^ fun_id_or_trait_method_ref_to_string ctx fid
+      ^ "\n- inst_sg:\n"
+      ^ inst_fun_sig_to_string ctx inst_sg
+      ^ "\n- call.generics:\n"
+      ^ egeneric_args_to_string ctx generics
+      ^ "\n- args:\n"
+      ^ String.concat ", " (List.map (operand_to_string ctx) args)
+      ^ "\n- dest:\n" ^ place_to_string ctx dest));
+
   (* Generate a fresh symbolic value for the return value *)
   let ret_sv_ty = inst_sg.A.output in
   let ret_spc = mk_fresh_symbolic_value V.FunCallRet ret_sv_ty in
@@ -1487,7 +1497,7 @@ and eval_function_call_symbolic_from_inst_sig (config : C.config)
 and eval_assumed_function_call_symbolic (config : C.config)
     (fid : A.assumed_fun_id) (call : A.call) : st_cm_fun =
  fun cf ctx ->
-  let generics = call.generics in
+  let generics = call.func.generics in
   let args = call.args in
   let dest = call.dest in
   (* Sanity check: make sure the type parameters don't contain regions -
@@ -1503,7 +1513,7 @@ and eval_assumed_function_call_symbolic (config : C.config)
        See {!eval_box_free}
   *)
   match fid with
-  | A.BoxFree ->
+  | BoxFree ->
       (* Degenerate case: box_free - note that this is not really a function
        * call: no need to call a "synthesize_..." function *)
       eval_box_free config generics args dest (cf Unit) ctx
@@ -1514,7 +1524,7 @@ and eval_assumed_function_call_symbolic (config : C.config)
        * instantiated signatures, and delegate the work to an auxiliary function *)
       let inst_sig =
         match fid with
-        | A.BoxFree ->
+        | BoxFree ->
             (* should have been treated above *)
             raise (Failure "Unreachable")
         | _ ->
@@ -1525,7 +1535,7 @@ and eval_assumed_function_call_symbolic (config : C.config)
       in
 
       (* Evaluate the function call *)
-      eval_function_call_symbolic_from_inst_sig config (A.FunId (A.Assumed fid))
+      eval_function_call_symbolic_from_inst_sig config (FunId (Assumed fid))
         inst_sig generics args dest cf ctx
 
 (** Evaluate a statement seen as a function body *)
diff --git a/compiler/InterpreterUtils.ml b/compiler/InterpreterUtils.ml
index 7aaee6ff..6e08e553 100644
--- a/compiler/InterpreterUtils.ml
+++ b/compiler/InterpreterUtils.ml
@@ -46,6 +46,11 @@ let operand_to_string = PA.operand_to_string
 let egeneric_args_to_string = PA.egeneric_args_to_string
 let rtrait_instance_id_to_string = PA.rtrait_instance_id_to_string
 let fun_sig_to_string = PA.fun_sig_to_string
+let inst_fun_sig_to_string = PA.inst_fun_sig_to_string
+
+let fun_id_or_trait_method_ref_to_string =
+  PA.fun_id_or_trait_method_ref_to_string
+
 let fun_decl_to_string = PA.fun_decl_to_string
 let call_to_string = PA.call_to_string
 
diff --git a/compiler/Print.ml b/compiler/Print.ml
index 5d5c16ee..1d5ddc50 100644
--- a/compiler/Print.ml
+++ b/compiler/Print.ml
@@ -359,6 +359,18 @@ module Values = struct
     ^ "}" ^ "{regions="
     ^ T.RegionId.Set.to_string None abs.regions
     ^ "}" ^ " {\n" ^ avs ^ "\n" ^ indent ^ "}"
+
+  let inst_fun_sig_to_string (fmt : value_formatter) (sg : LlbcAst.inst_fun_sig)
+      : string =
+    (* TODO: print the trait type constraints? *)
+    let ty_fmt = value_to_rtype_formatter fmt in
+    let ty_to_string = PT.ty_to_string ty_fmt in
+
+    let inputs =
+      "(" ^ String.concat ", " (List.map ty_to_string sg.inputs) ^ ")"
+    in
+    let output = ty_to_string sg.output in
+    inputs ^ " -> " ^ output
 end
 
 module PV = Values (* local module *)
@@ -755,6 +767,17 @@ module EvalCtxLlbcAst = struct
     let fmt = PC.eval_ctx_to_ast_formatter ctx in
     PA.fun_sig_to_string fmt "" "  " x
 
+  let inst_fun_sig_to_string (ctx : C.eval_ctx) (x : LlbcAst.inst_fun_sig) :
+      string =
+    let fmt = PC.eval_ctx_to_ast_formatter ctx in
+    let fmt = PC.ast_to_value_formatter fmt in
+    PV.inst_fun_sig_to_string fmt x
+
+  let fun_id_or_trait_method_ref_to_string (ctx : C.eval_ctx)
+      (x : E.fun_id_or_trait_method_ref) : string =
+    let fmt = PC.eval_ctx_to_ast_formatter ctx in
+    PE.fun_id_or_trait_method_ref_to_string fmt x "..."
+
   let statement_to_string (ctx : C.eval_ctx) (indent : string)
       (indent_incr : string) (e : A.statement) : string =
     let fmt = PC.eval_ctx_to_ast_formatter ctx in
diff --git a/compiler/PrintPure.ml b/compiler/PrintPure.ml
index 5fb5978b..be7b3cb4 100644
--- a/compiler/PrintPure.ml
+++ b/compiler/PrintPure.ml
@@ -593,17 +593,17 @@ let fun_suffix (lp_id : LoopId.id option) (rg_id : T.RegionGroupId.id option) :
 
 let llbc_assumed_fun_id_to_string (fid : A.assumed_fun_id) : string =
   match fid with
-  | A.Replace -> "core::mem::replace"
-  | A.BoxNew -> "alloc::boxed::Box::new"
-  | A.BoxDeref -> "core::ops::deref::Deref::deref"
-  | A.BoxDerefMut -> "core::ops::deref::DerefMut::deref_mut"
-  | A.BoxFree -> "alloc::alloc::box_free"
-  | A.VecNew -> "alloc::vec::Vec::new"
-  | A.VecPush -> "alloc::vec::Vec::push"
-  | A.VecInsert -> "alloc::vec::Vec::insert"
-  | A.VecLen -> "alloc::vec::Vec::len"
-  | A.VecIndex -> "core::ops::index::Index<alloc::vec::Vec>::index"
-  | A.VecIndexMut -> "core::ops::index::IndexMut<alloc::vec::Vec>::index_mut"
+  | Replace -> "core::mem::replace"
+  | BoxNew -> "alloc::boxed::Box::new"
+  | BoxDeref -> "core::ops::deref::Deref::deref"
+  | BoxDerefMut -> "core::ops::deref::DerefMut::deref_mut"
+  | BoxFree -> "alloc::alloc::box_free"
+  | VecNew -> "alloc::vec::Vec::new"
+  | VecPush -> "alloc::vec::Vec::push"
+  | VecInsert -> "alloc::vec::Vec::insert"
+  | VecLen -> "alloc::vec::Vec::len"
+  | VecIndex -> "core::ops::index::Index<alloc::vec::Vec>::index"
+  | VecIndexMut -> "core::ops::index::IndexMut<alloc::vec::Vec>::index_mut"
   | ArrayIndexShared -> "@ArrayIndexShared"
   | ArrayIndexMut -> "@ArrayIndexMut"
   | ArrayToSliceShared -> "@ArrayToSliceShared"
diff --git a/compiler/PureMicroPasses.ml b/compiler/PureMicroPasses.ml
index cedc3559..b00509a6 100644
--- a/compiler/PureMicroPasses.ml
+++ b/compiler/PureMicroPasses.ml
@@ -791,7 +791,7 @@ let expression_contains_child_call_in_all_paths (ctx : trans_ctx)
                     let id0 =
                       match id0 with
                       | FunId fun_id -> fun_id
-                      | TraitMethod (_, _, fun_decl_id) -> A.Regular fun_decl_id
+                      | TraitMethod (_, _, fun_decl_id) -> Regular fun_decl_id
                     in
                     LlbcAstUtils.lookup_fun_sig id0 ctx.fun_ctx.fun_decls
                   in
@@ -1523,29 +1523,29 @@ let eliminate_box_functions (_ctx : trans_ctx) (def : fun_decl) : fun_decl =
         match opt_destruct_function_call e with
         | Some (fun_id, _tys, args) -> (
             match fun_id with
-            | Fun (FromLlbc (FunId (A.Assumed aid), _lp_id, rg_id)) -> (
+            | Fun (FromLlbc (FunId (Assumed aid), _lp_id, rg_id)) -> (
                 (* Below, when dealing with the arguments: we consider the very
                  * general case, where functions could be boxed (meaning we
                  * could have: [box_new f x])
                  * *)
                 match (aid, rg_id) with
-                | A.BoxNew, _ ->
+                | BoxNew, _ ->
                     assert (rg_id = None);
                     let arg, args = Collections.List.pop args in
                     mk_apps arg args
-                | A.BoxDeref, None ->
+                | BoxDeref, None ->
                     (* [Box::deref] forward is the identity *)
                     let arg, args = Collections.List.pop args in
                     mk_apps arg args
-                | A.BoxDeref, Some _ ->
+                | BoxDeref, Some _ ->
                     (* [Box::deref] backward is [()] (doesn't give back anything) *)
                     assert (args = []);
                     mk_unit_rvalue
-                | A.BoxDerefMut, None ->
+                | BoxDerefMut, None ->
                     (* [Box::deref_mut] forward is the identity *)
                     let arg, args = Collections.List.pop args in
                     mk_apps arg args
-                | A.BoxDerefMut, Some _ ->
+                | BoxDerefMut, Some _ ->
                     (* [Box::deref_mut] back is almost the identity:
                      * let box_deref_mut (x_init : t) (x_back : t) : t = x_back
                      * *)
@@ -1555,15 +1555,15 @@ let eliminate_box_functions (_ctx : trans_ctx) (def : fun_decl) : fun_decl =
                       | _ -> raise (Failure "Unreachable")
                     in
                     mk_apps arg args
-                | A.BoxFree, _ ->
+                | BoxFree, _ ->
                     assert (args = []);
                     mk_unit_rvalue
-                | ( ( A.Replace | VecNew | VecPush | VecInsert | VecLen
-                    | VecIndex | VecIndexMut | ArraySubsliceShared
-                    | ArraySubsliceMut | SliceIndexShared | SliceIndexMut
-                    | SliceSubsliceShared | SliceSubsliceMut | ArrayIndexShared
-                    | ArrayIndexMut | ArrayToSliceShared | ArrayToSliceMut
-                    | ArrayRepeat | SliceLen ),
+                | ( ( Replace | VecNew | VecPush | VecInsert | VecLen | VecIndex
+                    | VecIndexMut | ArraySubsliceShared | ArraySubsliceMut
+                    | SliceIndexShared | SliceIndexMut | SliceSubsliceShared
+                    | SliceSubsliceMut | ArrayIndexShared | ArrayIndexMut
+                    | ArrayToSliceShared | ArrayToSliceMut | ArrayRepeat
+                    | SliceLen ),
                     _ ) ->
                     super#visit_texpression env e)
             | _ -> super#visit_texpression env e)
@@ -2046,7 +2046,7 @@ let filter_loop_inputs (transl : pure_fun_translation list) :
     let inputs_set = VarId.Set.of_list (List.map var_get_id inputs_prefix) in
     assert (Option.is_some decl.loop_id);
 
-    let fun_id = (A.Regular decl.def_id, decl.loop_id) in
+    let fun_id = (E.Regular decl.def_id, decl.loop_id) in
 
     let set_used vid =
       used := List.map (fun (vid', b) -> (vid', b || vid = vid')) !used
@@ -2130,7 +2130,7 @@ let filter_loop_inputs (transl : pure_fun_translation list) :
   (* We then apply the filtering to all the function definitions at once *)
   let filter_in_one (decl : fun_decl) : fun_decl =
     (* Filter the function signature *)
-    let fun_id = (A.Regular decl.def_id, decl.loop_id) in
+    let fun_id = (E.Regular decl.def_id, decl.loop_id) in
     let decl =
       match FunLoopIdMap.find_opt fun_id !used_map with
       | None -> (* Nothing to filter *) decl
diff --git a/compiler/SymbolicToPure.ml b/compiler/SymbolicToPure.ml
index 429198ad..54221cb1 100644
--- a/compiler/SymbolicToPure.ml
+++ b/compiler/SymbolicToPure.ml
@@ -343,7 +343,7 @@ let bs_ctx_lookup_llbc_fun_decl (id : A.FunDeclId.id) (ctx : bs_ctx) :
 (* TODO: move *)
 let bs_ctx_lookup_local_function_sig (def_id : A.FunDeclId.id)
     (back_id : T.RegionGroupId.id option) (ctx : bs_ctx) : fun_sig =
-  let id = (A.Regular def_id, back_id) in
+  let id = (E.Regular def_id, back_id) in
   (RegularFunIdNotLoopMap.find id ctx.fun_context.fun_sigs).sg
 
 (* Some generic translation functions (we need to translate different "flavours"
@@ -390,6 +390,7 @@ and translate_trait_instance_id (translate_ty : 'r T.ty -> ty)
       let inst_id = translate_trait_instance_id inst_id in
       ItemClause (inst_id, decl_id, item_name, clause_id)
   | TraitRef tr -> TraitRef (translate_trait_ref translate_ty tr)
+  | FnPointer _ -> raise (Failure "TODO")
   | UnknownTrait s -> raise (Failure ("Unknown trait found: " ^ s))
 
 let rec translate_sty (ty : T.sty) : ty =
@@ -427,6 +428,7 @@ let rec translate_sty (ty : T.sty) : ty =
       let trait_ref = translate_strait_ref trait_ref in
       let generics = translate_sgeneric_args generics in
       TraitType (trait_ref, generics, type_name)
+  | Arrow _ -> raise (Failure "TODO")
 
 and translate_sgeneric_args (generics : T.sgeneric_args) : generic_args =
   translate_generic_args translate_sty generics
@@ -569,6 +571,7 @@ let rec translate_fwd_ty (type_infos : TA.type_infos) (ty : 'r T.ty) : ty =
       let trait_ref = translate_fwd_trait_ref type_infos trait_ref in
       let generics = translate_fwd_generic_args type_infos generics in
       TraitType (trait_ref, generics, type_name)
+  | Arrow _ -> raise (Failure "TODO")
 
 and translate_fwd_generic_args (type_infos : TA.type_infos)
     (generics : 'r T.generic_args) : generic_args =
@@ -658,6 +661,7 @@ let rec translate_back_ty (type_infos : TA.type_infos)
       let trait_ref = translate_fwd_trait_ref type_infos trait_ref in
       let generics = translate_fwd_generic_args type_infos generics in
       Some (TraitType (trait_ref, generics, type_name))
+  | Arrow _ -> raise (Failure "TODO")
 
 (** Simply calls [translate_back_ty] *)
 let ctx_translate_back_ty (ctx : bs_ctx) (keep_region : 'r -> bool)
@@ -694,7 +698,7 @@ let type_check_texpression (ctx : bs_ctx) (e : texpression) : unit =
 let translate_fun_id_or_trait_method_ref (ctx : bs_ctx)
     (id : A.fun_id_or_trait_method_ref) : fun_id_or_trait_method_ref =
   match id with
-  | A.FunId fun_id -> FunId fun_id
+  | FunId fun_id -> FunId fun_id
   | TraitMethod (trait_ref, method_name, fun_decl_id) ->
       let type_infos = ctx.type_context.type_infos in
       let trait_ref = translate_fwd_trait_ref type_infos trait_ref in
@@ -795,7 +799,7 @@ let get_fun_effect_info (fun_infos : FA.fun_info A.FunDeclId.Map.t)
     (fun_id : A.fun_id_or_trait_method_ref) (lid : V.LoopId.id option)
     (gid : T.RegionGroupId.id option) : fun_effect_info =
   match fun_id with
-  | A.TraitMethod (_, _, fid) | A.FunId (A.Regular fid) ->
+  | TraitMethod (_, _, fid) | FunId (Regular fid) ->
       let info = A.FunDeclId.Map.find fid fun_infos in
       let stateful_group = info.stateful in
       let stateful =
@@ -808,7 +812,7 @@ let get_fun_effect_info (fun_infos : FA.fun_info A.FunDeclId.Map.t)
         can_diverge = info.can_diverge;
         is_rec = info.is_rec || Option.is_some lid;
       }
-  | A.FunId (A.Assumed aid) ->
+  | FunId (Assumed aid) ->
       assert (lid = None);
       {
         can_fail = Assumed.assumed_can_fail aid;
@@ -841,7 +845,7 @@ let translate_fun_sig (decls_ctx : C.decls_ctx) (fun_id : A.fun_id)
   in
   (* Is the function stateful, and can it fail? *)
   let lid = None in
-  let effect_info = get_fun_effect_info fun_infos (A.FunId fun_id) lid bid in
+  let effect_info = get_fun_effect_info fun_infos (FunId fun_id) lid bid in
   (* We need an evaluation context to normalize the types (to normalize the
      associated types, etc. - for instance it may happen that the types
      refer to the types associated to a trait ref, but where the trait ref
@@ -1706,18 +1710,20 @@ and translate_function_call (call : S.call) (e : S.expression) (ctx : bs_ctx) :
             in
             (ctx, Unop (Neg int_ty), effect_info, args, None)
         | _ -> raise (Failure "Unreachable"))
-    | S.Unop (E.Cast (src_ty, tgt_ty)) ->
-        (* Note that cast can fail *)
-        let effect_info =
-          {
-            can_fail = true;
-            stateful_group = false;
-            stateful = false;
-            can_diverge = false;
-            is_rec = false;
-          }
-        in
-        (ctx, Unop (Cast (src_ty, tgt_ty)), effect_info, args, None)
+    | S.Unop (E.Cast cast_kind) -> (
+        match cast_kind with
+        | CastInteger (src_ty, tgt_ty) ->
+            (* Note that cast can fail *)
+            let effect_info =
+              {
+                can_fail = true;
+                stateful_group = false;
+                stateful = false;
+                can_diverge = false;
+                is_rec = false;
+              }
+            in
+            (ctx, Unop (Cast (src_ty, tgt_ty)), effect_info, args, None))
     | S.Binop binop -> (
         match args with
         | [ arg0; arg1 ] ->
@@ -1925,7 +1931,7 @@ and translate_end_abstraction_fun_call (ectx : C.eval_ctx) (abs : V.abs)
   (* Sanity check: there is the proper number of inputs and outputs, and they have the proper type *)
   (if (* TODO: normalize the types *) !Config.type_check_pure_code then
      match fun_id with
-     | A.FunId fun_id ->
+     | FunId fun_id ->
          let inst_sg =
            get_instantiated_fun_sig fun_id (Some rg_id) generics ctx
          in
@@ -2088,9 +2094,9 @@ and translate_end_abstraction_loop (ectx : C.eval_ctx) (abs : V.abs)
       (* Actually the same case as [SynthInput] *)
       translate_end_abstraction_synth_input ectx abs e ctx rg_id
   | V.LoopCall ->
-      let fun_id = A.Regular ctx.fun_decl.A.def_id in
+      let fun_id = E.Regular ctx.fun_decl.A.def_id in
       let effect_info =
-        get_fun_effect_info ctx.fun_context.fun_infos (A.FunId fun_id)
+        get_fun_effect_info ctx.fun_context.fun_infos (FunId fun_id)
           (Some vloop_id) (Some rg_id)
       in
       let loop_info = LoopId.Map.find loop_id ctx.loops in
@@ -2553,9 +2559,9 @@ and translate_forward_end (ectx : C.eval_ctx)
       let org_args = args in
 
       (* Lookup the effect info for the loop function *)
-      let fid = A.Regular ctx.fun_decl.A.def_id in
+      let fid = E.Regular ctx.fun_decl.A.def_id in
       let effect_info =
-        get_fun_effect_info ctx.fun_context.fun_infos (A.FunId fid) None ctx.bid
+        get_fun_effect_info ctx.fun_context.fun_infos (FunId fid) None ctx.bid
       in
 
       (* Introduce a fresh output value for the forward function *)
diff --git a/compiler/SynthesizeSymbolic.ml b/compiler/SynthesizeSymbolic.ml
index aeb6899f..9084f2b3 100644
--- a/compiler/SynthesizeSymbolic.ml
+++ b/compiler/SynthesizeSymbolic.ml
@@ -85,7 +85,7 @@ let synthesize_symbolic_expansion (sv : V.symbolic_value)
             match ls with
             | [ (Some see, exp) ] -> ExpandNoBranch (see, exp)
             | _ -> raise (Failure "Ill-formed borrow expansion"))
-        | T.TypeVar _ | T.Literal Char | Never | T.TraitType _ ->
+        | T.TypeVar _ | T.Literal Char | Never | T.TraitType _ | T.Arrow _ ->
             raise (Failure "Ill-formed symbolic expansion")
       in
       Some (Expansion (place, sv, expansion))
diff --git a/compiler/Translate.ml b/compiler/Translate.ml
index e69abee1..8e01c869 100644
--- a/compiler/Translate.ml
+++ b/compiler/Translate.ml
@@ -61,7 +61,7 @@ let translate_function_to_pure (trans_ctx : trans_ctx)
 
   (* Initialize the context *)
   let forward_sig =
-    RegularFunIdNotLoopMap.find (A.Regular def_id, None) fun_sigs
+    RegularFunIdNotLoopMap.find (E.Regular def_id, None) fun_sigs
   in
   let sv_to_var = V.SymbolicValueId.Map.empty in
   let var_counter = Pure.VarId.generator_zero in
@@ -200,7 +200,7 @@ let translate_function_to_pure (trans_ctx : trans_ctx)
         (* Initialize the context - note that the ret_ty is not really
          * useful as we don't translate a body *)
         let backward_sg =
-          RegularFunIdNotLoopMap.find (A.Regular def_id, Some back_id) fun_sigs
+          RegularFunIdNotLoopMap.find (Regular def_id, Some back_id) fun_sigs
         in
         let ctx = { ctx with bid = Some back_id; sg = backward_sg.sg } in
 
@@ -211,7 +211,7 @@ let translate_function_to_pure (trans_ctx : trans_ctx)
            variables required by the backward function.
         *)
         let backward_sg =
-          RegularFunIdNotLoopMap.find (A.Regular def_id, Some back_id) fun_sigs
+          RegularFunIdNotLoopMap.find (Regular def_id, Some back_id) fun_sigs
         in
         (* We need to ignore the forward inputs, and the state input (if there is) *)
         let backward_inputs =
@@ -298,7 +298,7 @@ let translate_crate_to_pure (crate : A.crate) :
   let assumed_sigs =
     List.map
       (fun (id, sg, _, _) ->
-        (A.Assumed id, List.map (fun _ -> None) (sg : A.fun_sig).inputs, sg))
+        (E.Assumed id, List.map (fun _ -> None) (sg : A.fun_sig).inputs, sg))
       Assumed.assumed_infos
   in
   let local_sigs =
@@ -312,7 +312,7 @@ let translate_crate_to_pure (crate : A.crate) :
                 (fun (v : A.var) -> v.name)
                 (LlbcAstUtils.fun_body_get_input_vars body)
         in
-        (A.Regular fdef.def_id, input_names, fdef.signature))
+        (E.Regular fdef.def_id, input_names, fdef.signature))
       (A.FunDeclId.Map.values crate.functions)
   in
   let sigs = List.append assumed_sigs local_sigs in
diff --git a/compiler/TypesAnalysis.ml b/compiler/TypesAnalysis.ml
index 95c7206a..4a187893 100644
--- a/compiler/TypesAnalysis.ml
+++ b/compiler/TypesAnalysis.ml
@@ -232,6 +232,14 @@ let analyze_full_ty (r_is_static : 'r -> bool) (updated : bool ref)
         in
         (* Return *)
         ty_info
+    | Arrow (inputs, output) ->
+        (* Just dive into the arrow *)
+        let ty_info =
+          List.fold_left
+            (fun ty_info ty -> analyze expl_info ty_info ty)
+            ty_info inputs
+        in
+        analyze expl_info ty_info output
   in
   (* Explore *)
   analyze expl_info_init ty_info ty
-- 
cgit v1.3.1


From 838cc86cb2efc8fb64a94a94b58b82d66844e7e4 Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Mon, 23 Oct 2023 13:47:39 +0200
Subject: Remove some assumed types and add more support for builtin
 definitions

---
 compiler/Assumed.ml                | 254 +++++---------------
 compiler/Extract.ml                | 145 ++++++------
 compiler/ExtractAssumed.ml         |  61 -----
 compiler/ExtractBase.ml            |  73 +-----
 compiler/ExtractBuiltin.ml         | 468 +++++++++++++++++++++++++++++++++++++
 compiler/FunsAnalysis.ml           |   2 +-
 compiler/InterpreterExpansion.ml   |  15 +-
 compiler/InterpreterExpressions.ml | 100 +++-----
 compiler/InterpreterPaths.ml       |  31 +--
 compiler/InterpreterPaths.mli      |   4 -
 compiler/InterpreterStatements.ml  | 100 +-------
 compiler/Invariants.ml             |  15 +-
 compiler/LlbcAstUtils.ml           |   8 +-
 compiler/PrePasses.ml              |   2 +-
 compiler/Print.ml                  |  11 -
 compiler/PrintPure.ml              |  57 +----
 compiler/Pure.ml                   |  12 +-
 compiler/PureMicroPasses.ml        |  42 ++--
 compiler/PureTypeCheck.ml          |  13 +-
 compiler/Substitute.ml             |  14 +-
 compiler/SymbolicToPure.ml         |  31 +--
 compiler/Translate.ml              | 107 +++++----
 compiler/TypesAnalysis.ml          |   4 +-
 compiler/dune                      |   2 +-
 24 files changed, 763 insertions(+), 808 deletions(-)
 delete mode 100644 compiler/ExtractAssumed.ml
 create mode 100644 compiler/ExtractBuiltin.ml

(limited to 'compiler/ExtractBase.ml')

diff --git a/compiler/Assumed.ml b/compiler/Assumed.ml
index b1ec0660..94fb7a72 100644
--- a/compiler/Assumed.ml
+++ b/compiler/Assumed.ml
@@ -80,8 +80,6 @@ module Sig = struct
   let mk_slice_ty (ty : T.sty) : T.sty =
     Adt (Assumed Slice, mk_generic_args [] [ ty ] [])
 
-  let range_ty : T.sty = Adt (Assumed Range, mk_generic_args [] [ usize_ty ] [])
-
   let mk_sig generics regions_hierarchy inputs output : A.fun_sig =
     let preds : T.predicates =
       { regions_outlive = []; types_outlive = []; trait_type_constraints = [] }
@@ -95,19 +93,6 @@ module Sig = struct
       output;
     }
 
-  (** [fn<T>(&'a mut T, T) -> T] *)
-  let mem_replace_sig : A.fun_sig =
-    (* The signature fields *)
-    let regions = [ region_param_0 ] (* <'a> *) in
-    let regions_hierarchy = [ region_group_0 ] (* [{<'a>}] *) in
-    let types = [ type_param_0 ] (* <T> *) in
-    let generics = mk_generic_params regions types [] in
-    let inputs =
-      [ mk_ref_ty rvar_0 tvar_0 true (* &'a mut T *); tvar_0 (* T *) ]
-    in
-    let output = tvar_0 (* T *) in
-    mk_sig generics regions_hierarchy inputs output
-
   (** [fn<T>(T) -> Box<T>] *)
   let box_new_sig : A.fun_sig =
     let generics = mk_generic_params [] [ type_param_0 ] [] (* <T> *) in
@@ -124,101 +109,6 @@ module Sig = struct
     let output = mk_unit_ty (* () *) in
     mk_sig generics regions_hierarchy inputs output
 
-  (** Helper for [Box::deref_shared] and [Box::deref_mut].
-      Returns:
-      [fn<'a, T>(&'a (mut) Box<T>) -> &'a (mut) T]
-  *)
-  let box_deref_gen_sig (is_mut : bool) : A.fun_sig =
-    let generics =
-      mk_generic_params [ region_param_0 ] [ type_param_0 ] [] (* <'a, T> *)
-    in
-    let regions_hierarchy = [ region_group_0 ] (* <'a> *) in
-    let inputs =
-      [ mk_ref_ty rvar_0 (mk_box_ty tvar_0) is_mut (* &'a (mut) Box<T> *) ]
-    in
-    let output = mk_ref_ty rvar_0 tvar_0 is_mut (* &'a (mut) T *) in
-    mk_sig generics regions_hierarchy inputs output
-
-  (** [fn<'a, T>(&'a Box<T>) -> &'a T] *)
-  let box_deref_shared_sig = box_deref_gen_sig false
-
-  (** [fn<'a, T>(&'a mut Box<T>) -> &'a mut T] *)
-  let box_deref_mut_sig = box_deref_gen_sig true
-
-  (** [fn<T>() -> Vec<T>] *)
-  let vec_new_sig : A.fun_sig =
-    let generics = mk_generic_params [] [ type_param_0 ] [] (* <T> *) in
-    let regions_hierarchy = [] in
-    let inputs = [] in
-    let output = mk_vec_ty tvar_0 (* Vec<T> *) in
-    mk_sig generics regions_hierarchy inputs output
-
-  (** [fn<T>(&'a mut Vec<T>, T)] *)
-  let vec_push_sig : A.fun_sig =
-    let generics =
-      mk_generic_params [ region_param_0 ] [ type_param_0 ] [] (* <'a, T> *)
-    in
-    let regions_hierarchy = [ region_group_0 ] (* <'a> *) in
-    let inputs =
-      [
-        mk_ref_ty rvar_0 (mk_vec_ty tvar_0) true (* &'a mut Vec<T> *);
-        tvar_0 (* T *);
-      ]
-    in
-    let output = mk_unit_ty (* () *) in
-    mk_sig generics regions_hierarchy inputs output
-
-  (** [fn<T>(&'a mut Vec<T>, usize, T)] *)
-  let vec_insert_sig : A.fun_sig =
-    let generics =
-      mk_generic_params [ region_param_0 ] [ type_param_0 ] [] (* <'a, T> *)
-    in
-    let regions_hierarchy = [ region_group_0 ] (* <'a> *) in
-    let inputs =
-      [
-        mk_ref_ty rvar_0 (mk_vec_ty tvar_0) true (* &'a mut Vec<T> *);
-        mk_usize_ty (* usize *);
-        tvar_0 (* T *);
-      ]
-    in
-    let output = mk_unit_ty (* () *) in
-    mk_sig generics regions_hierarchy inputs output
-
-  (** [fn<T>(&'a Vec<T>) -> usize] *)
-  let vec_len_sig : A.fun_sig =
-    let generics =
-      mk_generic_params [ region_param_0 ] [ type_param_0 ] [] (* <'a, T> *)
-    in
-    let regions_hierarchy = [ region_group_0 ] (* <'a> *) in
-    let inputs =
-      [ mk_ref_ty rvar_0 (mk_vec_ty tvar_0) false (* &'a Vec<T> *) ]
-    in
-    let output = mk_usize_ty (* usize *) in
-    mk_sig generics regions_hierarchy inputs output
-
-  (** Helper:
-      [fn<T>(&'a (mut) Vec<T>, usize) -> &'a (mut) T]
-   *)
-  let vec_index_gen_sig (is_mut : bool) : A.fun_sig =
-    let generics =
-      mk_generic_params [ region_param_0 ] [ type_param_0 ] [] (* <'a, T> *)
-    in
-    let regions_hierarchy = [ region_group_0 ] (* <'a> *) in
-    let inputs =
-      [
-        mk_ref_ty rvar_0 (mk_vec_ty tvar_0) is_mut (* &'a (mut) Vec<T> *);
-        mk_usize_ty (* usize *);
-      ]
-    in
-    let output = mk_ref_ty rvar_0 tvar_0 is_mut (* &'a (mut) T *) in
-    mk_sig generics regions_hierarchy inputs output
-
-  (** [fn<T>(&'a Vec<T>, usize) -> &'a T] *)
-  let vec_index_shared_sig : A.fun_sig = vec_index_gen_sig false
-
-  (** [fn<T>(&'a mut Vec<T>, usize) -> &'a mut T] *)
-  let vec_index_mut_sig : A.fun_sig = vec_index_gen_sig true
-
   (** Array/slice functions *)
 
   (** Small helper.
@@ -281,23 +171,6 @@ module Sig = struct
     let cgs = [ cg_param_0 ] in
     mk_array_slice_borrow_sig cgs input_ty None output_ty is_mut
 
-  let mk_array_slice_subslice_sig (is_array : bool) (is_mut : bool) : A.fun_sig
-      =
-    (* Array<T, N> *)
-    let input_ty id =
-      if is_array then mk_array_ty (T.TypeVar id) cgvar_0
-      else mk_slice_ty (T.TypeVar id)
-    in
-    (* Range *)
-    let index_ty = range_ty in
-    (* Slice<T> *)
-    let output_ty id = mk_slice_ty (T.TypeVar id) in
-    let cgs = if is_array then [ cg_param_0 ] else [] in
-    mk_array_slice_borrow_sig cgs input_ty (Some index_ty) output_ty is_mut
-
-  let array_subslice_sig (is_mut : bool) =
-    mk_array_slice_subslice_sig true is_mut
-
   let array_repeat_sig =
     let generics =
       (* <T, N> *)
@@ -311,9 +184,6 @@ module Sig = struct
     in
     mk_sig generics regions_hierarchy inputs output
 
-  let slice_subslice_sig (is_mut : bool) =
-    mk_array_slice_subslice_sig false is_mut
-
   (** Helper:
       [fn<T>(&'a [T]) -> usize]
    *)
@@ -329,7 +199,25 @@ module Sig = struct
     mk_sig generics regions_hierarchy inputs output
 end
 
-type assumed_info = A.assumed_fun_id * A.fun_sig * bool * name
+type raw_assumed_fun_info =
+  A.assumed_fun_id * A.fun_sig * bool * name * bool list option
+
+type assumed_fun_info = {
+  fun_id : A.assumed_fun_id;
+  fun_sig : A.fun_sig;
+  can_fail : bool;
+  name : name;
+  keep_types : bool list option;
+      (** We may want to filter some type arguments.
+
+          For instance, all the `Vec` functions (and the `Vec` type itself) take
+          an `Allocator` type as argument, that we ignore.
+       *)
+}
+
+let mk_assumed_fun_info (raw : raw_assumed_fun_info) : assumed_fun_info =
+  let fun_id, fun_sig, can_fail, name, keep_types = raw in
+  { fun_id; fun_sig; can_fail; name; keep_types }
 
 (** The list of assumed functions and all their information:
     - their signature
@@ -342,96 +230,72 @@ type assumed_info = A.assumed_fun_id * A.fun_sig * bool * name
     a [usize], we have to make sure that vectors are bounded by the max usize.
     As a consequence, [Vec::push] is monadic.
  *)
-let assumed_infos : assumed_info list =
-  let deref_pre = [ "core"; "ops"; "deref" ] in
-  let vec_pre = [ "alloc"; "vec"; "Vec" ] in
-  let index_pre = [ "core"; "ops"; "index" ] in
+let raw_assumed_fun_infos : raw_assumed_fun_info list =
   [
-    (Replace, Sig.mem_replace_sig, false, to_name [ "core"; "mem"; "replace" ]);
-    (BoxNew, Sig.box_new_sig, false, to_name [ "alloc"; "boxed"; "Box"; "new" ]);
+    ( BoxNew,
+      Sig.box_new_sig,
+      false,
+      to_name [ "alloc"; "boxed"; "Box"; "new" ],
+      Some [ true; false ] );
+    (* BoxFree shouldn't be used *)
     ( BoxFree,
       Sig.box_free_sig,
       false,
-      to_name [ "alloc"; "boxed"; "Box"; "free" ] );
-    ( BoxDeref,
-      Sig.box_deref_shared_sig,
-      false,
-      to_name (deref_pre @ [ "Deref"; "deref" ]) );
-    ( BoxDerefMut,
-      Sig.box_deref_mut_sig,
-      false,
-      to_name (deref_pre @ [ "DerefMut"; "deref_mut" ]) );
-    (VecNew, Sig.vec_new_sig, false, to_name (vec_pre @ [ "new" ]));
-    (VecPush, Sig.vec_push_sig, true, to_name (vec_pre @ [ "push" ]));
-    (VecInsert, Sig.vec_insert_sig, true, to_name (vec_pre @ [ "insert" ]));
-    (VecLen, Sig.vec_len_sig, false, to_name (vec_pre @ [ "len" ]));
-    ( VecIndex,
-      Sig.vec_index_shared_sig,
-      true,
-      to_name (index_pre @ [ "Index"; "index" ]) );
-    ( VecIndexMut,
-      Sig.vec_index_mut_sig,
-      true,
-      to_name (index_pre @ [ "IndexMut"; "index_mut" ]) );
+      to_name [ "alloc"; "boxed"; "Box"; "free" ],
+      Some [ true; false ] );
     (* Array Index *)
     ( ArrayIndexShared,
       Sig.array_index_sig false,
       true,
-      to_name [ "@ArrayIndexShared" ] );
-    (ArrayIndexMut, Sig.array_index_sig true, true, to_name [ "@ArrayIndexMut" ]);
+      to_name [ "@ArrayIndexShared" ],
+      None );
+    ( ArrayIndexMut,
+      Sig.array_index_sig true,
+      true,
+      to_name [ "@ArrayIndexMut" ],
+      None );
     (* Array to slice*)
     ( ArrayToSliceShared,
       Sig.array_to_slice_sig false,
       true,
-      to_name [ "@ArrayToSliceShared" ] );
+      to_name [ "@ArrayToSliceShared" ],
+      None );
     ( ArrayToSliceMut,
       Sig.array_to_slice_sig true,
       true,
-      to_name [ "@ArrayToSliceMut" ] );
-    (* Array Subslice *)
-    ( ArraySubsliceShared,
-      Sig.array_subslice_sig false,
-      true,
-      to_name [ "@ArraySubsliceShared" ] );
-    ( ArraySubsliceMut,
-      Sig.array_subslice_sig true,
-      true,
-      to_name [ "@ArraySubsliceMut" ] );
+      to_name [ "@ArrayToSliceMut" ],
+      None );
     (* Array Repeat *)
-    (ArrayRepeat, Sig.array_repeat_sig, false, to_name [ "@ArrayRepeat" ]);
+    (ArrayRepeat, Sig.array_repeat_sig, false, to_name [ "@ArrayRepeat" ], None);
     (* Slice Index *)
     ( SliceIndexShared,
       Sig.slice_index_sig false,
       true,
-      to_name [ "@SliceIndexShared" ] );
-    (SliceIndexMut, Sig.slice_index_sig true, true, to_name [ "@SliceIndexMut" ]);
-    (* Slice Subslice *)
-    ( SliceSubsliceShared,
-      Sig.slice_subslice_sig false,
+      to_name [ "@SliceIndexShared" ],
+      None );
+    ( SliceIndexMut,
+      Sig.slice_index_sig true,
       true,
-      to_name [ "@SliceSubsliceShared" ] );
-    ( SliceSubsliceMut,
-      Sig.slice_subslice_sig true,
-      true,
-      to_name [ "@SliceSubsliceMut" ] );
-    (SliceLen, Sig.slice_len_sig, false, to_name [ "@SliceLen" ]);
+      to_name [ "@SliceIndexMut" ],
+      None );
+    (SliceLen, Sig.slice_len_sig, false, to_name [ "@SliceLen" ], None);
   ]
 
-let get_assumed_info (id : A.assumed_fun_id) : assumed_info =
-  match List.find_opt (fun (id', _, _, _) -> id = id') assumed_infos with
+let assumed_fun_infos : assumed_fun_info list =
+  List.map mk_assumed_fun_info raw_assumed_fun_infos
+
+let get_assumed_fun_info (id : A.assumed_fun_id) : assumed_fun_info =
+  match List.find_opt (fun x -> id = x.fun_id) assumed_fun_infos with
   | Some info -> info
   | None ->
       raise
-        (Failure ("get_assumed_info: not found: " ^ A.show_assumed_fun_id id))
+        (Failure ("get_assumed_fun_info: not found: " ^ A.show_assumed_fun_id id))
 
-let get_assumed_sig (id : A.assumed_fun_id) : A.fun_sig =
-  let _, sg, _, _ = get_assumed_info id in
-  sg
+let get_assumed_fun_sig (id : A.assumed_fun_id) : A.fun_sig =
+  (get_assumed_fun_info id).fun_sig
 
-let get_assumed_name (id : A.assumed_fun_id) : fun_name =
-  let _, _, _, name = get_assumed_info id in
-  name
+let get_assumed_fun_name (id : A.assumed_fun_id) : fun_name =
+  (get_assumed_fun_info id).name
 
-let assumed_can_fail (id : A.assumed_fun_id) : bool =
-  let _, _, b, _ = get_assumed_info id in
-  b
+let assumed_fun_can_fail (id : A.assumed_fun_id) : bool =
+  (get_assumed_fun_info id).can_fail
diff --git a/compiler/Extract.ml b/compiler/Extract.ml
index 688f6ce3..30c4c27d 100644
--- a/compiler/Extract.ml
+++ b/compiler/Extract.ml
@@ -225,12 +225,9 @@ let assumed_adts () : (assumed_ty * string) list =
         (Result, "Result");
         (Error, "Error");
         (Fuel, "Nat");
-        (Option, "Option");
-        (Vec, "Vec");
         (Array, "Array");
         (Slice, "Slice");
         (Str, "Str");
-        (Range, "Range");
       ]
   | Coq | FStar ->
       [
@@ -238,12 +235,9 @@ let assumed_adts () : (assumed_ty * string) list =
         (Result, "result");
         (Error, "error");
         (Fuel, "nat");
-        (Option, "option");
-        (Vec, "vec");
         (Array, "array");
         (Slice, "slice");
         (Str, "str");
-        (Range, "range");
       ]
   | HOL4 ->
       [
@@ -251,20 +245,17 @@ let assumed_adts () : (assumed_ty * string) list =
         (Result, "result");
         (Error, "error");
         (Fuel, "num");
-        (Option, "option");
-        (Vec, "vec");
         (Array, "array");
         (Slice, "slice");
         (Str, "str");
-        (Range, "range");
       ]
 
 let assumed_struct_constructors () : (assumed_ty * string) list =
   match !backend with
-  | Lean -> [ (Range, "Range.mk"); (Array, "Array.make") ]
-  | Coq -> [ (Range, "mk_range"); (Array, "mk_array") ]
-  | FStar -> [ (Range, "Mkrange"); (Array, "mk_array") ]
-  | HOL4 -> [ (Range, "mk_range"); (Array, "mk_array") ]
+  | Lean -> [ (Array, "Array.make") ]
+  | Coq -> [ (Array, "mk_array") ]
+  | FStar -> [ (Array, "mk_array") ]
+  | HOL4 -> [ (Array, "mk_array") ]
 
 let assumed_variants () : (assumed_ty * VariantId.id * string) list =
   match !backend with
@@ -276,8 +267,6 @@ let assumed_variants () : (assumed_ty * VariantId.id * string) list =
         (Error, error_out_of_fuel_id, "OutOfFuel");
         (* No Fuel::Zero on purpose *)
         (* No Fuel::Succ on purpose *)
-        (Option, option_some_id, "Some");
-        (Option, option_none_id, "None");
       ]
   | Coq ->
       [
@@ -287,8 +276,6 @@ let assumed_variants () : (assumed_ty * VariantId.id * string) list =
         (Error, error_out_of_fuel_id, "OutOfFuel");
         (Fuel, fuel_zero_id, "O");
         (Fuel, fuel_succ_id, "S");
-        (Option, option_some_id, "Some");
-        (Option, option_none_id, "None");
       ]
   | Lean ->
       [
@@ -297,8 +284,6 @@ let assumed_variants () : (assumed_ty * VariantId.id * string) list =
         (Error, error_failure_id, "panic");
         (* No Fuel::Zero on purpose *)
         (* No Fuel::Succ on purpose *)
-        (Option, option_some_id, "some");
-        (Option, option_none_id, "none");
       ]
   | HOL4 ->
       [
@@ -307,8 +292,6 @@ let assumed_variants () : (assumed_ty * VariantId.id * string) list =
         (Error, error_failure_id, "Failure");
         (* No Fuel::Zero on purpose *)
         (* No Fuel::Succ on purpose *)
-        (Option, option_some_id, "SOME");
-        (Option, option_none_id, "NONE");
       ]
 
 let assumed_llbc_functions () :
@@ -317,66 +300,30 @@ let assumed_llbc_functions () :
   match !backend with
   | FStar | Coq | HOL4 ->
       [
-        (Replace, None, "mem_replace_fwd");
-        (Replace, rg0, "mem_replace_back");
-        (VecNew, None, "vec_new");
-        (VecPush, None, "vec_push_fwd") (* Shouldn't be used *);
-        (VecPush, rg0, "vec_push_back");
-        (VecInsert, None, "vec_insert_fwd") (* Shouldn't be used *);
-        (VecInsert, rg0, "vec_insert_back");
-        (VecLen, None, "vec_len");
-        (VecIndex, None, "vec_index_fwd");
-        (VecIndex, rg0, "vec_index_back") (* shouldn't be used *);
-        (VecIndexMut, None, "vec_index_mut_fwd");
-        (VecIndexMut, rg0, "vec_index_mut_back");
         (ArrayIndexShared, None, "array_index_shared");
         (ArrayIndexMut, None, "array_index_mut_fwd");
         (ArrayIndexMut, rg0, "array_index_mut_back");
         (ArrayToSliceShared, None, "array_to_slice_shared");
         (ArrayToSliceMut, None, "array_to_slice_mut_fwd");
         (ArrayToSliceMut, rg0, "array_to_slice_mut_back");
-        (ArraySubsliceShared, None, "array_subslice_shared");
-        (ArraySubsliceMut, None, "array_subslice_mut_fwd");
-        (ArraySubsliceMut, rg0, "array_subslice_mut_back");
         (ArrayRepeat, None, "array_repeat");
         (SliceIndexShared, None, "slice_index_shared");
         (SliceIndexMut, None, "slice_index_mut_fwd");
         (SliceIndexMut, rg0, "slice_index_mut_back");
-        (SliceSubsliceShared, None, "slice_subslice_shared");
-        (SliceSubsliceMut, None, "slice_subslice_mut_fwd");
-        (SliceSubsliceMut, rg0, "slice_subslice_mut_back");
         (SliceLen, None, "slice_len");
       ]
   | Lean ->
       [
-        (Replace, None, "mem.replace");
-        (Replace, rg0, "mem.replace_back");
-        (VecNew, None, "Vec.new");
-        (VecPush, None, "Vec.push_fwd") (* Shouldn't be used *);
-        (VecPush, rg0, "Vec.push");
-        (VecInsert, None, "Vec.insert_fwd") (* Shouldn't be used *);
-        (VecInsert, rg0, "Vec.insert");
-        (VecLen, None, "Vec.len");
-        (VecIndex, None, "Vec.index_shared");
-        (VecIndex, rg0, "Vec.index_shared_back") (* shouldn't be used *);
-        (VecIndexMut, None, "Vec.index_mut");
-        (VecIndexMut, rg0, "Vec.index_mut_back");
         (ArrayIndexShared, None, "Array.index_shared");
         (ArrayIndexMut, None, "Array.index_mut");
         (ArrayIndexMut, rg0, "Array.index_mut_back");
         (ArrayToSliceShared, None, "Array.to_slice_shared");
         (ArrayToSliceMut, None, "Array.to_slice_mut");
         (ArrayToSliceMut, rg0, "Array.to_slice_mut_back");
-        (ArraySubsliceShared, None, "Array.subslice_shared");
-        (ArraySubsliceMut, None, "Array.subslice_mut");
-        (ArraySubsliceMut, rg0, "Array.subslice_mut_back");
         (ArrayRepeat, None, "Array.repeat");
         (SliceIndexShared, None, "Slice.index_shared");
         (SliceIndexMut, None, "Slice.index_mut");
         (SliceIndexMut, rg0, "Slice.index_mut_back");
-        (SliceSubsliceShared, None, "Slice.subslice_shared");
-        (SliceSubsliceMut, None, "Slice.subslice_mut");
-        (SliceSubsliceMut, rg0, "Slice.subslice_mut_back");
         (SliceLen, None, "Slice.len");
       ]
 
@@ -850,12 +797,9 @@ let mk_formatter (ctx : trans_ctx) (crate_name : string)
             | Assumed Result -> "r"
             | Assumed Error -> ConstStrings.error_basename
             | Assumed Fuel -> ConstStrings.fuel_basename
-            | Assumed Option -> "opt"
-            | Assumed Vec -> "v"
             | Assumed Array -> "a"
             | Assumed Slice -> "s"
             | Assumed Str -> "s"
-            | Assumed Range -> "r"
             | Assumed State -> ConstStrings.state_basename
             | AdtId adt_id ->
                 let def = TypeDeclId.Map.find adt_id ctx.type_ctx.type_decls in
@@ -1397,8 +1341,18 @@ and extract_trait_instance_id (ctx : extraction_ctx) (fmt : F.formatter)
  *)
 let extract_type_decl_register_names (ctx : extraction_ctx) (def : type_decl) :
     extraction_ctx =
+  (* Lookup the builtin information, if there is *)
+  let open ExtractBuiltin in
+  let sname = name_to_simple_name def.name in
+  let info = SimpleNameMap.find_opt sname (builtin_types_map ()) in
   (* Compute and register the type def name *)
-  let ctx = ctx_add_type_decl def ctx in
+  let def_name =
+    match info with
+    | None -> ctx.fmt.type_name def.name
+    | Some info -> info.rust_name
+  in
+  let is_opaque = def.kind = Opaque in
+  let ctx = ctx_add is_opaque (TypeId (AdtId def.def_id)) def_name ctx in
   (* Compute and register:
    * - the variant names, if this is an enumeration
    * - the field names, if this is a structure
@@ -1406,18 +1360,73 @@ let extract_type_decl_register_names (ctx : extraction_ctx) (def : type_decl) :
   let ctx =
     match def.kind with
     | Struct fields ->
+        (* Compute the names *)
+        let field_names, cons_name =
+          match info with
+          | None ->
+              let field_names =
+                FieldId.mapi
+                  (fun fid (field : field) ->
+                    (fid, ctx.fmt.field_name def.name fid field.field_name))
+                  fields
+              in
+              let cons_name = ctx.fmt.struct_constructor def.name in
+              (field_names, cons_name)
+          | Some { body_info = Some (Struct (cons_name, field_names)); _ } ->
+              let field_names =
+                FieldId.mapi
+                  (fun fid (_, name) -> (fid, name))
+                  (List.combine fields field_names)
+              in
+              (field_names, cons_name)
+          | _ -> raise (Failure "Invalid builtin information")
+        in
         (* Add the fields *)
         let ctx =
-          fst
-            (ctx_add_fields def (FieldId.mapi (fun id f -> (id, f)) fields) ctx)
+          List.fold_left
+            (fun ctx (fid, name) ->
+              ctx_add is_opaque (FieldId (AdtId def.def_id, fid)) name ctx)
+            ctx field_names
         in
         (* Add the constructor name *)
-        fst (ctx_add_struct def ctx)
+        ctx_add is_opaque (StructId (AdtId def.def_id)) cons_name ctx
     | Enum variants ->
-        fst
-          (ctx_add_variants def
-             (VariantId.mapi (fun id v -> (id, v)) variants)
-             ctx)
+        let variant_names =
+          match info with
+          | None ->
+              VariantId.mapi
+                (fun variant_id (variant : variant) ->
+                  let name =
+                    ctx.fmt.variant_name def.name variant.variant_name
+                  in
+                  (* Add the type name prefix for Lean *)
+                  let name =
+                    if !Config.backend = Lean then
+                      let type_name = ctx.fmt.type_name def.name in
+                      type_name ^ "." ^ name
+                    else name
+                  in
+                  (variant_id, name))
+                variants
+          | Some { body_info = Some (Enum variant_infos); _ } ->
+              (* We need to compute the map from variant to variant *)
+              let variant_map =
+                StringMap.of_list
+                  (List.map
+                     (fun (info : builtin_enum_variant_info) ->
+                       (info.rust_variant_name, info.extract_variant_name))
+                     variant_infos)
+              in
+              VariantId.mapi
+                (fun variant_id (variant : variant) ->
+                  (variant_id, StringMap.find variant.variant_name variant_map))
+                variants
+          | _ -> raise (Failure "Invalid builtin information")
+        in
+        List.fold_left
+          (fun ctx (vid, vname) ->
+            ctx_add is_opaque (VariantId (AdtId def.def_id, vid)) vname ctx)
+          ctx variant_names
     | Opaque ->
         (* Nothing to do *)
         ctx
diff --git a/compiler/ExtractAssumed.ml b/compiler/ExtractAssumed.ml
deleted file mode 100644
index 7f094b24..00000000
--- a/compiler/ExtractAssumed.ml
+++ /dev/null
@@ -1,61 +0,0 @@
-(** This file declares external identifiers that we catch to map them to
-    definitions coming from the standard libraries in our backends. *)
-
-open Names
-
-type simple_name = string list [@@deriving show, ord]
-
-let name_to_simple_name (s : name) : simple_name =
-  (* We simply ignore the disambiguators *)
-  List.filter_map (function Ident id -> Some id | Disambiguator _ -> None) s
-
-(** Small helper which cuts a string at the occurrences of "::" *)
-let string_to_simple_name (s : string) : simple_name =
-  (* No function to split by using string separator?? *)
-  let name = String.split_on_char ':' s in
-  List.filter (fun s -> s <> "") name
-
-module SimpleNameOrd = struct
-  type t = simple_name
-
-  let compare = compare_simple_name
-  let to_string = show_simple_name
-  let pp_t = pp_simple_name
-  let show_t = show_simple_name
-end
-
-module SimpleNameMap = Collections.MakeMap (SimpleNameOrd)
-
-let assumed_globals : (string * string) list =
-  [
-    (* Min *)
-    ("core::num::usize::MIN", "core_usize_min");
-    ("core::num::u8::MIN", "core_u8_min");
-    ("core::num::u16::MIN", "core_u16_min");
-    ("core::num::u32::MIN", "core_u32_min");
-    ("core::num::u64::MIN", "core_u64_min");
-    ("core::num::u128::MIN", "core_u128_min");
-    ("core::num::isize::MIN", "core_isize_min");
-    ("core::num::i8::MIN", "core_i8_min");
-    ("core::num::i16::MIN", "core_i16_min");
-    ("core::num::i32::MIN", "core_i32_min");
-    ("core::num::i64::MIN", "core_i64_min");
-    ("core::num::i128::MIN", "core_i128_min");
-    (* Max *)
-    ("core::num::usize::MAX", "core_usize_max");
-    ("core::num::u8::MAX", "core_u8_max");
-    ("core::num::u16::MAX", "core_u16_max");
-    ("core::num::u32::MAX", "core_u32_max");
-    ("core::num::u64::MAX", "core_u64_max");
-    ("core::num::u128::MAX", "core_u128_max");
-    ("core::num::isize::MAX", "core_isize_max");
-    ("core::num::i8::MAX", "core_i8_max");
-    ("core::num::i16::MAX", "core_i16_max");
-    ("core::num::i32::MAX", "core_i32_max");
-    ("core::num::i64::MAX", "core_i64_max");
-    ("core::num::i128::MAX", "core_i128_max");
-  ]
-
-let assumed_globals_map : string SimpleNameMap.t =
-  SimpleNameMap.of_list
-    (List.map (fun (x, y) -> (string_to_simple_name x, y)) assumed_globals)
diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index a921515b..54f69735 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -5,7 +5,7 @@ open TranslateCore
 module C = Contexts
 module RegionVarId = T.RegionVarId
 module F = Format
-open ExtractAssumed
+open ExtractBuiltin
 
 (** The local logger *)
 let log = L.pure_to_extract_log
@@ -803,15 +803,11 @@ let id_to_string (id : id) (ctx : extraction_ctx) : string =
             if variant_id = error_failure_id then "@error::Failure"
             else if variant_id = error_out_of_fuel_id then "@error::OutOfFuel"
             else raise (Failure "Unreachable")
-        | Assumed Option ->
-            if variant_id = option_some_id then "@option::Some"
-            else if variant_id = option_none_id then "@option::None"
-            else raise (Failure "Unreachable")
         | Assumed Fuel ->
             if variant_id = fuel_zero_id then "@fuel::0"
             else if variant_id = fuel_succ_id then "@fuel::Succ"
             else raise (Failure "Unreachable")
-        | Assumed (State | Vec | Array | Slice | Str | Range) ->
+        | Assumed (State | Array | Slice | Str) ->
             raise
               (Failure
                  ("Unreachable: variant id ("
@@ -830,9 +826,7 @@ let id_to_string (id : id) (ctx : extraction_ctx) : string =
       let field_name =
         match id with
         | Tuple -> raise (Failure "Unreachable")
-        | Assumed
-            ( State | Result | Error | Fuel | Option | Vec | Array | Slice | Str
-            | Range ) ->
+        | Assumed (State | Result | Error | Fuel | Array | Slice | Str) ->
             (* We can't directly have access to the fields of those types *)
             raise (Failure "Unreachable")
         | AdtId id -> (
@@ -1186,65 +1180,6 @@ let ctx_add_generic_params (generics : generic_params) (ctx : extraction_ctx) :
   let ctx, tcs = ctx_add_local_trait_clauses trait_clauses ctx in
   (ctx, tys, cgs, tcs)
 
-let ctx_add_type_decl_struct (def : type_decl) (ctx : extraction_ctx) :
-    extraction_ctx * string =
-  assert (match def.kind with Struct _ -> true | _ -> false);
-  let is_opaque = false in
-  let cons_name = ctx.fmt.struct_constructor def.name in
-  let ctx = ctx_add is_opaque (StructId (AdtId def.def_id)) cons_name ctx in
-  (ctx, cons_name)
-
-let ctx_add_type_decl (def : type_decl) (ctx : extraction_ctx) : extraction_ctx
-    =
-  let is_opaque = def.kind = Opaque in
-  let def_name = ctx.fmt.type_name def.name in
-  let ctx = ctx_add is_opaque (TypeId (AdtId def.def_id)) def_name ctx in
-  ctx
-
-let ctx_add_field (def : type_decl) (field_id : FieldId.id) (field : field)
-    (ctx : extraction_ctx) : extraction_ctx * string =
-  let is_opaque = false in
-  let name = ctx.fmt.field_name def.name field_id field.field_name in
-  let ctx = ctx_add is_opaque (FieldId (AdtId def.def_id, field_id)) name ctx in
-  (ctx, name)
-
-let ctx_add_fields (def : type_decl) (fields : (FieldId.id * field) list)
-    (ctx : extraction_ctx) : extraction_ctx * string list =
-  List.fold_left_map
-    (fun ctx (vid, v) -> ctx_add_field def vid v ctx)
-    ctx fields
-
-let ctx_add_variant (def : type_decl) (variant_id : VariantId.id)
-    (variant : variant) (ctx : extraction_ctx) : extraction_ctx * string =
-  let is_opaque = false in
-  let name = ctx.fmt.variant_name def.name variant.variant_name in
-  (* Add the type name prefix for Lean *)
-  let name =
-    if !Config.backend = Lean then
-      let type_name = ctx.fmt.type_name def.name in
-      type_name ^ "." ^ name
-    else name
-  in
-  let ctx =
-    ctx_add is_opaque (VariantId (AdtId def.def_id, variant_id)) name ctx
-  in
-  (ctx, name)
-
-let ctx_add_variants (def : type_decl)
-    (variants : (VariantId.id * variant) list) (ctx : extraction_ctx) :
-    extraction_ctx * string list =
-  List.fold_left_map
-    (fun ctx (vid, v) -> ctx_add_variant def vid v ctx)
-    ctx variants
-
-let ctx_add_struct (def : type_decl) (ctx : extraction_ctx) :
-    extraction_ctx * string =
-  assert (match def.kind with Struct _ -> true | _ -> false);
-  let is_opaque = false in
-  let name = ctx.fmt.struct_constructor def.name in
-  let ctx = ctx_add is_opaque (StructId (AdtId def.def_id)) name ctx in
-  (ctx, name)
-
 let ctx_add_decreases_proof (def : fun_decl) (ctx : extraction_ctx) :
     extraction_ctx =
   let is_opaque = false in
@@ -1277,7 +1212,7 @@ let ctx_add_global_decl_and_body (def : A.global_decl) (ctx : extraction_ctx) :
      to a custom definition in our standard library (for instance, happens
      with "core::num::usize::MAX") *)
   let sname = name_to_simple_name def.name in
-  match SimpleNameMap.find_opt sname assumed_globals_map with
+  match SimpleNameMap.find_opt sname builtin_globals_map with
   | Some name ->
       (* Yes: register the custom binding *)
       ctx_add is_opaque decl name ctx
diff --git a/compiler/ExtractBuiltin.ml b/compiler/ExtractBuiltin.ml
new file mode 100644
index 00000000..cf5cc70d
--- /dev/null
+++ b/compiler/ExtractBuiltin.ml
@@ -0,0 +1,468 @@
+(** This file declares external identifiers that we catch to map them to
+    definitions coming from the standard libraries in our backends. *)
+
+open Names
+open Config
+
+type simple_name = string list [@@deriving show, ord]
+
+let name_to_simple_name (s : name) : simple_name =
+  (* We simply ignore the disambiguators *)
+  List.filter_map (function Ident id -> Some id | Disambiguator _ -> None) s
+
+(** Small helper which cuts a string at the occurrences of "::" *)
+let string_to_simple_name (s : string) : simple_name =
+  (* No function to split by using string separator?? *)
+  let name = String.split_on_char ':' s in
+  List.filter (fun s -> s <> "") name
+
+module SimpleNameOrd = struct
+  type t = simple_name
+
+  let compare = compare_simple_name
+  let to_string = show_simple_name
+  let pp_t = pp_simple_name
+  let show_t = show_simple_name
+end
+
+module SimpleNameMap = Collections.MakeMap (SimpleNameOrd)
+
+(** Small utility to memoize some computations *)
+let mk_memoized (f : unit -> 'a) : unit -> 'a =
+  let r = ref None in
+  let g () =
+    match !r with
+    | Some x -> x
+    | None ->
+        let x = f () in
+        r := Some x;
+        x
+  in
+  g
+
+let builtin_globals : (string * string) list =
+  [
+    (* Min *)
+    ("core::num::usize::MIN", "core_usize_min");
+    ("core::num::u8::MIN", "core_u8_min");
+    ("core::num::u16::MIN", "core_u16_min");
+    ("core::num::u32::MIN", "core_u32_min");
+    ("core::num::u64::MIN", "core_u64_min");
+    ("core::num::u128::MIN", "core_u128_min");
+    ("core::num::isize::MIN", "core_isize_min");
+    ("core::num::i8::MIN", "core_i8_min");
+    ("core::num::i16::MIN", "core_i16_min");
+    ("core::num::i32::MIN", "core_i32_min");
+    ("core::num::i64::MIN", "core_i64_min");
+    ("core::num::i128::MIN", "core_i128_min");
+    (* Max *)
+    ("core::num::usize::MAX", "core_usize_max");
+    ("core::num::u8::MAX", "core_u8_max");
+    ("core::num::u16::MAX", "core_u16_max");
+    ("core::num::u32::MAX", "core_u32_max");
+    ("core::num::u64::MAX", "core_u64_max");
+    ("core::num::u128::MAX", "core_u128_max");
+    ("core::num::isize::MAX", "core_isize_max");
+    ("core::num::i8::MAX", "core_i8_max");
+    ("core::num::i16::MAX", "core_i16_max");
+    ("core::num::i32::MAX", "core_i32_max");
+    ("core::num::i64::MAX", "core_i64_max");
+    ("core::num::i128::MAX", "core_i128_max");
+  ]
+
+let builtin_globals_map : string SimpleNameMap.t =
+  SimpleNameMap.of_list
+    (List.map (fun (x, y) -> (string_to_simple_name x, y)) builtin_globals)
+
+type builtin_variant_info = { fields : (string * string) list }
+
+type builtin_enum_variant_info = {
+  rust_variant_name : string;
+  extract_variant_name : string;
+  fields : string list option;
+}
+
+type builtin_type_body_info =
+  | Struct of string * string list
+    (* The constructor name and the map for the field names *)
+  | Enum of builtin_enum_variant_info list
+(* For every variant, a map for the field names *)
+
+type builtin_type_info = {
+  rust_name : string;
+  extract_name : string;
+  keep_params : bool list option;
+      (** We might want to filter some of the type parameters.
+
+          For instance, `Vec` type takes a type parameter for the allocator,
+          which we want to ignore.
+       *)
+  body_info : builtin_type_body_info option;
+}
+
+(** The assumed types.
+
+    The optional list of booleans is filtering information for the type
+    parameters. For instance, in the case of the `Vec` functions, there is
+    a type parameter for the allocator to use, which we want to filter.
+ *)
+let builtin_types () : builtin_type_info list =
+  [
+    (* Alloc *)
+    {
+      rust_name = "alloc::alloc::Global";
+      extract_name =
+        (match !backend with
+        | Lean -> "AllocGlobal"
+        | Coq | FStar | HOL4 -> "alloc_global");
+      keep_params = None;
+      body_info = None;
+    };
+    (* Vec *)
+    {
+      rust_name = "alloc::vec::Vec";
+      extract_name =
+        (match !backend with Lean -> "Vec" | Coq | FStar | HOL4 -> "vec");
+      keep_params = Some [ true; false ];
+      body_info = None;
+    };
+    (* Option *)
+    {
+      rust_name = "core::option::Option";
+      extract_name =
+        (match !backend with
+        | Lean -> "Option"
+        | Coq | FStar | HOL4 -> "option");
+      keep_params = None;
+      body_info =
+        Some
+          (Enum
+             [
+               {
+                 rust_variant_name = "None";
+                 extract_variant_name =
+                   (match !backend with
+                   | FStar | Coq -> "None"
+                   | Lean -> "none"
+                   | HOL4 -> "NONE");
+                 fields = None;
+               };
+               {
+                 rust_variant_name = "Some";
+                 extract_variant_name =
+                   (match !backend with
+                   | FStar | Coq -> "Some"
+                   | Lean -> "some"
+                   | HOL4 -> "SOME");
+                 fields = None;
+               };
+             ]);
+    };
+    (* Range *)
+    {
+      rust_name = "core::ops::range::Range";
+      extract_name =
+        (match !backend with Lean -> "Range" | Coq | FStar | HOL4 -> "range");
+      keep_params = None;
+      body_info =
+        Some
+          (Struct
+             ( (match !backend with
+               | Lean -> "Range.mk"
+               | Coq | HOL4 -> "mk_range"
+               | FStar -> "Mkrange"),
+               [ "start"; "end_" ] ));
+    };
+  ]
+
+let mk_builtin_types_map () =
+  SimpleNameMap.of_list
+    (List.map
+       (fun info -> (string_to_simple_name info.rust_name, info))
+       (builtin_types ()))
+
+let builtin_types_map = mk_memoized mk_builtin_types_map
+
+type builtin_fun_info = {
+  rg : Types.RegionGroupId.id option;
+  extract_name : string;
+}
+
+(** The assumed functions.
+
+    The optional list of booleans is filtering information for the type
+    parameters. For instance, in the case of the `Vec` functions, there is
+    a type parameter for the allocator to use, which we want to filter.
+ *)
+let builtin_funs () : (string * bool list option * builtin_fun_info list) list =
+  let rg0 = Some Types.RegionGroupId.zero in
+  [
+    ( "core::mem::replace",
+      None,
+      [
+        {
+          rg = None;
+          extract_name =
+            (match !backend with
+            | FStar | Coq | HOL4 -> "mem_replace_fwd"
+            | Lean -> "mem.replace");
+        };
+        {
+          rg = rg0;
+          extract_name =
+            (match !backend with
+            | FStar | Coq | HOL4 -> "mem_replace_back"
+            | Lean -> "mem.replace_back");
+        };
+      ] );
+    ( "alloc::vec::Vec::new",
+      Some [ true; false ],
+      [
+        {
+          rg = None;
+          extract_name =
+            (match !backend with
+            | FStar | Coq | HOL4 -> "vec_new"
+            | Lean -> "Vec.new");
+        };
+        {
+          rg = rg0;
+          extract_name =
+            (match !backend with
+            | FStar | Coq | HOL4 -> "vec_new_back"
+            | Lean -> "Vec.new_back");
+        };
+      ] );
+    ( "alloc::vec::Vec::push",
+      Some [ true; false ],
+      [
+        (* The forward function shouldn't be used *)
+        {
+          rg = None;
+          extract_name =
+            (match !backend with
+            | FStar | Coq | HOL4 -> "vec_push_fwd"
+            | Lean -> "Vec.push_fwd");
+        };
+        {
+          rg = rg0;
+          extract_name =
+            (match !backend with
+            | FStar | Coq | HOL4 -> "vec_push_back"
+            | Lean -> "Vec.push");
+        };
+      ] );
+    ( "alloc::vec::Vec::insert",
+      Some [ true; false ],
+      [
+        (* The forward function shouldn't be used *)
+        {
+          rg = None;
+          extract_name =
+            (match !backend with
+            | FStar | Coq | HOL4 -> "vec_insert_fwd"
+            | Lean -> "Vec.insert_fwd");
+        };
+        {
+          rg = rg0;
+          extract_name =
+            (match !backend with
+            | FStar | Coq | HOL4 -> "vec_insert_back"
+            | Lean -> "Vec.insert");
+        };
+      ] );
+    ( "alloc::vec::Vec::len",
+      Some [ true; false ],
+      [
+        {
+          rg = None;
+          extract_name =
+            (match !backend with
+            | FStar | Coq | HOL4 -> "vec_len"
+            | Lean -> "Vec.len");
+        };
+      ] );
+    ( "alloc::vec::Vec::index",
+      Some [ true; false ],
+      [
+        {
+          rg = None;
+          extract_name =
+            (match !backend with
+            | FStar | Coq | HOL4 -> "vec_index_fwd"
+            | Lean -> "Vec.index_shared");
+        };
+        (* The backward function shouldn't be used *)
+        {
+          rg = rg0;
+          extract_name =
+            (match !backend with
+            | FStar | Coq | HOL4 -> "vec_index_back"
+            | Lean -> "Vec.index_shared_back");
+        };
+      ] );
+    ( "alloc::vec::Vec::index_mut",
+      Some [ true; false ],
+      [
+        {
+          rg = None;
+          extract_name =
+            (match !backend with
+            | FStar | Coq | HOL4 -> "vec_index_mut_fwd"
+            | Lean -> "Vec.index_mut");
+        };
+        (* The backward function shouldn't be used *)
+        {
+          rg = rg0;
+          extract_name =
+            (match !backend with
+            | FStar | Coq | HOL4 -> "vec_index_mut_back"
+            | Lean -> "Vec.index_mut_back");
+        };
+      ] );
+  ]
+
+let mk_builtin_funs_map () =
+  SimpleNameMap.of_list
+    (List.map
+       (fun (name, filter, info) ->
+         (string_to_simple_name name, (filter, info)))
+       (builtin_funs ()))
+
+let builtin_funs_map () = mk_memoized mk_builtin_funs_map
+
+type builtin_trait_info = {
+  rust_name : string;
+  extract_name : string;
+  parent_clauses : string list;
+  consts : (string * string) list;
+  types : (string * string * string list) list;
+      (** Every type has:
+          - a Rust name
+          - an extraction name
+          - a list of clauses *)
+  funs : (string * Types.RegionGroupId.id option * string) list;
+}
+
+let builtin_traits () =
+  let rg0 = Some Types.RegionGroupId.zero in
+  [
+    {
+      (* Deref *)
+      rust_name = "core::ops::deref::Deref";
+      extract_name =
+        (match !backend with
+        | Coq | FStar | HOL4 -> "core_ops_deref_Deref"
+        | Lean -> "core.ops.deref.Deref");
+      parent_clauses = [];
+      consts = [];
+      types =
+        [
+          ( "Target",
+            (match !backend with
+            | Coq | FStar | HOL4 -> "core_ops_deref_Deref_Target"
+            | Lean -> "Target"),
+            [] );
+        ];
+      funs =
+        [
+          ( "deref",
+            None,
+            match !backend with
+            | Coq | FStar | HOL4 -> "core_ops_deref_Deref_deref"
+            | Lean -> "deref" );
+        ];
+    };
+    {
+      (* DerefMut *)
+      rust_name = "core::ops::deref::DerefMut";
+      extract_name =
+        (match !backend with
+        | Coq | FStar | HOL4 -> "core_ops_deref_DerefMut"
+        | Lean -> "core.ops.deref.DerefMut");
+      parent_clauses =
+        [
+          (match !backend with
+          | Coq | FStar | HOL4 -> "deref_inst"
+          | Lean -> "DerefInst");
+        ];
+      consts = [];
+      types = [];
+      funs =
+        [
+          ( "deref_mut",
+            None,
+            match !backend with
+            | Coq | FStar | HOL4 -> "core_ops_deref_DerefMut_deref_mut"
+            | Lean -> "deref_mut" );
+          ( "deref_mut",
+            rg0,
+            match !backend with
+            | Coq | FStar | HOL4 -> "core_ops_deref_DerefMut_deref_mut_back"
+            | Lean -> "deref_mut_back" );
+        ];
+    };
+    {
+      (* Index *)
+      rust_name = "core::ops::index::Index";
+      extract_name =
+        (match !backend with
+        | Coq | FStar | HOL4 -> "core_ops_index_Index"
+        | Lean -> "core.ops.index.Index");
+      parent_clauses = [];
+      consts = [];
+      types =
+        [
+          ( "Output",
+            (match !backend with
+            | Coq | FStar | HOL4 -> "core_ops_index_Index_Output"
+            | Lean -> "Output"),
+            [] );
+        ];
+      funs =
+        [
+          ( "index",
+            None,
+            match !backend with
+            | Coq | FStar | HOL4 -> "core_ops_index_Index_index"
+            | Lean -> "index" );
+        ];
+    };
+    {
+      (* IndexMut *)
+      rust_name = "core::ops::index::IndexMut";
+      extract_name =
+        (match !backend with
+        | Coq | FStar | HOL4 -> "core_ops_index_IndexMut"
+        | Lean -> "core.ops.index.IndexMut");
+      parent_clauses =
+        [
+          (match !backend with
+          | Coq | FStar | HOL4 -> "index_inst"
+          | Lean -> "IndexInst");
+        ];
+      consts = [];
+      types = [];
+      funs =
+        [
+          ( "index_mut",
+            None,
+            match !backend with
+            | Coq | FStar | HOL4 -> "core_ops_index_IndexMut_mut"
+            | Lean -> "index_mut" );
+          ( "index_mut",
+            rg0,
+            match !backend with
+            | Coq | FStar | HOL4 -> "core_ops_index_IndexMut_mut_back"
+            | Lean -> "index_mut_back" );
+        ];
+    };
+  ]
+
+let mk_builtin_traits_map () =
+  SimpleNameMap.of_list
+    (List.map
+       (fun info -> (string_to_simple_name info.rust_name, info))
+       (builtin_traits ()))
+
+let builtin_traits_map () = mk_memoized mk_builtin_traits_map
diff --git a/compiler/FunsAnalysis.ml b/compiler/FunsAnalysis.ml
index a09a6d05..5e849ba7 100644
--- a/compiler/FunsAnalysis.ml
+++ b/compiler/FunsAnalysis.ml
@@ -88,7 +88,7 @@ let analyze_module (m : crate) (funs_map : fun_decl FunDeclId.Map.t)
                   can_diverge := !can_diverge || info.can_diverge
             | FunId (Assumed id) ->
                 (* None of the assumed functions can diverge nor are considered stateful *)
-                can_fail := !can_fail || Assumed.assumed_can_fail id
+                can_fail := !can_fail || Assumed.assumed_fun_can_fail id
             | TraitMethod _ ->
                 (* We consider trait functions can fail, diverge, and are not stateful *)
                 can_fail := true;
diff --git a/compiler/InterpreterExpansion.ml b/compiler/InterpreterExpansion.ml
index c1041fa3..167e3d58 100644
--- a/compiler/InterpreterExpansion.ml
+++ b/compiler/InterpreterExpansion.ml
@@ -241,17 +241,6 @@ let compute_expanded_symbolic_non_assumed_adt_value (expand_enumerations : bool)
   (* Initialize all the expanded values of all the variants *)
   List.map initialize variants_fields_types
 
-(** Compute the expansion of an Option value.
- *)
-let compute_expanded_symbolic_option_value (expand_enumerations : bool)
-    (kind : V.sv_kind) (ty : T.rty) : V.symbolic_expansion list =
-  assert expand_enumerations;
-  let some_se =
-    V.SeAdt (Some T.option_some_id, [ mk_fresh_symbolic_value kind ty ])
-  in
-  let none_se = V.SeAdt (Some T.option_none_id, []) in
-  [ none_se; some_se ]
-
 let compute_expanded_symbolic_tuple_value (kind : V.sv_kind)
     (field_types : T.rty list) : V.symbolic_expansion =
   (* Generate the field values *)
@@ -286,8 +275,6 @@ let compute_expanded_symbolic_adt_value (expand_enumerations : bool)
         def_id generics ctx
   | T.Tuple, [], _ ->
       [ compute_expanded_symbolic_tuple_value kind generics.types ]
-  | T.Assumed T.Option, [], [ ty ] ->
-      compute_expanded_symbolic_option_value expand_enumerations kind ty
   | T.Assumed T.Box, [], [ boxed_ty ] ->
       [ compute_expanded_symbolic_box_value kind boxed_ty ]
   | _ ->
@@ -704,7 +691,7 @@ let greedy_expand_symbolics_with_borrows (config : C.config) : cm_fun =
         | T.Adt ((Tuple | Assumed Box), _) | T.Ref (_, _, _) ->
             (* Ok *)
             expand_symbolic_value_no_branching config sv None
-        | T.Adt (Assumed (Vec | Option | Array | Slice | Str | Range), _) ->
+        | T.Adt (Assumed (Array | Slice | Str), _) ->
             (* We can't expand those *)
             raise
               (Failure
diff --git a/compiler/InterpreterExpressions.ml b/compiler/InterpreterExpressions.ml
index a42c552a..341e97eb 100644
--- a/compiler/InterpreterExpressions.ml
+++ b/compiler/InterpreterExpressions.ml
@@ -142,10 +142,10 @@ let rec copy_value (allow_adt_copy : bool) (config : C.config)
   | V.Adt av ->
       (* Sanity check *)
       (match v.V.ty with
-      | T.Adt (T.Assumed (T.Box | Vec), _) ->
+      | T.Adt (T.Assumed T.Box, _) ->
           raise (Failure "Can't copy an assumed value other than Option")
       | T.Adt (T.AdtId _, _) -> assert allow_adt_copy
-      | T.Adt ((T.Assumed Option | T.Tuple), _) -> () (* Ok *)
+      | T.Adt (T.Tuple, _) -> () (* Ok *)
       | T.Adt
           ( T.Assumed (Slice | T.Array),
             {
@@ -722,70 +722,38 @@ let eval_rvalue_aggregate (config : C.config)
    fun ctx ->
     (* Match on the aggregate kind *)
     match aggregate_kind with
-    | E.AggregatedTuple ->
-        let tys = List.map (fun (v : V.typed_value) -> v.V.ty) values in
-        let v = V.Adt { variant_id = None; field_values = values } in
-        let generics = TypesUtils.mk_generic_args [] tys [] [] in
-        let ty = T.Adt (T.Tuple, generics) in
-        let aggregated : V.typed_value = { V.value = v; ty } in
-        (* Call the continuation *)
-        cf aggregated ctx
-    | E.AggregatedOption (variant_id, ty) ->
-        (* Sanity check *)
-        if variant_id = T.option_none_id then assert (values = [])
-        else if variant_id = T.option_some_id then
-          assert (List.length values = 1)
-        else raise (Failure "Unreachable");
-        (* Construt the value *)
-        let generics = TypesUtils.mk_generic_args [] [ ty ] [] [] in
-        let aty = T.Adt (T.Assumed T.Option, generics) in
-        let av : V.adt_value =
-          { V.variant_id = Some variant_id; V.field_values = values }
-        in
-        let aggregated : V.typed_value = { V.value = Adt av; ty = aty } in
-        (* Call the continuation *)
-        cf aggregated ctx
-    | E.AggregatedAdt (def_id, opt_variant_id, generics) ->
-        (* Sanity checks *)
-        let type_decl = C.ctx_lookup_type_decl ctx def_id in
-        assert (
-          List.length type_decl.generics.regions = List.length generics.regions);
-        let expected_field_types =
-          Assoc.ctx_adt_get_inst_norm_field_etypes ctx def_id opt_variant_id
-            generics
-        in
-        assert (
-          expected_field_types
-          = List.map (fun (v : V.typed_value) -> v.V.ty) values);
-        (* Construct the value *)
-        let av : V.adt_value =
-          { V.variant_id = opt_variant_id; V.field_values = values }
-        in
-        let aty = T.Adt (T.AdtId def_id, generics) in
-        let aggregated : V.typed_value = { V.value = Adt av; ty = aty } in
-        (* Call the continuation *)
-        cf aggregated ctx
-    | E.AggregatedRange ety ->
-        (* There should be two fields exactly *)
-        let v0, v1 =
-          match values with
-          | [ v0; v1 ] -> (v0, v1)
-          | _ -> raise (Failure "Unreachable")
-        in
-        (* Ranges are parametric over the type of indices. For now we only
-           support scalars, which can be of any type *)
-        assert (literal_type_is_integer (ty_as_literal ety));
-        assert (v0.ty = ety);
-        assert (v1.ty = ety);
-        (* Construct the value *)
-        let av : V.adt_value =
-          { V.variant_id = None; V.field_values = values }
-        in
-        let generics = TypesUtils.mk_generic_args_from_types [ ety ] in
-        let aty = T.Adt (T.Assumed T.Range, generics) in
-        let aggregated : V.typed_value = { V.value = Adt av; ty = aty } in
-        (* Call the continuation *)
-        cf aggregated ctx
+    | E.AggregatedAdt (type_id, opt_variant_id, generics) -> (
+        match type_id with
+        | Tuple ->
+            let tys = List.map (fun (v : V.typed_value) -> v.V.ty) values in
+            let v = V.Adt { variant_id = None; field_values = values } in
+            let generics = TypesUtils.mk_generic_args [] tys [] [] in
+            let ty = T.Adt (T.Tuple, generics) in
+            let aggregated : V.typed_value = { V.value = v; ty } in
+            (* Call the continuation *)
+            cf aggregated ctx
+        | AdtId def_id ->
+            (* Sanity checks *)
+            let type_decl = C.ctx_lookup_type_decl ctx def_id in
+            assert (
+              List.length type_decl.generics.regions
+              = List.length generics.regions);
+            let expected_field_types =
+              Assoc.ctx_adt_get_inst_norm_field_etypes ctx def_id opt_variant_id
+                generics
+            in
+            assert (
+              expected_field_types
+              = List.map (fun (v : V.typed_value) -> v.V.ty) values);
+            (* Construct the value *)
+            let av : V.adt_value =
+              { V.variant_id = opt_variant_id; V.field_values = values }
+            in
+            let aty = T.Adt (T.AdtId def_id, generics) in
+            let aggregated : V.typed_value = { V.value = Adt av; ty = aty } in
+            (* Call the continuation *)
+            cf aggregated ctx
+        | Assumed _ -> raise (Failure "Unreachable"))
     | E.AggregatedArray (ety, cg) -> (
         (* Sanity check: all the values have the proper type *)
         assert (List.for_all (fun (v : V.typed_value) -> v.V.ty = ety) values);
diff --git a/compiler/InterpreterPaths.ml b/compiler/InterpreterPaths.ml
index 465d0028..2a277c91 100644
--- a/compiler/InterpreterPaths.ml
+++ b/compiler/InterpreterPaths.ml
@@ -96,7 +96,7 @@ let rec access_projection (access : projection_access) (ctx : C.eval_ctx)
   | pe :: p' -> (
       (* Match on the projection element and the value *)
       match (pe, v.V.value, v.V.ty) with
-      | ( Field (((ProjAdt (_, _) | ProjOption _) as proj_kind), field_id),
+      | ( Field ((ProjAdt (_, _) as proj_kind), field_id),
           V.Adt adt,
           T.Adt (type_id, _) ) -> (
           (* Check consistency *)
@@ -104,8 +104,6 @@ let rec access_projection (access : projection_access) (ctx : C.eval_ctx)
           | ProjAdt (def_id, opt_variant_id), T.AdtId def_id' ->
               assert (def_id = def_id');
               assert (opt_variant_id = adt.variant_id)
-          | ProjOption variant_id, T.Assumed T.Option ->
-              assert (Some variant_id = adt.variant_id)
           | _ -> raise (Failure "Unreachable"));
           (* Actually project *)
           let fv = T.FieldId.nth adt.field_values field_id in
@@ -136,7 +134,7 @@ let rec access_projection (access : projection_access) (ctx : C.eval_ctx)
               Ok (ctx, { res with updated })
           (* If we reach Bottom, it may mean we need to expand an uninitialized
            * enumeration value *))
-      | Field ((ProjAdt (_, _) | ProjTuple _ | ProjOption _), _), V.Bottom, _ ->
+      | Field ((ProjAdt (_, _) | ProjTuple _), _), V.Bottom, _ ->
           Error (FailBottom (1 + List.length p', pe, v.ty))
       (* Symbolic value: needs to be expanded *)
       | _, Symbolic sp, _ ->
@@ -376,20 +374,6 @@ let compute_expanded_bottom_adt_value (ctx : C.eval_ctx)
   let ty = T.Adt (T.AdtId def_id, generics) in
   { V.value = av; V.ty }
 
-let compute_expanded_bottom_option_value (variant_id : T.VariantId.id)
-    (param_ty : T.ety) : V.typed_value =
-  (* Note that the variant can be [Some] or [None]: we expand bottom values
-   * when writing to fields or setting discriminants *)
-  let field_values =
-    if variant_id = T.option_some_id then [ mk_bottom param_ty ]
-    else if variant_id = T.option_none_id then []
-    else raise (Failure "Unreachable")
-  in
-  let av = V.Adt { variant_id = Some variant_id; field_values } in
-  let generics = TypesUtils.mk_generic_args [] [ param_ty ] [] [] in
-  let ty = T.Adt (T.Assumed T.Option, generics) in
-  { V.value = av; ty }
-
 let compute_expanded_bottom_tuple_value (field_types : T.ety list) :
     V.typed_value =
   (* Generate the field values *)
@@ -451,17 +435,6 @@ let expand_bottom_value_from_projection (access : access_kind) (p : E.place)
         T.Adt (T.AdtId def_id', generics) ) ->
         assert (def_id = def_id');
         compute_expanded_bottom_adt_value ctx def_id opt_variant_id generics
-    (* Option *)
-    | ( Field (ProjOption variant_id, _),
-        T.Adt
-          ( T.Assumed T.Option,
-            {
-              T.regions = [];
-              types = [ ty ];
-              const_generics = [];
-              trait_refs = [];
-            } ) ) ->
-        compute_expanded_bottom_option_value variant_id ty
     (* Tuples *)
     | ( Field (ProjTuple arity, _),
         T.Adt
diff --git a/compiler/InterpreterPaths.mli b/compiler/InterpreterPaths.mli
index 041b0a97..0ff8063f 100644
--- a/compiler/InterpreterPaths.mli
+++ b/compiler/InterpreterPaths.mli
@@ -63,10 +63,6 @@ val compute_expanded_bottom_adt_value :
   T.egeneric_args ->
   V.typed_value
 
-(** Compute an expanded [Option] ⊥ value *)
-val compute_expanded_bottom_option_value :
-  T.VariantId.id -> T.ety -> V.typed_value
-
 (** Drop (end) outer loans at a given place, which should be seen as an l-value
     (we will write to it later, but need to drop the loans before writing).
 
diff --git a/compiler/InterpreterStatements.ml b/compiler/InterpreterStatements.ml
index 9f35c6f2..2aced79f 100644
--- a/compiler/InterpreterStatements.ml
+++ b/compiler/InterpreterStatements.ml
@@ -10,7 +10,6 @@ open TypesUtils
 open ValuesUtils
 module Inv = Invariants
 module S = SynthesizeSymbolic
-open Utils
 open Cps
 open InterpreterUtils
 open InterpreterProjectors
@@ -233,8 +232,7 @@ let set_discriminant (config : C.config) (p : E.place)
   let update_value cf (v : V.typed_value) : m_fun =
    fun ctx ->
     match (v.V.ty, v.V.value) with
-    | T.Adt (((T.AdtId _ | T.Assumed T.Option) as type_id), generics), V.Adt av
-      -> (
+    | T.Adt ((T.AdtId _ as type_id), generics), V.Adt av -> (
         (* There are two situations:
            - either the discriminant is already the proper one (in which case we
              don't do anything)
@@ -253,24 +251,15 @@ let set_discriminant (config : C.config) (p : E.place)
                 | T.AdtId def_id ->
                     compute_expanded_bottom_adt_value ctx def_id
                       (Some variant_id) generics
-                | T.Assumed T.Option ->
-                    assert (generics.regions = []);
-                    compute_expanded_bottom_option_value variant_id
-                      (Collections.List.to_cons_nil generics.types)
                 | _ -> raise (Failure "Unreachable")
               in
               assign_to_place config bottom_v p (cf Unit) ctx)
-    | T.Adt (((T.AdtId _ | T.Assumed T.Option) as type_id), generics), V.Bottom
-      ->
+    | T.Adt ((T.AdtId _ as type_id), generics), V.Bottom ->
         let bottom_v =
           match type_id with
           | T.AdtId def_id ->
               compute_expanded_bottom_adt_value ctx def_id (Some variant_id)
                 generics
-          | T.Assumed T.Option ->
-              assert (generics.regions = []);
-              compute_expanded_bottom_option_value variant_id
-                (Collections.List.to_cons_nil generics.types)
           | _ -> raise (Failure "Unreachable")
         in
         assign_to_place config bottom_v p (cf Unit) ctx
@@ -313,7 +302,7 @@ let get_assumed_function_return_type (ctx : C.eval_ctx) (fid : A.assumed_fun_id)
       mk_unit_ty
   | _ ->
       (* Retrieve the function's signature *)
-      let sg = Assumed.get_assumed_sig fid in
+      let sg = Assumed.get_assumed_fun_sig fid in
       (* Instantiate the return type  *)
       (* There shouldn't be any reference to Self *)
       let tr_self : T.erased_region T.trait_instance_id =
@@ -426,11 +415,6 @@ let pop_frame_assign (config : C.config) (dest : E.place) : cm_fun =
   in
   comp cf_pop cf_assign
 
-(** Auxiliary function - see {!eval_assumed_function_call} *)
-let eval_replace_concrete (_config : C.config) (_generics : T.egeneric_args) :
-    cm_fun =
- fun _cf _ctx -> raise Unimplemented
-
 (** Auxiliary function - see {!eval_assumed_function_call} *)
 let eval_box_new_concrete (config : C.config) (generics : T.egeneric_args) :
     cm_fun =
@@ -475,67 +459,6 @@ let eval_box_new_concrete (config : C.config) (generics : T.egeneric_args) :
       comp cf_move cf_create cf ctx
   | _ -> raise (Failure "Inconsistent state")
 
-(** Auxiliary function which factorizes code to evaluate [std::Deref::deref]
-    and [std::DerefMut::deref_mut] - see {!eval_assumed_function_call} *)
-let eval_box_deref_mut_or_shared_concrete (config : C.config)
-    (generics : T.egeneric_args) (is_mut : bool) : cm_fun =
- fun cf ctx ->
-  (* Check the arguments *)
-  match
-    (generics.regions, generics.types, generics.const_generics, ctx.env)
-  with
-  | ( [],
-      [ boxed_ty ],
-      [],
-      Var (VarBinder input_var, input_value)
-      :: Var (_ret_var, _)
-      :: C.Frame :: _ ) ->
-      (* Required type checking. We must have:
-         - input_value.ty = & (mut) Box<ty>
-         - boxed_ty = ty
-         for some ty
-      *)
-      (let _, input_ty, ref_kind = ty_get_ref input_value.V.ty in
-       assert (match ref_kind with T.Shared -> not is_mut | T.Mut -> is_mut);
-       let input_ty = ty_get_box input_ty in
-       assert (input_ty = boxed_ty));
-
-      (* Borrow the boxed value *)
-      let p =
-        { E.var_id = input_var.C.index; projection = [ E.Deref; E.DerefBox ] }
-      in
-      let borrow_kind = if is_mut then E.Mut else E.Shared in
-      let rv = E.RvRef (p, borrow_kind) in
-      let cf_borrow = eval_rvalue_not_global config rv in
-
-      (* Move the borrow to its destination *)
-      let cf_move cf res : m_fun =
-        match res with
-        | Error EPanic ->
-            (* We can't get there by borrowing a value *)
-            raise (Failure "Unreachable")
-        | Ok borrowed_value ->
-            (* Move and continue *)
-            let destp = mk_place_from_var_id E.VarId.zero in
-            assign_to_place config borrowed_value destp cf
-      in
-
-      (* Compose and apply *)
-      comp cf_borrow cf_move cf ctx
-  | _ -> raise (Failure "Inconsistent state")
-
-(** Auxiliary function - see {!eval_assumed_function_call} *)
-let eval_box_deref_concrete (config : C.config) (generics : T.egeneric_args) :
-    cm_fun =
-  let is_mut = false in
-  eval_box_deref_mut_or_shared_concrete config generics is_mut
-
-(** Auxiliary function - see {!eval_assumed_function_call} *)
-let eval_box_deref_mut_concrete (config : C.config) (generics : T.egeneric_args)
-    : cm_fun =
-  let is_mut = true in
-  eval_box_deref_mut_or_shared_concrete config generics is_mut
-
 (** Auxiliary function - see {!eval_assumed_function_call}.
 
     [Box::free] is not handled the same way as the other assumed functions:
@@ -575,11 +498,6 @@ let eval_box_free (config : C.config) (generics : T.egeneric_args)
       cc cf ctx
   | _ -> raise (Failure "Inconsistent state")
 
-(** Auxiliary function - see {!eval_assumed_function_call} *)
-let eval_vec_function_concrete (_config : C.config) (_fid : A.assumed_fun_id)
-    (_generics : T.egeneric_args) : cm_fun =
- fun _cf _ctx -> raise Unimplemented
-
 (** Evaluate a non-local function call in concrete mode *)
 let eval_assumed_function_call_concrete (config : C.config)
     (fid : A.assumed_fun_id) (call : A.call) : cm_fun =
@@ -636,18 +554,12 @@ let eval_assumed_function_call_concrete (config : C.config)
          * access to a body. *)
         let cf_eval_body : cm_fun =
           match fid with
-          | Replace -> eval_replace_concrete config generics
           | BoxNew -> eval_box_new_concrete config generics
-          | BoxDeref -> eval_box_deref_concrete config generics
-          | BoxDerefMut -> eval_box_deref_mut_concrete config generics
           | BoxFree ->
               (* Should have been treated above *) raise (Failure "Unreachable")
-          | VecNew | VecPush | VecInsert | VecLen | VecIndex | VecIndexMut ->
-              eval_vec_function_concrete config fid generics
           | ArrayIndexShared | ArrayIndexMut | ArrayToSliceShared
-          | ArrayToSliceMut | ArraySubsliceShared | ArraySubsliceMut
-          | ArrayRepeat | SliceIndexShared | SliceIndexMut | SliceSubsliceShared
-          | SliceSubsliceMut | SliceLen ->
+          | ArrayToSliceMut | ArrayRepeat | SliceIndexShared | SliceIndexMut
+          | SliceLen ->
               raise (Failure "Unimplemented")
         in
 
@@ -1531,7 +1443,7 @@ and eval_assumed_function_call_symbolic (config : C.config)
             (* There shouldn't be any reference to Self *)
             let tr_self = T.UnknownTrait __FUNCTION__ in
             instantiate_fun_sig ctx generics tr_self
-              (Assumed.get_assumed_sig fid)
+              (Assumed.get_assumed_fun_sig fid)
       in
 
       (* Evaluate the function call *)
diff --git a/compiler/Invariants.ml b/compiler/Invariants.ml
index 9ac5ce13..5c8ec7af 100644
--- a/compiler/Invariants.ml
+++ b/compiler/Invariants.ml
@@ -447,7 +447,7 @@ let check_typing_invariant (ctx : C.eval_ctx) : unit =
               fields_with_types
         (* Assumed type case *)
         | V.Adt av, T.Adt (T.Assumed aty_id, generics) -> (
-            assert (av.V.variant_id = None || aty_id = T.Option);
+            assert (av.V.variant_id = None);
             match
               ( aty_id,
                 av.V.field_values,
@@ -456,19 +456,8 @@ let check_typing_invariant (ctx : C.eval_ctx) : unit =
                 generics.const_generics )
             with
             (* Box *)
-            | T.Box, [ inner_value ], [], [ inner_ty ], []
-            | T.Option, [ inner_value ], [], [ inner_ty ], [] ->
+            | T.Box, [ inner_value ], [], [ inner_ty ], [] ->
                 assert (inner_value.V.ty = inner_ty)
-            | T.Option, _, [], [ _ ], [] ->
-                (* Option::None: nothing to check *)
-                ()
-            | T.Vec, fvs, [], [ vec_ty ], [] ->
-                List.iter
-                  (fun (v : V.typed_value) -> assert (v.ty = vec_ty))
-                  fvs
-            | T.Range, [ v0; v1 ], [], [ inner_ty ], [] ->
-                assert (v0.V.ty = inner_ty);
-                assert (v1.V.ty = inner_ty)
             | T.Array, inner_values, _, [ inner_ty ], [ cg ] ->
                 (* *)
                 assert (
diff --git a/compiler/LlbcAstUtils.ml b/compiler/LlbcAstUtils.ml
index a982af30..2553127a 100644
--- a/compiler/LlbcAstUtils.ml
+++ b/compiler/LlbcAstUtils.ml
@@ -5,13 +5,13 @@ let lookup_fun_sig (fun_id : fun_id) (fun_decls : fun_decl FunDeclId.Map.t) :
     fun_sig =
   match fun_id with
   | Regular id -> (FunDeclId.Map.find id fun_decls).signature
-  | Assumed aid -> Assumed.get_assumed_sig aid
+  | Assumed aid -> Assumed.get_assumed_fun_sig aid
 
 let lookup_fun_name (fun_id : fun_id) (fun_decls : fun_decl FunDeclId.Map.t) :
     Names.fun_name =
   match fun_id with
   | Regular id -> (FunDeclId.Map.find id fun_decls).name
-  | Assumed aid -> Assumed.get_assumed_name aid
+  | Assumed aid -> Assumed.get_assumed_fun_name aid
 
 (** Return the opaque declarations found in the crate.
 
@@ -22,7 +22,7 @@ let lookup_fun_name (fun_id : fun_id) (fun_decls : fun_decl FunDeclId.Map.t) :
  *)
 let crate_get_opaque_decls (k : crate) (filter_assumed : bool) :
     T.type_decl list * fun_decl list =
-  let open ExtractAssumed in
+  let open ExtractBuiltin in
   let is_opaque_fun (d : fun_decl) : bool =
     let sname = name_to_simple_name d.name in
     d.body = None
@@ -30,7 +30,7 @@ let crate_get_opaque_decls (k : crate) (filter_assumed : bool) :
        (which don't have a body but must not be considered as opaque) *)
     && (match d.kind with TraitMethodDecl _ -> false | _ -> true)
     && ((not filter_assumed)
-       || not (SimpleNameMap.mem sname assumed_globals_map))
+       || not (SimpleNameMap.mem sname builtin_globals_map))
   in
   let is_opaque_type (d : T.type_decl) : bool = d.kind = T.Opaque in
   (* Note that by checking the function bodies we also the globals *)
diff --git a/compiler/PrePasses.ml b/compiler/PrePasses.ml
index 1058fab0..ee06fa07 100644
--- a/compiler/PrePasses.ml
+++ b/compiler/PrePasses.ml
@@ -108,7 +108,7 @@ let remove_useless_cf_merges (crate : A.crate) (f : A.fun_decl) : A.fun_decl =
     | Assign (_, rv) -> (
         match rv with
         | Use _ | RvRef _ -> not must_end_with_exit
-        | Aggregate (AggregatedTuple, []) -> not must_end_with_exit
+        | Aggregate (AggregatedAdt (Tuple, _, _), []) -> not must_end_with_exit
         | _ -> false)
     | FakeRead _ | Drop _ | Nop -> not must_end_with_exit
     | Panic | Return -> true
diff --git a/compiler/Print.ml b/compiler/Print.ml
index 1d5ddc50..aeacfbf0 100644
--- a/compiler/Print.ml
+++ b/compiler/Print.ml
@@ -127,17 +127,6 @@ module Values = struct
             (* Assumed type *)
             match (aty, field_values) with
             | Box, [ bv ] -> "@Box(" ^ bv ^ ")"
-            | Option, _ ->
-                if av.variant_id = Some T.option_some_id then
-                  "@Option::Some("
-                  ^ Collections.List.to_cons_nil field_values
-                  ^ ")"
-                else if av.variant_id = Some T.option_none_id then (
-                  assert (field_values = []);
-                  "@Option::None")
-                else raise (Failure "Unreachable")
-            | Range, _ -> "@Range{ " ^ String.concat ", " field_values ^ "}"
-            | Vec, _ -> "@Vec[" ^ String.concat ", " field_values ^ "]"
             | Array, _ ->
                 (* Happens when we aggregate values *)
                 "@Array[" ^ String.concat ", " field_values ^ "]"
diff --git a/compiler/PrintPure.ml b/compiler/PrintPure.ml
index be7b3cb4..6396fe96 100644
--- a/compiler/PrintPure.ml
+++ b/compiler/PrintPure.ml
@@ -195,12 +195,9 @@ let assumed_ty_to_string (aty : assumed_ty) : string =
   | Result -> "Result"
   | Error -> "Error"
   | Fuel -> "Fuel"
-  | Option -> "Option"
-  | Vec -> "Vec"
   | Array -> "Array"
   | Slice -> "Slice"
   | Str -> "Str"
-  | Range -> "Range"
 
 let type_id_to_string (fmt : type_formatter) (id : type_id) : string =
   match id with
@@ -354,10 +351,6 @@ let rec mprojection_to_string (fmt : ast_formatter) (inside : string)
   | pe :: p' -> (
       let s = mprojection_to_string fmt inside p' in
       match pe.pkind with
-      | E.ProjOption variant_id ->
-          assert (variant_id = T.option_some_id);
-          assert (pe.field_id = T.FieldId.zero);
-          "(" ^ s ^ "as Option::Some)." ^ T.FieldId.to_string pe.field_id
       | E.ProjTuple _ -> "(" ^ s ^ ")." ^ T.FieldId.to_string pe.field_id
       | E.ProjAdt (adt_id, opt_variant_id) -> (
           let field_name =
@@ -395,8 +388,6 @@ let adt_variant_to_string (fmt : value_formatter) (adt_id : type_id)
       | State | Array | Slice | Str ->
           (* Those types are opaque: we can't get there *)
           raise (Failure "Unreachable")
-      | Vec -> "@Vec"
-      | Range -> "@Range"
       | Result ->
           let variant_id = Option.get variant_id in
           if variant_id = result_return_id then "@Result::Return"
@@ -412,13 +403,7 @@ let adt_variant_to_string (fmt : value_formatter) (adt_id : type_id)
           let variant_id = Option.get variant_id in
           if variant_id = fuel_zero_id then "@Fuel::Zero"
           else if variant_id = fuel_succ_id then "@Fuel::Succ"
-          else raise (Failure "Unreachable: improper variant id for fuel type")
-      | Option ->
-          let variant_id = Option.get variant_id in
-          if variant_id = option_some_id then "@Option::Some "
-          else if variant_id = option_none_id then "@Option::None"
-          else
-            raise (Failure "Unreachable: improper variant id for result type"))
+          else raise (Failure "Unreachable: improper variant id for fuel type"))
 
 let adt_field_to_string (fmt : value_formatter) (adt_id : type_id)
     (field_id : FieldId.id) : string =
@@ -435,11 +420,10 @@ let adt_field_to_string (fmt : value_formatter) (adt_id : type_id)
   | Assumed aty -> (
       (* Assumed type *)
       match aty with
-      | Range -> FieldId.to_string field_id
-      | State | Fuel | Vec | Array | Slice | Str ->
+      | State | Fuel | Array | Slice | Str ->
           (* Opaque types: we can't get there *)
           raise (Failure "Unreachable")
-      | Result | Error | Option ->
+      | Result | Error ->
           (* Enumerations: we can't get there *)
           raise (Failure "Unreachable"))
 
@@ -510,31 +494,13 @@ let adt_g_value_to_string (fmt : value_formatter)
             | [ v ] -> "@Fuel::Succ " ^ v
             | _ -> raise (Failure "@Fuel::Succ takes exactly one value")
           else raise (Failure "Unreachable: improper variant id for fuel type")
-      | Option ->
-          let variant_id = Option.get variant_id in
-          if variant_id = option_some_id then
-            match field_values with
-            | [ v ] -> "@Option::Some " ^ v
-            | _ -> raise (Failure "Option::Some takes exactly one value")
-          else if variant_id = option_none_id then (
-            assert (field_values = []);
-            "@Option::None")
-          else
-            raise (Failure "Unreachable: improper variant id for result type")
-      | Vec | Array | Slice | Str ->
-          assert (variant_id = None);
-          let field_values =
-            List.mapi (fun i v -> string_of_int i ^ " -> " ^ v) field_values
-          in
-          let id = assumed_ty_to_string aty in
-          id ^ " [" ^ String.concat "; " field_values ^ "]"
-      | Range ->
+      | Array | Slice | Str ->
           assert (variant_id = None);
           let field_values =
             List.mapi (fun i v -> string_of_int i ^ " -> " ^ v) field_values
           in
           let id = assumed_ty_to_string aty in
-          id ^ " {" ^ String.concat "; " field_values ^ "}")
+          id ^ " [" ^ String.concat "; " field_values ^ "]")
   | _ ->
       let fmt = value_to_type_formatter fmt in
       raise
@@ -593,29 +559,16 @@ let fun_suffix (lp_id : LoopId.id option) (rg_id : T.RegionGroupId.id option) :
 
 let llbc_assumed_fun_id_to_string (fid : A.assumed_fun_id) : string =
   match fid with
-  | Replace -> "core::mem::replace"
   | BoxNew -> "alloc::boxed::Box::new"
-  | BoxDeref -> "core::ops::deref::Deref::deref"
-  | BoxDerefMut -> "core::ops::deref::DerefMut::deref_mut"
   | BoxFree -> "alloc::alloc::box_free"
-  | VecNew -> "alloc::vec::Vec::new"
-  | VecPush -> "alloc::vec::Vec::push"
-  | VecInsert -> "alloc::vec::Vec::insert"
-  | VecLen -> "alloc::vec::Vec::len"
-  | VecIndex -> "core::ops::index::Index<alloc::vec::Vec>::index"
-  | VecIndexMut -> "core::ops::index::IndexMut<alloc::vec::Vec>::index_mut"
   | ArrayIndexShared -> "@ArrayIndexShared"
   | ArrayIndexMut -> "@ArrayIndexMut"
   | ArrayToSliceShared -> "@ArrayToSliceShared"
   | ArrayToSliceMut -> "@ArrayToSliceMut"
-  | ArraySubsliceShared -> "@ArraySubsliceShared"
-  | ArraySubsliceMut -> "@ArraySubsliceMut"
   | ArrayRepeat -> "@ArrayRepeat"
   | SliceLen -> "@SliceLen"
   | SliceIndexShared -> "@SliceIndexShared"
   | SliceIndexMut -> "@SliceIndexMut"
-  | SliceSubsliceShared -> "@SliceSubsliceShared"
-  | SliceSubsliceMut -> "@SliceSubsliceMut"
 
 let pure_assumed_fun_id_to_string (fid : pure_assumed_fun_id) : string =
   match fid with
diff --git a/compiler/Pure.ml b/compiler/Pure.ml
index 47c7beb4..81e13af7 100644
--- a/compiler/Pure.ml
+++ b/compiler/Pure.ml
@@ -64,17 +64,7 @@ type fun_decl_id = A.fun_decl_id [@@deriving show, ord]
         this state is opaque to Aeneas (the user can define it, or leave it as
         assumed)
   *)
-type assumed_ty =
-  | State
-  | Result
-  | Error
-  | Fuel
-  | Vec
-  | Option
-  | Array
-  | Slice
-  | Str
-  | Range
+type assumed_ty = State | Result | Error | Fuel | Array | Slice | Str
 [@@deriving show, ord]
 
 (* TODO: we should never directly manipulate [Return] and [Fail], but rather
diff --git a/compiler/PureMicroPasses.ml b/compiler/PureMicroPasses.ml
index b00509a6..a326d19e 100644
--- a/compiler/PureMicroPasses.ml
+++ b/compiler/PureMicroPasses.ml
@@ -1513,7 +1513,7 @@ let unit_vars_to_unit (def : fun_decl) : fun_decl =
     function calls, and when translating end abstractions. Here, we can do
     something simpler, in one micro-pass.
  *)
-let eliminate_box_functions (_ctx : trans_ctx) (def : fun_decl) : fun_decl =
+let eliminate_box_functions (ctx : trans_ctx) (def : fun_decl) : fun_decl =
   (* The map visitor *)
   let obj =
     object
@@ -1522,30 +1522,42 @@ let eliminate_box_functions (_ctx : trans_ctx) (def : fun_decl) : fun_decl =
       method! visit_texpression env e =
         match opt_destruct_function_call e with
         | Some (fun_id, _tys, args) -> (
+            (* Below, when dealing with the arguments: we consider the very
+             * general case, where functions could be boxed (meaning we
+             * could have: [box_new f x])
+             * *)
             match fun_id with
             | Fun (FromLlbc (FunId (Assumed aid), _lp_id, rg_id)) -> (
-                (* Below, when dealing with the arguments: we consider the very
-                 * general case, where functions could be boxed (meaning we
-                 * could have: [box_new f x])
-                 * *)
                 match (aid, rg_id) with
                 | BoxNew, _ ->
                     assert (rg_id = None);
                     let arg, args = Collections.List.pop args in
                     mk_apps arg args
-                | BoxDeref, None ->
+                | BoxFree, _ ->
+                    assert (args = []);
+                    mk_unit_rvalue
+                | ( ( SliceIndexShared | SliceIndexMut | ArrayIndexShared
+                    | ArrayIndexMut | ArrayToSliceShared | ArrayToSliceMut
+                    | ArrayRepeat | SliceLen ),
+                    _ ) ->
+                    super#visit_texpression env e)
+            | Fun (FromLlbc (FunId (Regular fid), _lp_id, rg_id)) -> (
+                (* Lookup the function name *)
+                let def = FunDeclId.Map.find fid ctx.fun_ctx.fun_decls in
+                match (Names.name_to_string def.name, rg_id) with
+                | "alloc::box::Boxed::deref", None ->
                     (* [Box::deref] forward is the identity *)
                     let arg, args = Collections.List.pop args in
                     mk_apps arg args
-                | BoxDeref, Some _ ->
+                | "alloc::box::Boxed::deref", Some _ ->
                     (* [Box::deref] backward is [()] (doesn't give back anything) *)
                     assert (args = []);
                     mk_unit_rvalue
-                | BoxDerefMut, None ->
+                | "alloc::box::Boxed::deref_mut", None ->
                     (* [Box::deref_mut] forward is the identity *)
                     let arg, args = Collections.List.pop args in
                     mk_apps arg args
-                | BoxDerefMut, Some _ ->
+                | "alloc::box::Boxed::deref_mut", Some _ ->
                     (* [Box::deref_mut] back is almost the identity:
                      * let box_deref_mut (x_init : t) (x_back : t) : t = x_back
                      * *)
@@ -1555,17 +1567,7 @@ let eliminate_box_functions (_ctx : trans_ctx) (def : fun_decl) : fun_decl =
                       | _ -> raise (Failure "Unreachable")
                     in
                     mk_apps arg args
-                | BoxFree, _ ->
-                    assert (args = []);
-                    mk_unit_rvalue
-                | ( ( Replace | VecNew | VecPush | VecInsert | VecLen | VecIndex
-                    | VecIndexMut | ArraySubsliceShared | ArraySubsliceMut
-                    | SliceIndexShared | SliceIndexMut | SliceSubsliceShared
-                    | SliceSubsliceMut | ArrayIndexShared | ArrayIndexMut
-                    | ArrayToSliceShared | ArrayToSliceMut | ArrayRepeat
-                    | SliceLen ),
-                    _ ) ->
-                    super#visit_texpression env e)
+                | _ -> super#visit_texpression env e)
             | _ -> super#visit_texpression env e)
         | _ -> super#visit_texpression env e
     end
diff --git a/compiler/PureTypeCheck.ml b/compiler/PureTypeCheck.ml
index b80ff72f..d31f0cf9 100644
--- a/compiler/PureTypeCheck.ml
+++ b/compiler/PureTypeCheck.ml
@@ -46,18 +46,7 @@ let get_adt_field_types (type_decls : type_decl TypeDeclId.Map.t)
           if variant_id = fuel_zero_id then []
           else if variant_id = fuel_succ_id then [ mk_fuel_ty ]
           else raise (Failure "Unreachable: improper variant id for fuel type")
-      | Option ->
-          let ty = Collections.List.to_cons_nil generics.types in
-          let variant_id = Option.get variant_id in
-          if variant_id = option_some_id then [ ty ]
-          else if variant_id = option_none_id then []
-          else
-            raise (Failure "Unreachable: improper variant id for option type")
-      | Range ->
-          let ty = Collections.List.to_cons_nil generics.types in
-          assert (variant_id = None);
-          [ ty; ty ]
-      | Vec | Array | Slice | Str ->
+      | Array | Slice | Str ->
           (* Array: when not symbolic values (for instance, because of aggregates),
              the array expressions are introduced as struct updates *)
           raise (Failure "Attempting to access the fields of an opaque type"))
diff --git a/compiler/Substitute.ml b/compiler/Substitute.ml
index b1680282..6d9b9e15 100644
--- a/compiler/Substitute.ml
+++ b/compiler/Substitute.ml
@@ -305,19 +305,7 @@ let ctx_adt_value_get_instantiated_field_rtypes (ctx : C.eval_ctx)
       generics.types
   | T.Assumed aty -> (
       match aty with
-      | T.Box | T.Vec ->
-          assert (generics.regions = []);
-          assert (List.length generics.types = 1);
-          assert (generics.const_generics = []);
-          generics.types
-      | T.Option ->
-          assert (generics.regions = []);
-          assert (List.length generics.types = 1);
-          assert (generics.const_generics = []);
-          if adt.V.variant_id = Some T.option_some_id then generics.types
-          else if adt.V.variant_id = Some T.option_none_id then []
-          else raise (Failure "Unreachable")
-      | T.Range ->
+      | T.Box ->
           assert (generics.regions = []);
           assert (List.length generics.types = 1);
           assert (generics.const_generics = []);
diff --git a/compiler/SymbolicToPure.ml b/compiler/SymbolicToPure.ml
index 54221cb1..9c698b51 100644
--- a/compiler/SymbolicToPure.ml
+++ b/compiler/SymbolicToPure.ml
@@ -405,8 +405,6 @@ let rec translate_sty (ty : T.sty) : ty =
           mk_simpl_tuple_ty generics.types
       | T.Assumed aty -> (
           match aty with
-          | T.Vec -> Adt (Assumed Vec, generics)
-          | T.Option -> Adt (Assumed Option, generics)
           | T.Box -> (
               (* Eliminate the boxes *)
               match generics.types with
@@ -418,8 +416,7 @@ let rec translate_sty (ty : T.sty) : ty =
               )
           | T.Array -> Adt (Assumed Array, generics)
           | T.Slice -> Adt (Assumed Slice, generics)
-          | T.Str -> Adt (Assumed Str, generics)
-          | T.Range -> Adt (Assumed Range, generics)))
+          | T.Str -> Adt (Assumed Str, generics)))
   | TypeVar vid -> TypeVar vid
   | Literal ty -> Literal ty
   | Never -> raise (Failure "Unreachable")
@@ -510,12 +507,9 @@ let translate_type_id (id : T.type_id) : type_id =
   | T.Assumed aty ->
       let aty =
         match aty with
-        | T.Vec -> Vec
-        | T.Option -> Option
         | T.Array -> Array
         | T.Slice -> Slice
         | T.Str -> Str
-        | T.Range -> Range
         | T.Box ->
             (* Boxes have to be eliminated: this type id shouldn't
                be translated *)
@@ -534,8 +528,7 @@ let rec translate_fwd_ty (type_infos : TA.type_infos) (ty : 'r T.ty) : ty =
       let t_generics = translate_fwd_generic_args type_infos generics in
       (* Eliminate boxes and simplify tuples *)
       match type_id with
-      | AdtId _
-      | T.Assumed (T.Vec | T.Option | T.Array | T.Slice | T.Str | T.Range) ->
+      | AdtId _ | T.Assumed (T.Array | T.Slice | T.Str) ->
           (* No general parametricity for now *)
           assert (
             not
@@ -610,8 +603,7 @@ let rec translate_back_ty (type_infos : TA.type_infos)
   match ty with
   | T.Adt (type_id, generics) -> (
       match type_id with
-      | T.AdtId _
-      | Assumed (T.Vec | T.Option | T.Array | T.Slice | T.Str | T.Range) ->
+      | T.AdtId _ | Assumed (T.Array | T.Slice | T.Str) ->
           (* Don't accept ADTs (which are not tuples) with borrows for now *)
           assert (not (TypesUtils.ty_has_borrows type_infos ty));
           let type_id = translate_type_id type_id in
@@ -815,7 +807,7 @@ let get_fun_effect_info (fun_infos : FA.fun_info A.FunDeclId.Map.t)
   | FunId (Assumed aid) ->
       assert (lid = None);
       {
-        can_fail = Assumed.assumed_can_fail aid;
+        can_fail = Assumed.assumed_fun_can_fail aid;
         stateful_group = false;
         stateful = false;
         can_diverge = false;
@@ -1221,9 +1213,7 @@ let rec typed_avalue_to_consumed (ctx : bs_ctx) (ectx : C.eval_ctx)
         (* For now, only tuples can contain borrows *)
         let adt_id, _ = TypesUtils.ty_as_adt av.ty in
         match adt_id with
-        | T.AdtId _
-        | T.Assumed
-            (T.Box | T.Vec | T.Option | T.Array | T.Slice | T.Str | T.Range) ->
+        | T.AdtId _ | T.Assumed (T.Box | T.Array | T.Slice | T.Str) ->
             assert (field_values = []);
             None
         | T.Tuple ->
@@ -1368,9 +1358,7 @@ let rec typed_avalue_to_given_back (mp : mplace option) (av : V.typed_avalue)
          * vector value upon visiting the "abstraction borrow" node *)
         let adt_id, _ = TypesUtils.ty_as_adt av.ty in
         match adt_id with
-        | T.AdtId _
-        | T.Assumed
-            (T.Box | T.Vec | T.Option | T.Array | T.Slice | T.Str | T.Range) ->
+        | T.AdtId _ | T.Assumed (T.Box | T.Array | T.Slice | T.Str) ->
             assert (field_values = []);
             (ctx, None)
         | T.Tuple ->
@@ -2441,17 +2429,12 @@ and translate_ExpandAdt_one_branch (sv : V.symbolic_value)
         (mk_typed_pattern_from_var var None)
         (mk_opt_mplace_texpression scrutinee_mplace scrutinee)
         branch
-  | T.Assumed (T.Vec | T.Array | T.Slice | T.Str) ->
+  | T.Assumed (T.Array | T.Slice | T.Str) ->
       (* We can't expand those values: we can access the fields only
        * through the functions provided by the API (note that we don't
        * know how to expand values like vectors or arrays, because they have a variable number
        * of fields!) *)
       raise (Failure "Attempt to expand a non-expandable value")
-  | T.Assumed Range -> raise (Failure "Unimplemented")
-  | T.Assumed T.Option ->
-      (* We shouldn't get there in the "one-branch" case: options have
-       * two variants *)
-      raise (Failure "Unreachable")
 
 and translate_intro_symbolic (ectx : C.eval_ctx) (p : S.mplace option)
     (sv : V.symbolic_value) (v : S.value_aggregate) (e : S.expression)
diff --git a/compiler/Translate.ml b/compiler/Translate.ml
index 8e01c869..15297770 100644
--- a/compiler/Translate.ml
+++ b/compiler/Translate.ml
@@ -297,9 +297,11 @@ let translate_crate_to_pure (crate : A.crate) :
   (* Translate all the function *signatures* *)
   let assumed_sigs =
     List.map
-      (fun (id, sg, _, _) ->
-        (E.Assumed id, List.map (fun _ -> None) (sg : A.fun_sig).inputs, sg))
-      Assumed.assumed_infos
+      (fun (info : Assumed.assumed_fun_info) ->
+        ( E.Assumed info.fun_id,
+          List.map (fun _ -> None) info.fun_sig.inputs,
+          info.fun_sig ))
+      Assumed.assumed_fun_infos
   in
   let local_sigs =
     List.map
@@ -425,11 +427,15 @@ let export_type (fmt : Format.formatter) (config : gen_config) (ctx : gen_ctx)
         (true, kind)
   in
   (* Extract, if the config instructs to do so (depending on whether the type
-   * is opaque or not) *)
-  if
+     is opaque or not). Remark: we don't check if the definitions are builtin
+     here but in the function [export_types_group]: the reason is that if one
+     definition in the group is builtin, then we must check that all the
+     definitions are marked builtin *)
+  let extract =
     (is_opaque && config.extract_opaque)
     || ((not is_opaque) && config.extract_transparent)
-  then (
+  in
+  if extract then (
     if extract_decl then
       Extract.extract_type_decl ctx fmt type_decl_group kind def;
     if extract_extra_info then
@@ -464,41 +470,58 @@ let export_types_group (fmt : Format.formatter) (config : gen_config)
     List.map (fun id -> Pure.TypeDeclId.Map.find id ctx.trans_types) ids
   in
 
-  (* Extract the type declarations.
-
-     Because some declaration groups are delimited, we wrap the declarations
-     between [{start,end}_type_decl_group].
+  (* Check if the definition are builtin - if yes they must be ignored.
+     Note that if one definition in the group is builtin, then all the
+     definitions must be builtin *)
+  let builtin =
+    let open ExtractBuiltin in
+    let types_map = builtin_types_map () in
+    List.map
+      (fun (def : Pure.type_decl) ->
+        let sname = name_to_simple_name def.name in
+        SimpleNameMap.find_opt sname types_map <> None)
+      defs
+  in
 
-     Ex.:
-     ====
-     When targeting HOL4, the calls to [{start,end}_type_decl_group] would generate
-     the [Datatype] and [End] delimiters in the snippet of code below:
+  if List.exists (fun b -> b) builtin then
+    (* Sanity check *)
+    assert (List.for_all (fun b -> b) builtin)
+  else (
+    (* Extract the type declarations.
+
+       Because some declaration groups are delimited, we wrap the declarations
+       between [{start,end}_type_decl_group].
+
+       Ex.:
+       ====
+       When targeting HOL4, the calls to [{start,end}_type_decl_group] would generate
+       the [Datatype] and [End] delimiters in the snippet of code below:
+
+       {[
+         Datatype:
+           tree =
+             TLeaf 'a
+           | TNode node ;
+
+           node =
+             Node (tree list)
+         End
+       ]}
+    *)
+    Extract.start_type_decl_group ctx fmt is_rec defs;
+    List.iteri
+      (fun i def ->
+        let kind = kind_from_index i in
+        export_type_decl kind def)
+      defs;
+    Extract.end_type_decl_group fmt is_rec defs;
 
-     {[
-       Datatype:
-         tree =
-           TLeaf 'a
-         | TNode node ;
-
-         node =
-           Node (tree list)
-       End
-     ]}
-  *)
-  Extract.start_type_decl_group ctx fmt is_rec defs;
-  List.iteri
-    (fun i def ->
-      let kind = kind_from_index i in
-      export_type_decl kind def)
-    defs;
-  Extract.end_type_decl_group fmt is_rec defs;
-
-  (* Export the extra information (ex.: [Arguments] instructions in Coq) *)
-  List.iteri
-    (fun i def ->
-      let kind = kind_from_index i in
-      export_type_extra_info kind def)
-    defs
+    (* Export the extra information (ex.: [Arguments] instructions in Coq) *)
+    List.iteri
+      (fun i def ->
+        let kind = kind_from_index i in
+        export_type_extra_info kind def)
+      defs)
 
 (** Export a global declaration.
 
@@ -520,12 +543,12 @@ let export_global (fmt : Format.formatter) (config : gen_config) (ctx : gen_ctx)
     && (((not is_opaque) && config.extract_transparent)
        || (is_opaque && config.extract_opaque))
   in
-  (* Check if it is an assumed global - if yes, we ignore it because we
+  (* Check if it is a builtin global - if yes, we ignore it because we
      map the definition to one in the standard library *)
-  let open ExtractAssumed in
+  let open ExtractBuiltin in
   let sname = name_to_simple_name global.name in
   let extract =
-    extract && SimpleNameMap.find_opt sname assumed_globals_map = None
+    extract && SimpleNameMap.find_opt sname builtin_globals_map = None
   in
   if extract then
     (* We don't wrap global declaration groups between calls to functions
diff --git a/compiler/TypesAnalysis.ml b/compiler/TypesAnalysis.ml
index 4a187893..16f8c5f9 100644
--- a/compiler/TypesAnalysis.ml
+++ b/compiler/TypesAnalysis.ml
@@ -168,9 +168,7 @@ let analyze_full_ty (r_is_static : 'r -> bool) (updated : bool ref)
         in
         (* Continue exploring *)
         analyze expl_info ty_info rty
-    | Adt
-        ( (Tuple | Assumed (Box | Vec | Option | Slice | Array | Str | Range)),
-          generics ) ->
+    | Adt ((Tuple | Assumed (Box | Slice | Array | Str)), generics) ->
         (* Nothing to update: just explore the type parameters *)
         List.fold_left
           (fun ty_info ty -> analyze expl_info ty_info ty)
diff --git a/compiler/dune b/compiler/dune
index 2f5a0a44..4ec46b70 100644
--- a/compiler/dune
+++ b/compiler/dune
@@ -22,8 +22,8 @@
   Expressions
   ExpressionsUtils
   Extract
-  ExtractAssumed
   ExtractBase
+  ExtractBuiltin
   FunsAnalysis
   Identifiers
   InterpreterBorrowsCore
-- 
cgit v1.3.1


From c486bd0675f489c5ac917749a68e2c71b55041ae Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Mon, 23 Oct 2023 17:29:15 +0200
Subject: Make progress on handling the builtins

---
 compiler/Extract.ml        | 254 +++++++++++++++++++++++++++++++++++++--------
 compiler/ExtractBase.ml    |  68 ------------
 compiler/ExtractBuiltin.ml |  93 +++++++++--------
 compiler/Translate.ml      |   9 +-
 4 files changed, 270 insertions(+), 154 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/compiler/Extract.ml b/compiler/Extract.ml
index 30c4c27d..6a306592 100644
--- a/compiler/Extract.ml
+++ b/compiler/Extract.ml
@@ -4062,64 +4062,234 @@ let extract_global_decl (ctx : extraction_ctx) (fmt : F.formatter)
       (* Add a break to insert lines between declarations *)
       F.pp_print_break fmt 0 0
 
-(** Register the names for one trait method item *)
-let extract_trait_decl_method_register_names (ctx : extraction_ctx)
-    (trait_decl : trait_decl) (name : string) (id : fun_decl_id) :
+(** Similar to {!extract_trait_decl_register_names} *)
+let extract_trait_decl_register_parent_clause_names (ctx : extraction_ctx)
+    (trait_decl : trait_decl)
+    (builtin_info : ExtractBuiltin.builtin_trait_decl_info option) :
     extraction_ctx =
-  (* We add one field per required forward/backward function *)
-  let trans = A.FunDeclId.Map.find id ctx.trans_funs in
-
-  let register_fun ctx f = ctx_add_trait_method trait_decl name f.f ctx in
+  let is_opaque = false in
+  let generics = trait_decl.generics in
+  (* Compute the clause names *)
+  let clause_names =
+    match builtin_info with
+    | None ->
+        List.map
+          (fun (c : trait_clause) ->
+            let name = ctx.fmt.trait_parent_clause_name trait_decl c in
+            (* Add a prefix if necessary *)
+            let name =
+              if !Config.record_fields_short_names then name
+              else ctx.fmt.trait_decl_name trait_decl ^ name
+            in
+            (c.clause_id, name))
+          generics.trait_clauses
+    | Some info ->
+        List.map
+          (fun (c, name) -> (c.clause_id, name))
+          (List.combine generics.trait_clauses info.parent_clauses)
+  in
+  (* Register the names *)
+  List.fold_left
+    (fun ctx (cid, cname) ->
+      ctx_add is_opaque (TraitParentClauseId (trait_decl.def_id, cid)) cname ctx)
+    ctx clause_names
+
+(** Similar to {!extract_trait_decl_register_names} *)
+let extract_trait_decl_register_constant_names (ctx : extraction_ctx)
+    (trait_decl : trait_decl)
+    (builtin_info : ExtractBuiltin.builtin_trait_decl_info option) :
+    extraction_ctx =
+  let is_opaque = false in
+  let consts = trait_decl.consts in
+  (* Compute the names *)
+  let constant_names =
+    match builtin_info with
+    | None ->
+        List.map
+          (fun (item_name, _) ->
+            let name = ctx.fmt.trait_const_name trait_decl item_name in
+            (* Add a prefix if necessary *)
+            let name =
+              if !Config.record_fields_short_names then name
+              else ctx.fmt.trait_decl_name trait_decl ^ name
+            in
+            (item_name, name))
+          consts
+    | Some info ->
+        let const_map = StringMap.of_list info.consts in
+        List.map
+          (fun (item_name, _) ->
+            (item_name, StringMap.find item_name const_map))
+          consts
+  in
   (* Register the names *)
-  let funs = trans.fwd :: trans.backs in
-  List.fold_left register_fun ctx funs
+  List.fold_left
+    (fun ctx (item_name, name) ->
+      ctx_add is_opaque (TraitItemId (trait_decl.def_id, item_name)) name ctx)
+    ctx constant_names
+
+(** Similar to {!extract_trait_decl_register_names} *)
+let extract_trait_decl_type_names (ctx : extraction_ctx)
+    (trait_decl : trait_decl)
+    (builtin_info : ExtractBuiltin.builtin_trait_decl_info option) :
+    extraction_ctx =
+  let is_opaque = false in
+  let types = trait_decl.types in
+  (* Compute the names *)
+  let type_names =
+    match builtin_info with
+    | None ->
+        let compute_type_name (item_name : string) : string =
+          let type_name = ctx.fmt.trait_type_name trait_decl item_name in
+          if !Config.record_fields_short_names then type_name
+          else ctx.fmt.trait_decl_name trait_decl ^ type_name
+        in
+        let compute_clause_name (item_name : string) (clause : trait_clause) :
+            TraitClauseId.id * string =
+          let name =
+            ctx.fmt.trait_type_clause_name trait_decl item_name clause
+          in
+          (* Add a prefix if necessary *)
+          let name =
+            if !Config.record_fields_short_names then name
+            else ctx.fmt.trait_decl_name trait_decl ^ name
+          in
+          (clause.clause_id, name)
+        in
+        List.map
+          (fun (item_name, (item_clauses, _)) ->
+            (* Type name *)
+            let type_name = compute_type_name item_name in
+            (* Clause names *)
+            let clauses =
+              List.map (compute_clause_name item_name) item_clauses
+            in
+            (item_name, (type_name, clauses)))
+          types
+    | Some info ->
+        let type_map = StringMap.of_list info.types in
+        List.map
+          (fun (item_name, (item_clauses, _)) ->
+            let type_name, clauses_info = StringMap.find item_name type_map in
+            let clauses =
+              List.map
+                (fun (clause, clause_name) -> (clause.clause_id, clause_name))
+                (List.combine item_clauses clauses_info)
+            in
+            (item_name, (type_name, clauses)))
+          types
+  in
+  (* Register the names *)
+  List.fold_left
+    (fun ctx (item_name, (type_name, clauses)) ->
+      let ctx =
+        ctx_add is_opaque
+          (TraitItemId (trait_decl.def_id, item_name))
+          type_name ctx
+      in
+      List.fold_left
+        (fun ctx (clause_id, clause_name) ->
+          ctx_add is_opaque
+            (TraitItemClauseId (trait_decl.def_id, item_name, clause_id))
+            clause_name ctx)
+        ctx clauses)
+    ctx type_names
+
+(** Similar to {!extract_trait_decl_register_names} *)
+let extract_trait_decl_method_names (ctx : extraction_ctx)
+    (trait_decl : trait_decl)
+    (builtin_info : ExtractBuiltin.builtin_trait_decl_info option) :
+    extraction_ctx =
+  let is_opaque = false in
+  let required_methods = trait_decl.required_methods in
+  (* Compute the names *)
+  let method_names =
+    (* We add one field per required forward/backward function *)
+    let get_funs_for_id (id : fun_decl_id) : fun_decl list =
+      let trans : pure_fun_translation = FunDeclId.Map.find id ctx.trans_funs in
+      List.map (fun f -> f.f) (trans.fwd :: trans.backs)
+    in
+    match builtin_info with
+    | None ->
+        (* We add one field per required forward/backward function *)
+        let compute_item_names (item_name : string) (id : fun_decl_id) :
+            string * (RegionGroupId.id option * string) list =
+          let compute_fun_name (f : fun_decl) : RegionGroupId.id option * string
+              =
+            (* We do something special: we use the base name but remove everything
+               but the crate (because [get_name] removes it) and the last ident.
+               This allows us to reuse the [ctx_compute_fun_decl] function.
+            *)
+            let basename : name =
+              match (f.basename : name) with
+              | Ident crate :: name ->
+                  Ident crate :: [ Collections.List.last name ]
+              | _ -> raise (Failure "Unexpected")
+            in
+            let f = { f with basename } in
+            let trans = A.FunDeclId.Map.find f.def_id ctx.trans_funs in
+            let name = ctx_compute_fun_name trans f ctx in
+            (* Add a prefix if necessary *)
+            let name =
+              if !Config.record_fields_short_names then name
+              else ctx.fmt.trait_decl_name trait_decl ^ "_" ^ name
+            in
+            (f.back_id, name)
+          in
+          let funs = get_funs_for_id id in
+          (item_name, List.map compute_fun_name funs)
+        in
+        List.map (fun (name, id) -> compute_item_names name id) required_methods
+    | Some info ->
+        let funs_map = StringMap.of_list info.funs in
+        List.map
+          (fun (item_name, fun_id) ->
+            let info = StringMap.find item_name funs_map in
+            let trans_funs = get_funs_for_id fun_id in
+            let rg_with_name_list =
+              List.map
+                (fun (trans_fun : fun_decl) ->
+                  List.find (fun (rg, _) -> rg = trans_fun.back_id) info)
+                trans_funs
+            in
+            (item_name, rg_with_name_list))
+          required_methods
+  in
+  (* Register the names *)
+  List.fold_left
+    (fun ctx (item_name, funs) ->
+      (* We add one field per required forward/backward function *)
+      List.fold_left
+        (fun ctx (rg, fun_name) ->
+          ctx_add is_opaque
+            (TraitMethodId (trait_decl.def_id, item_name, rg))
+            fun_name ctx)
+        ctx funs)
+    ctx method_names
 
 (** Similar to {!extract_type_decl_register_names} *)
 let extract_trait_decl_register_names (ctx : extraction_ctx)
     (trait_decl : trait_decl) : extraction_ctx =
-  let {
-    def_id = _;
-    name = _;
-    generics;
-    preds = _;
-    all_trait_clauses = _;
-    consts;
-    types;
-    required_methods;
-    provided_methods = _;
-  } =
-    trait_decl
+  (* Lookup the information if this is a builtin trait *)
+  let open ExtractBuiltin in
+  let sname = name_to_simple_name trait_decl.name in
+  let builtin_info =
+    SimpleNameMap.find_opt sname (builtin_trait_decls_map ())
   in
   let ctx = ctx_add_trait_decl trait_decl ctx in
   (* Parent clauses *)
   let ctx =
-    List.fold_left
-      (fun ctx clause -> ctx_add_trait_parent_clause trait_decl clause ctx)
-      ctx generics.trait_clauses
+    extract_trait_decl_register_parent_clause_names ctx trait_decl builtin_info
   in
   (* Constants *)
   let ctx =
-    List.fold_left
-      (fun ctx (name, (_, _)) -> ctx_add_trait_const trait_decl name ctx)
-      ctx consts
+    extract_trait_decl_register_constant_names ctx trait_decl builtin_info
   in
   (* Types *)
-  let ctx =
-    List.fold_left
-      (fun ctx (name, (clauses, _)) ->
-        let ctx = ctx_add_trait_type trait_decl name ctx in
-        List.fold_left
-          (fun ctx clause ->
-            ctx_add_trait_type_clause trait_decl name clause ctx)
-          ctx clauses)
-      ctx types
-  in
+  let ctx = extract_trait_decl_type_names ctx trait_decl builtin_info in
   (* Required methods *)
-  List.fold_left
-    (fun ctx (name, id) ->
-      (* We add one field per required forward/backward function *)
-      extract_trait_decl_method_register_names ctx trait_decl name id)
-    ctx required_methods
+  let ctx = extract_trait_decl_method_names ctx trait_decl builtin_info in
+  ctx
 
 (** Similar to {!extract_type_decl_register_names} *)
 let extract_trait_impl_register_names (ctx : extraction_ctx)
diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index 54f69735..ea5fe8d3 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -1288,74 +1288,6 @@ let ctx_add_trait_impl (d : trait_impl) (ctx : extraction_ctx) : extraction_ctx
   let name = ctx.fmt.trait_impl_name decl d in
   ctx_add is_opaque (TraitImplId d.def_id) name ctx
 
-let ctx_add_trait_const (d : trait_decl) (item : string) (ctx : extraction_ctx)
-    : extraction_ctx =
-  let is_opaque = false in
-  let name = ctx.fmt.trait_const_name d item in
-  (* Add a prefix if necessary *)
-  let name =
-    if !Config.record_fields_short_names then name
-    else ctx.fmt.trait_decl_name d ^ name
-  in
-  ctx_add is_opaque (TraitItemId (d.def_id, item)) name ctx
-
-let ctx_add_trait_type (d : trait_decl) (item : string) (ctx : extraction_ctx) :
-    extraction_ctx =
-  let is_opaque = false in
-  let name = ctx.fmt.trait_type_name d item in
-  (* Add a prefix if necessary *)
-  let name =
-    if !Config.record_fields_short_names then name
-    else ctx.fmt.trait_decl_name d ^ name
-  in
-  ctx_add is_opaque (TraitItemId (d.def_id, item)) name ctx
-
-let ctx_add_trait_method (d : trait_decl) (item_name : string) (f : fun_decl)
-    (ctx : extraction_ctx) : extraction_ctx =
-  (* We do something special: we use the base name but remove everything
-     but the crate (because [get_name] removes it) and the last ident.
-     This allows us to reuse the [ctx_compute_fun_decl] function.
-  *)
-  let basename : name =
-    match (f.basename : name) with
-    | Ident crate :: name -> Ident crate :: [ Collections.List.last name ]
-    | _ -> raise (Failure "Unexpected")
-  in
-  let f = { f with basename } in
-  let trans = A.FunDeclId.Map.find f.def_id ctx.trans_funs in
-  let name = ctx_compute_fun_name trans f ctx in
-  (* Add a prefix if necessary *)
-  let name =
-    if !Config.record_fields_short_names then name
-    else ctx.fmt.trait_decl_name d ^ "_" ^ name
-  in
-  let is_opaque = false in
-  ctx_add is_opaque (TraitMethodId (d.def_id, item_name, f.back_id)) name ctx
-
-let ctx_add_trait_parent_clause (d : trait_decl) (clause : trait_clause)
-    (ctx : extraction_ctx) : extraction_ctx =
-  let is_opaque = false in
-  let name = ctx.fmt.trait_parent_clause_name d clause in
-  (* Add a prefix if necessary *)
-  let name =
-    if !Config.record_fields_short_names then name
-    else ctx.fmt.trait_decl_name d ^ name
-  in
-  ctx_add is_opaque (TraitParentClauseId (d.def_id, clause.clause_id)) name ctx
-
-let ctx_add_trait_type_clause (d : trait_decl) (item : string)
-    (clause : trait_clause) (ctx : extraction_ctx) : extraction_ctx =
-  let is_opaque = false in
-  let name = ctx.fmt.trait_type_clause_name d item clause in
-  (* Add a prefix if necessary *)
-  let name =
-    if !Config.record_fields_short_names then name
-    else ctx.fmt.trait_decl_name d ^ name
-  in
-  ctx_add is_opaque
-    (TraitItemClauseId (d.def_id, item, clause.clause_id))
-    name ctx
-
 type names_map_init = {
   keywords : string list;
   assumed_adts : (assumed_ty * string) list;
diff --git a/compiler/ExtractBuiltin.ml b/compiler/ExtractBuiltin.ml
index cf5cc70d..3b4afff6 100644
--- a/compiler/ExtractBuiltin.ml
+++ b/compiler/ExtractBuiltin.ml
@@ -1,5 +1,8 @@
 (** This file declares external identifiers that we catch to map them to
-    definitions coming from the standard libraries in our backends. *)
+    definitions coming from the standard libraries in our backends.
+
+    TODO: there misses trait **implementations**
+ *)
 
 open Names
 open Config
@@ -331,20 +334,20 @@ let mk_builtin_funs_map () =
 
 let builtin_funs_map () = mk_memoized mk_builtin_funs_map
 
-type builtin_trait_info = {
+type builtin_trait_decl_info = {
   rust_name : string;
   extract_name : string;
   parent_clauses : string list;
   consts : (string * string) list;
-  types : (string * string * string list) list;
+  types : (string * (string * string list)) list;
       (** Every type has:
           - a Rust name
           - an extraction name
           - a list of clauses *)
-  funs : (string * Types.RegionGroupId.id option * string) list;
+  funs : (string * (Types.RegionGroupId.id option * string) list) list;
 }
 
-let builtin_traits () =
+let builtin_trait_decls_info () =
   let rg0 = Some Types.RegionGroupId.zero in
   [
     {
@@ -359,18 +362,20 @@ let builtin_traits () =
       types =
         [
           ( "Target",
-            (match !backend with
-            | Coq | FStar | HOL4 -> "core_ops_deref_Deref_Target"
-            | Lean -> "Target"),
-            [] );
+            ( (match !backend with
+              | Coq | FStar | HOL4 -> "core_ops_deref_Deref_Target"
+              | Lean -> "Target"),
+              [] ) );
         ];
       funs =
         [
           ( "deref",
-            None,
-            match !backend with
-            | Coq | FStar | HOL4 -> "core_ops_deref_Deref_deref"
-            | Lean -> "deref" );
+            [
+              ( None,
+                match !backend with
+                | Coq | FStar | HOL4 -> "core_ops_deref_Deref_deref"
+                | Lean -> "deref" );
+            ] );
         ];
     };
     {
@@ -391,15 +396,16 @@ let builtin_traits () =
       funs =
         [
           ( "deref_mut",
-            None,
-            match !backend with
-            | Coq | FStar | HOL4 -> "core_ops_deref_DerefMut_deref_mut"
-            | Lean -> "deref_mut" );
-          ( "deref_mut",
-            rg0,
-            match !backend with
-            | Coq | FStar | HOL4 -> "core_ops_deref_DerefMut_deref_mut_back"
-            | Lean -> "deref_mut_back" );
+            [
+              ( None,
+                match !backend with
+                | Coq | FStar | HOL4 -> "core_ops_deref_DerefMut_deref_mut"
+                | Lean -> "deref_mut" );
+              ( rg0,
+                match !backend with
+                | Coq | FStar | HOL4 -> "core_ops_deref_DerefMut_deref_mut_back"
+                | Lean -> "deref_mut_back" );
+            ] );
         ];
     };
     {
@@ -414,18 +420,20 @@ let builtin_traits () =
       types =
         [
           ( "Output",
-            (match !backend with
-            | Coq | FStar | HOL4 -> "core_ops_index_Index_Output"
-            | Lean -> "Output"),
-            [] );
+            ( (match !backend with
+              | Coq | FStar | HOL4 -> "core_ops_index_Index_Output"
+              | Lean -> "Output"),
+              [] ) );
         ];
       funs =
         [
           ( "index",
-            None,
-            match !backend with
-            | Coq | FStar | HOL4 -> "core_ops_index_Index_index"
-            | Lean -> "index" );
+            [
+              ( None,
+                match !backend with
+                | Coq | FStar | HOL4 -> "core_ops_index_Index_index"
+                | Lean -> "index" );
+            ] );
         ];
     };
     {
@@ -446,23 +454,24 @@ let builtin_traits () =
       funs =
         [
           ( "index_mut",
-            None,
-            match !backend with
-            | Coq | FStar | HOL4 -> "core_ops_index_IndexMut_mut"
-            | Lean -> "index_mut" );
-          ( "index_mut",
-            rg0,
-            match !backend with
-            | Coq | FStar | HOL4 -> "core_ops_index_IndexMut_mut_back"
-            | Lean -> "index_mut_back" );
+            [
+              ( None,
+                match !backend with
+                | Coq | FStar | HOL4 -> "core_ops_index_IndexMut_mut"
+                | Lean -> "index_mut" );
+              ( rg0,
+                match !backend with
+                | Coq | FStar | HOL4 -> "core_ops_index_IndexMut_mut_back"
+                | Lean -> "index_mut_back" );
+            ] );
         ];
     };
   ]
 
-let mk_builtin_traits_map () =
+let mk_builtin_trait_decls_map () =
   SimpleNameMap.of_list
     (List.map
        (fun info -> (string_to_simple_name info.rust_name, info))
-       (builtin_traits ()))
+       (builtin_trait_decls_info ()))
 
-let builtin_traits_map () = mk_memoized mk_builtin_traits_map
+let builtin_trait_decls_map = mk_memoized mk_builtin_trait_decls_map
diff --git a/compiler/Translate.ml b/compiler/Translate.ml
index 15297770..0871a305 100644
--- a/compiler/Translate.ml
+++ b/compiler/Translate.ml
@@ -731,8 +731,13 @@ let export_functions_group (fmt : Format.formatter) (config : gen_config)
 let export_trait_decl (fmt : Format.formatter) (_config : gen_config)
     (ctx : gen_ctx) (trait_decl_id : Pure.trait_decl_id) : unit =
   let trait_decl = T.TraitDeclId.Map.find trait_decl_id ctx.trans_trait_decls in
-  let ctx = { ctx with trait_decl_id = Some trait_decl.def_id } in
-  Extract.extract_trait_decl ctx fmt trait_decl
+  (* Check if the trait declaration is builtin, in which case we ignore it *)
+  let open ExtractBuiltin in
+  let sname = name_to_simple_name trait_decl.name in
+  if SimpleNameMap.find_opt sname (builtin_trait_decls_map ()) = None then
+    let ctx = { ctx with trait_decl_id = Some trait_decl.def_id } in
+    Extract.extract_trait_decl ctx fmt trait_decl
+  else ()
 
 (** Export a trait implementation. *)
 let export_trait_impl (fmt : Format.formatter) (_config : gen_config)
-- 
cgit v1.3.1


From 63107911c16a9991f7d5cf8c6df621318a03ca3b Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Tue, 24 Oct 2023 14:32:38 +0200
Subject: Fix various issues with the builtins

---
 compiler/Extract.ml        | 115 +++++++++++++++++++++++----------
 compiler/ExtractBase.ml    |   1 +
 compiler/ExtractBuiltin.ml |  82 +++++++++++++++++------
 compiler/Translate.ml      | 158 ++++++++++++++++++++++++++-------------------
 4 files changed, 234 insertions(+), 122 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/compiler/Extract.ml b/compiler/Extract.ml
index 6a306592..ddc02fa7 100644
--- a/compiler/Extract.ml
+++ b/compiler/Extract.ml
@@ -1277,7 +1277,10 @@ and extract_trait_decl_ref (ctx : extraction_ctx) (fmt : F.formatter)
   let name = ctx_get_trait_decl is_opaque tr.trait_decl_id ctx in
   if use_brackets then F.pp_print_string fmt "(";
   F.pp_print_string fmt name;
-  extract_generic_args ctx fmt no_params_tys tr.decl_generics;
+  (* There is something subtle here: the trait obligations for the implemented
+     trait are put inside the parent clauses, so we must ignore them here *)
+  let generics = { tr.decl_generics with trait_refs = [] } in
+  extract_generic_args ctx fmt no_params_tys generics;
   if use_brackets then F.pp_print_string fmt ")"
 
 and extract_generic_args (ctx : extraction_ctx) (fmt : F.formatter)
@@ -1349,7 +1352,7 @@ let extract_type_decl_register_names (ctx : extraction_ctx) (def : type_decl) :
   let def_name =
     match info with
     | None -> ctx.fmt.type_name def.name
-    | Some info -> info.rust_name
+    | Some info -> String.concat "." info.rust_name
   in
   let is_opaque = def.kind = Opaque in
   let ctx = ctx_add is_opaque (TypeId (AdtId def.def_id)) def_name ctx in
@@ -1363,7 +1366,7 @@ let extract_type_decl_register_names (ctx : extraction_ctx) (def : type_decl) :
         (* Compute the names *)
         let field_names, cons_name =
           match info with
-          | None ->
+          | None | Some { body_info = None; _ } ->
               let field_names =
                 FieldId.mapi
                   (fun fid (field : field) ->
@@ -1379,7 +1382,11 @@ let extract_type_decl_register_names (ctx : extraction_ctx) (def : type_decl) :
                   (List.combine fields field_names)
               in
               (field_names, cons_name)
-          | _ -> raise (Failure "Invalid builtin information")
+          | Some info ->
+              raise
+                (Failure
+                   ("Invalid builtin information: "
+                   ^ show_builtin_type_info info))
         in
         (* Add the fields *)
         let ctx =
@@ -2365,33 +2372,70 @@ let extract_state_type (fmt : F.formatter) (ctx : extraction_ctx)
 let extract_fun_decl_register_names (ctx : extraction_ctx)
     (has_decreases_clause : fun_decl -> bool) (def : pure_fun_translation) :
     extraction_ctx =
-  let fwd = def.fwd in
-  let backs = def.backs in
-  (* Register the decrease clauses, if necessary *)
-  let register_decreases ctx def =
-    if has_decreases_clause def then
-      (* Add the termination measure *)
-      let ctx = ctx_add_termination_measure def ctx in
-      (* Add the decreases proof for Lean only *)
-      match !Config.backend with
-      | Coq | FStar -> ctx
-      | HOL4 -> raise (Failure "Unexpected")
-      | Lean -> ctx_add_decreases_proof def ctx
-    else ctx
-  in
-  let ctx = List.fold_left register_decreases ctx (fwd.f :: fwd.loops) in
-  let register_fun ctx f = ctx_add_fun_decl def f ctx in
-  let register_funs ctx fl = List.fold_left register_fun ctx fl in
-  (* Register the names of the forward functions *)
-  let ctx =
-    if def.keep_fwd then register_funs ctx (fwd.f :: fwd.loops) else ctx
-  in
-  (* Register the names of the backward functions *)
-  List.fold_left
-    (fun ctx { f = back; loops = loop_backs } ->
-      let ctx = register_fun ctx back in
-      register_funs ctx loop_backs)
-    ctx backs
+  (* Ignore the trait methods **declarations** (rem.: we do not ignore the trait
+     method implementations): we do not need to refer to them directly. We will
+     only use their type for the fields of the records we generate for the trait
+     declarations *)
+  match def.fwd.f.kind with
+  | TraitMethodDecl _ -> ctx
+  | _ -> (
+      (* Check if the function is builtin *)
+      let builtin =
+        let open ExtractBuiltin in
+        let funs_map = builtin_funs_map () in
+        let sname = name_to_simple_name def.fwd.f.basename in
+        SimpleNameMap.find_opt sname funs_map
+      in
+      (* Use the builtin names if necessary *)
+      match builtin with
+      | Some (_filter, info) ->
+          let backs = List.map (fun f -> f.f) def.backs in
+          let funs = if def.keep_fwd then def.fwd.f :: backs else backs in
+          let is_opaque = false in
+          List.fold_left
+            (fun ctx (f : fun_decl) ->
+              let open ExtractBuiltin in
+              let fun_id =
+                (Pure.FunId (Regular f.def_id), f.loop_id, f.back_id)
+              in
+              let fun_name =
+                (List.find
+                   (fun (x : builtin_fun_info) -> x.rg = f.back_id)
+                   info)
+                  .extract_name
+              in
+              ctx_add is_opaque (FunId (FromLlbc fun_id)) fun_name ctx)
+            ctx funs
+      | None ->
+          let fwd = def.fwd in
+          let backs = def.backs in
+          (* Register the decrease clauses, if necessary *)
+          let register_decreases ctx def =
+            if has_decreases_clause def then
+              (* Add the termination measure *)
+              let ctx = ctx_add_termination_measure def ctx in
+              (* Add the decreases proof for Lean only *)
+              match !Config.backend with
+              | Coq | FStar -> ctx
+              | HOL4 -> raise (Failure "Unexpected")
+              | Lean -> ctx_add_decreases_proof def ctx
+            else ctx
+          in
+          let ctx =
+            List.fold_left register_decreases ctx (fwd.f :: fwd.loops)
+          in
+          let register_fun ctx f = ctx_add_fun_decl def f ctx in
+          let register_funs ctx fl = List.fold_left register_fun ctx fl in
+          (* Register the names of the forward functions *)
+          let ctx =
+            if def.keep_fwd then register_funs ctx (fwd.f :: fwd.loops) else ctx
+          in
+          (* Register the names of the backward functions *)
+          List.fold_left
+            (fun ctx { f = back; loops = loop_backs } ->
+              let ctx = register_fun ctx back in
+              register_funs ctx loop_backs)
+            ctx backs)
 
 (** Simply add the global name to the context. *)
 let extract_global_decl_register_names (ctx : extraction_ctx)
@@ -4539,6 +4583,7 @@ let extract_trait_impl_method_items (ctx : extraction_ctx) (fmt : F.formatter)
 (** Extract a trait implementation *)
 let extract_trait_impl (ctx : extraction_ctx) (fmt : F.formatter)
     (impl : trait_impl) : unit =
+  log#ldebug (lazy ("extract_trait_impl: " ^ Names.name_to_string impl.name));
   (* Retrieve the impl name *)
   let with_opaque_pre = false in
   let impl_name = ctx_get_trait_impl with_opaque_pre impl.def_id ctx in
@@ -4565,9 +4610,11 @@ let extract_trait_impl (ctx : extraction_ctx) (fmt : F.formatter)
   (* `let (....) : Trait ... =` *)
   (* Open the box for the name + generics *)
   F.pp_open_hovbox fmt ctx.indent_incr;
-  let qualif = Option.get (ctx.fmt.fun_decl_kind_to_qualif SingleNonRec) in
-  F.pp_print_string fmt qualif;
-  F.pp_print_space fmt ();
+  (match ctx.fmt.fun_decl_kind_to_qualif SingleNonRec with
+  | Some qualif ->
+      F.pp_print_string fmt qualif;
+      F.pp_print_space fmt ()
+  | None -> ());
   F.pp_print_string fmt impl_name;
 
   (* Print the generics *)
diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index ea5fe8d3..22b017e5 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -1249,6 +1249,7 @@ let ctx_compute_fun_name (trans_group : pure_fun_translation) (def : fun_decl)
   ctx.fmt.fun_name def.basename def.num_loops def.loop_id num_rgs rg_info
     (keep_fwd, num_backs)
 
+(* TODO: move to Extract *)
 let ctx_add_fun_decl (trans_group : pure_fun_translation) (def : fun_decl)
     (ctx : extraction_ctx) : extraction_ctx =
   (* Sanity check: the function should not be a global body - those are handled
diff --git a/compiler/ExtractBuiltin.ml b/compiler/ExtractBuiltin.ml
index 3b4afff6..0d591028 100644
--- a/compiler/ExtractBuiltin.ml
+++ b/compiler/ExtractBuiltin.ml
@@ -78,21 +78,24 @@ let builtin_globals_map : string SimpleNameMap.t =
     (List.map (fun (x, y) -> (string_to_simple_name x, y)) builtin_globals)
 
 type builtin_variant_info = { fields : (string * string) list }
+[@@deriving show]
 
 type builtin_enum_variant_info = {
   rust_variant_name : string;
   extract_variant_name : string;
   fields : string list option;
 }
+[@@deriving show]
 
 type builtin_type_body_info =
   | Struct of string * string list
     (* The constructor name and the map for the field names *)
   | Enum of builtin_enum_variant_info list
 (* For every variant, a map for the field names *)
+[@@deriving show]
 
 type builtin_type_info = {
-  rust_name : string;
+  rust_name : string list;
   extract_name : string;
   keep_params : bool list option;
       (** We might want to filter some of the type parameters.
@@ -102,6 +105,7 @@ type builtin_type_info = {
        *)
   body_info : builtin_type_body_info option;
 }
+[@@deriving show]
 
 (** The assumed types.
 
@@ -113,7 +117,7 @@ let builtin_types () : builtin_type_info list =
   [
     (* Alloc *)
     {
-      rust_name = "alloc::alloc::Global";
+      rust_name = [ "alloc"; "alloc"; "Global" ];
       extract_name =
         (match !backend with
         | Lean -> "AllocGlobal"
@@ -123,7 +127,7 @@ let builtin_types () : builtin_type_info list =
     };
     (* Vec *)
     {
-      rust_name = "alloc::vec::Vec";
+      rust_name = [ "alloc"; "vec"; "Vec" ];
       extract_name =
         (match !backend with Lean -> "Vec" | Coq | FStar | HOL4 -> "vec");
       keep_params = Some [ true; false ];
@@ -131,7 +135,7 @@ let builtin_types () : builtin_type_info list =
     };
     (* Option *)
     {
-      rust_name = "core::option::Option";
+      rust_name = [ "core"; "option"; "Option" ];
       extract_name =
         (match !backend with
         | Lean -> "Option"
@@ -163,7 +167,7 @@ let builtin_types () : builtin_type_info list =
     };
     (* Range *)
     {
-      rust_name = "core::ops::range::Range";
+      rust_name = [ "core"; "ops"; "range"; "Range" ];
       extract_name =
         (match !backend with Lean -> "Range" | Coq | FStar | HOL4 -> "range");
       keep_params = None;
@@ -180,9 +184,7 @@ let builtin_types () : builtin_type_info list =
 
 let mk_builtin_types_map () =
   SimpleNameMap.of_list
-    (List.map
-       (fun info -> (string_to_simple_name info.rust_name, info))
-       (builtin_types ()))
+    (List.map (fun info -> (info.rust_name, info)) (builtin_types ()))
 
 let builtin_types_map = mk_memoized mk_builtin_types_map
 
@@ -190,6 +192,7 @@ type builtin_fun_info = {
   rg : Types.RegionGroupId.id option;
   extract_name : string;
 }
+[@@deriving show]
 
 (** The assumed functions.
 
@@ -197,10 +200,12 @@ type builtin_fun_info = {
     parameters. For instance, in the case of the `Vec` functions, there is
     a type parameter for the allocator to use, which we want to filter.
  *)
-let builtin_funs () : (string * bool list option * builtin_fun_info list) list =
+let builtin_funs () :
+    (string list * bool list option * builtin_fun_info list) list =
   let rg0 = Some Types.RegionGroupId.zero in
+  (* TODO: fix the names below *)
   [
-    ( "core::mem::replace",
+    ( [ "core::mem::replace" ],
       None,
       [
         {
@@ -218,7 +223,7 @@ let builtin_funs () : (string * bool list option * builtin_fun_info list) list =
             | Lean -> "mem.replace_back");
         };
       ] );
-    ( "alloc::vec::Vec::new",
+    ( [ "alloc::vec::Vec::new" ],
       Some [ true; false ],
       [
         {
@@ -236,7 +241,7 @@ let builtin_funs () : (string * bool list option * builtin_fun_info list) list =
             | Lean -> "Vec.new_back");
         };
       ] );
-    ( "alloc::vec::Vec::push",
+    ( [ "alloc::vec::Vec::push" ],
       Some [ true; false ],
       [
         (* The forward function shouldn't be used *)
@@ -255,7 +260,7 @@ let builtin_funs () : (string * bool list option * builtin_fun_info list) list =
             | Lean -> "Vec.push");
         };
       ] );
-    ( "alloc::vec::Vec::insert",
+    ( [ "alloc::vec::Vec::insert" ],
       Some [ true; false ],
       [
         (* The forward function shouldn't be used *)
@@ -274,7 +279,7 @@ let builtin_funs () : (string * bool list option * builtin_fun_info list) list =
             | Lean -> "Vec.insert");
         };
       ] );
-    ( "alloc::vec::Vec::len",
+    ( [ "alloc::vec::Vec::len" ],
       Some [ true; false ],
       [
         {
@@ -285,7 +290,7 @@ let builtin_funs () : (string * bool list option * builtin_fun_info list) list =
             | Lean -> "Vec.len");
         };
       ] );
-    ( "alloc::vec::Vec::index",
+    ( [ "alloc::vec::Vec::index" ],
       Some [ true; false ],
       [
         {
@@ -304,7 +309,7 @@ let builtin_funs () : (string * bool list option * builtin_fun_info list) list =
             | Lean -> "Vec.index_shared_back");
         };
       ] );
-    ( "alloc::vec::Vec::index_mut",
+    ( [ "alloc::vec::Vec::index_mut" ],
       Some [ true; false ],
       [
         {
@@ -323,16 +328,52 @@ let builtin_funs () : (string * bool list option * builtin_fun_info list) list =
             | Lean -> "Vec.index_mut_back");
         };
       ] );
+    ( [ "alloc"; "boxed"; "Box"; "deref" ],
+      Some [ true; false ],
+      [
+        {
+          rg = None;
+          extract_name =
+            (match !backend with
+            | FStar | Coq | HOL4 -> "alloc_boxed_box_deref"
+            | Lean -> "alloc.boxed.Box.deref");
+        };
+        (* The backward function shouldn't be used *)
+        {
+          rg = rg0;
+          extract_name =
+            (match !backend with
+            | FStar | Coq | HOL4 -> "alloc_boxed_box_deref_back"
+            | Lean -> "alloc.boxed.Box.deref_back");
+        };
+      ] );
+    ( [ "alloc"; "boxed"; "Box"; "deref_mut" ],
+      Some [ true; false ],
+      [
+        {
+          rg = None;
+          extract_name =
+            (match !backend with
+            | FStar | Coq | HOL4 -> "alloc_boxed_box_deref_mut"
+            | Lean -> "alloc.boxed.Box.deref_mut");
+        };
+        {
+          rg = rg0;
+          extract_name =
+            (match !backend with
+            | FStar | Coq | HOL4 -> "alloc_boxed_box_deref_mut_back"
+            | Lean -> "alloc.boxed.Box.deref_mut_back");
+        };
+      ] );
   ]
 
 let mk_builtin_funs_map () =
   SimpleNameMap.of_list
     (List.map
-       (fun (name, filter, info) ->
-         (string_to_simple_name name, (filter, info)))
+       (fun (name, filter, info) -> (name, (filter, info)))
        (builtin_funs ()))
 
-let builtin_funs_map () = mk_memoized mk_builtin_funs_map
+let builtin_funs_map = mk_memoized mk_builtin_funs_map
 
 type builtin_trait_decl_info = {
   rust_name : string;
@@ -346,6 +387,7 @@ type builtin_trait_decl_info = {
           - a list of clauses *)
   funs : (string * (Types.RegionGroupId.id option * string) list) list;
 }
+[@@deriving show]
 
 let builtin_trait_decls_info () =
   let rg0 = Some Types.RegionGroupId.zero in
@@ -389,7 +431,7 @@ let builtin_trait_decls_info () =
         [
           (match !backend with
           | Coq | FStar | HOL4 -> "deref_inst"
-          | Lean -> "DerefInst");
+          | Lean -> "derefInst");
         ];
       consts = [];
       types = [];
diff --git a/compiler/Translate.ml b/compiler/Translate.ml
index 0871a305..95252b61 100644
--- a/compiler/Translate.ml
+++ b/compiler/Translate.ml
@@ -654,78 +654,100 @@ let export_functions_group_scc (fmt : Format.formatter) (config : gen_config)
  *)
 let export_functions_group (fmt : Format.formatter) (config : gen_config)
     (ctx : gen_ctx) (pure_ls : pure_fun_translation list) : unit =
-  (* Utility to check a function has a decrease clause *)
-  let has_decreases_clause (def : Pure.fun_decl) : bool =
-    PureUtils.FunLoopIdSet.mem (def.def_id, def.loop_id)
-      ctx.functions_with_decreases_clause
+  (* Check if the definition are builtin - if yes they must be ignored.
+     Note that if one definition in the group is builtin, then all the
+     definitions must be builtin *)
+  let builtin =
+    let open ExtractBuiltin in
+    let funs_map = builtin_funs_map () in
+    List.map
+      (fun (trans : pure_fun_translation) ->
+        let sname = name_to_simple_name trans.fwd.f.basename in
+        SimpleNameMap.find_opt sname funs_map <> None)
+      pure_ls
   in
 
-  (* Extract the decrease clauses template bodies *)
-  if config.extract_template_decreases_clauses then
-    List.iter
-      (fun { fwd; _ } ->
-        (* We only generate decreases clauses for the forward functions, because
-           the termination argument should only depend on the forward inputs.
-           The backward functions thus use the same decreases clauses as the
-           forward function.
-
-           Rem.: we might filter backward functions in {!PureMicroPasses}, but
-           we don't remove forward functions. Instead, we remember if we should
-           filter those functions at extraction time with a boolean (see the
-           type of the [pure_ls] input parameter).
-        *)
-        let extract_decrease decl =
-          let has_decr_clause = has_decreases_clause decl in
-          if has_decr_clause then
-            match !Config.backend with
-            | Lean ->
-                Extract.extract_template_lean_termination_and_decreasing ctx fmt
-                  decl
-            | FStar ->
-                Extract.extract_template_fstar_decreases_clause ctx fmt decl
-            | Coq ->
-                raise (Failure "Coq doesn't have decreases/termination clauses")
-            | HOL4 ->
-                raise
-                  (Failure "HOL4 doesn't have decreases/termination clauses")
-        in
-        extract_decrease fwd.f;
-        List.iter extract_decrease fwd.loops)
-      pure_ls;
-
-  (* Concatenate the function definitions, filtering the useless forward
-   * functions. *)
-  let decls =
-    List.concat
-      (List.map
-         (fun { keep_fwd; fwd; backs } ->
-           let fwd = if keep_fwd then List.append fwd.loops [ fwd.f ] else [] in
-           let backs : Pure.fun_decl list =
-             List.concat
-               (List.map (fun back -> List.append back.loops [ back.f ]) backs)
-           in
-           List.append fwd backs)
-         pure_ls)
-  in
+  if List.exists (fun b -> b) builtin then
+    (* Sanity check *)
+    assert (List.for_all (fun b -> b) builtin)
+  else
+    (* Utility to check a function has a decrease clause *)
+    let has_decreases_clause (def : Pure.fun_decl) : bool =
+      PureUtils.FunLoopIdSet.mem (def.def_id, def.loop_id)
+        ctx.functions_with_decreases_clause
+    in
+
+    (* Extract the decrease clauses template bodies *)
+    if config.extract_template_decreases_clauses then
+      List.iter
+        (fun { fwd; _ } ->
+          (* We only generate decreases clauses for the forward functions, because
+             the termination argument should only depend on the forward inputs.
+             The backward functions thus use the same decreases clauses as the
+             forward function.
+
+             Rem.: we might filter backward functions in {!PureMicroPasses}, but
+             we don't remove forward functions. Instead, we remember if we should
+             filter those functions at extraction time with a boolean (see the
+             type of the [pure_ls] input parameter).
+          *)
+          let extract_decrease decl =
+            let has_decr_clause = has_decreases_clause decl in
+            if has_decr_clause then
+              match !Config.backend with
+              | Lean ->
+                  Extract.extract_template_lean_termination_and_decreasing ctx
+                    fmt decl
+              | FStar ->
+                  Extract.extract_template_fstar_decreases_clause ctx fmt decl
+              | Coq ->
+                  raise
+                    (Failure "Coq doesn't have decreases/termination clauses")
+              | HOL4 ->
+                  raise
+                    (Failure "HOL4 doesn't have decreases/termination clauses")
+          in
+          extract_decrease fwd.f;
+          List.iter extract_decrease fwd.loops)
+        pure_ls;
+
+    (* Concatenate the function definitions, filtering the useless forward
+     * functions. *)
+    let decls =
+      List.concat
+        (List.map
+           (fun { keep_fwd; fwd; backs } ->
+             let fwd =
+               if keep_fwd then List.append fwd.loops [ fwd.f ] else []
+             in
+             let backs : Pure.fun_decl list =
+               List.concat
+                 (List.map
+                    (fun back -> List.append back.loops [ back.f ])
+                    backs)
+             in
+             List.append fwd backs)
+           pure_ls)
+    in
 
-  (* Extract the function definitions *)
-  (if config.extract_fun_decls then
-     (* Group the mutually recursive definitions *)
-     let subgroups = ReorderDecls.group_reorder_fun_decls decls in
+    (* Extract the function definitions *)
+    (if config.extract_fun_decls then
+       (* Group the mutually recursive definitions *)
+       let subgroups = ReorderDecls.group_reorder_fun_decls decls in
 
-     (* Extract the subgroups *)
-     let export_subgroup (is_rec : bool) (decls : Pure.fun_decl list) : unit =
-       export_functions_group_scc fmt config ctx is_rec decls
-     in
-     List.iter (fun (is_rec, decls) -> export_subgroup is_rec decls) subgroups);
-
-  (* Insert unit tests if necessary *)
-  if config.test_trans_unit_functions then
-    List.iter
-      (fun trans ->
-        if trans.keep_fwd then
-          Extract.extract_unit_test_if_unit_fun ctx fmt trans.fwd.f)
-      pure_ls
+       (* Extract the subgroups *)
+       let export_subgroup (is_rec : bool) (decls : Pure.fun_decl list) : unit =
+         export_functions_group_scc fmt config ctx is_rec decls
+       in
+       List.iter (fun (is_rec, decls) -> export_subgroup is_rec decls) subgroups);
+
+    (* Insert unit tests if necessary *)
+    if config.test_trans_unit_functions then
+      List.iter
+        (fun trans ->
+          if trans.keep_fwd then
+            Extract.extract_unit_test_if_unit_fun ctx fmt trans.fwd.f)
+        pure_ls
 
 (** Export a trait declaration. *)
 let export_trait_decl (fmt : Format.formatter) (_config : gen_config)
-- 
cgit v1.3.1


From be70eed487b507dc002660a4c891397003165e75 Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Tue, 24 Oct 2023 15:01:55 +0200
Subject: Add support for builtin trait implementations

---
 compiler/Extract.ml        | 32 ++++++++++++++++++++++++++++++--
 compiler/ExtractBase.ml    | 17 -----------------
 compiler/ExtractBuiltin.ml | 34 ++++++++++++++++++++++++++++++++++
 compiler/Translate.ml      | 17 ++++++++++++++++-
 4 files changed, 80 insertions(+), 20 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/compiler/Extract.ml b/compiler/Extract.ml
index ddc02fa7..a1c9605b 100644
--- a/compiler/Extract.ml
+++ b/compiler/Extract.ml
@@ -4320,7 +4320,15 @@ let extract_trait_decl_register_names (ctx : extraction_ctx)
   let builtin_info =
     SimpleNameMap.find_opt sname (builtin_trait_decls_map ())
   in
-  let ctx = ctx_add_trait_decl trait_decl ctx in
+  let ctx =
+    let trait_name =
+      match builtin_info with
+      | None -> ctx.fmt.trait_decl_name trait_decl
+      | Some info -> info.extract_name
+    in
+    let is_opaque = false in
+    ctx_add is_opaque (TraitDeclId trait_decl.def_id) trait_name ctx
+  in
   (* Parent clauses *)
   let ctx =
     extract_trait_decl_register_parent_clause_names ctx trait_decl builtin_info
@@ -4338,11 +4346,31 @@ let extract_trait_decl_register_names (ctx : extraction_ctx)
 (** Similar to {!extract_type_decl_register_names} *)
 let extract_trait_impl_register_names (ctx : extraction_ctx)
     (trait_impl : trait_impl) : extraction_ctx =
+  let trait_decl =
+    TraitDeclId.Map.find trait_impl.impl_trait.trait_decl_id
+      ctx.trans_trait_decls
+  in
+  (* Check if the trait implementation is builtin *)
+  let builtin_info =
+    let open ExtractBuiltin in
+    let type_sname = name_to_simple_name trait_impl.name in
+    let trait_sname = name_to_simple_name trait_decl.name in
+    SimpleNamePairMap.find_opt (type_sname, trait_sname)
+      (builtin_trait_impls_map ())
+  in
+
   (* For now we do not support overriding provided methods *)
   assert (trait_impl.provided_methods = []);
   (* Everything is taken care of by {!extract_trait_decl_register_names} *but*
      the name of the implementation itself *)
-  ctx_add_trait_impl trait_impl ctx
+  (* Compute the name *)
+  let name =
+    match builtin_info with
+    | None -> ctx.fmt.trait_impl_name trait_decl trait_impl
+    | Some name -> name
+  in
+  let is_opaque = false in
+  ctx_add is_opaque (TraitImplId trait_impl.def_id) name ctx
 
 (** Small helper.
 
diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index 22b017e5..3ff299f2 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -1272,23 +1272,6 @@ let ctx_add_fun_decl (trans_group : pure_fun_translation) (def : fun_decl)
         ctx.fun_name_info;
   }
 
-let ctx_add_trait_decl (d : trait_decl) (ctx : extraction_ctx) : extraction_ctx
-    =
-  let is_opaque = false in
-  let name = ctx.fmt.trait_decl_name d in
-  ctx_add is_opaque (TraitDeclId d.def_id) name ctx
-
-let ctx_add_trait_impl (d : trait_impl) (ctx : extraction_ctx) : extraction_ctx
-    =
-  (* We need to lookup the trait decl that is implemented by the trait impl *)
-  let decl =
-    Pure.TraitDeclId.Map.find d.impl_trait.trait_decl_id ctx.trans_trait_decls
-  in
-  (* Compute the name *)
-  let is_opaque = false in
-  let name = ctx.fmt.trait_impl_name decl d in
-  ctx_add is_opaque (TraitImplId d.def_id) name ctx
-
 type names_map_init = {
   keywords : string list;
   assumed_adts : (assumed_ty * string) list;
diff --git a/compiler/ExtractBuiltin.ml b/compiler/ExtractBuiltin.ml
index 0d591028..d3cea54e 100644
--- a/compiler/ExtractBuiltin.ml
+++ b/compiler/ExtractBuiltin.ml
@@ -517,3 +517,37 @@ let mk_builtin_trait_decls_map () =
        (builtin_trait_decls_info ()))
 
 let builtin_trait_decls_map = mk_memoized mk_builtin_trait_decls_map
+
+(* TODO: generalize this.
+
+   For now, the key is:
+   - name of the impl (ex.: "alloc.boxed.Boxed")
+   - name of the implemented trait (ex.: "core.ops.deref.Deref"
+*)
+type simple_name_pair = simple_name * simple_name [@@deriving show, ord]
+
+module SimpleNamePairOrd = struct
+  type t = simple_name_pair
+
+  let compare = compare_simple_name_pair
+  let to_string = show_simple_name_pair
+  let pp_t = pp_simple_name_pair
+  let show_t = show_simple_name_pair
+end
+
+module SimpleNamePairMap = Collections.MakeMap (SimpleNamePairOrd)
+
+let builtin_trait_impls_info () : ((string list * string list) * string) list =
+  [
+    (* core::ops::Deref<alloc::boxed::Box<T>> *)
+    ( ([ "alloc"; "boxed"; "Box" ], [ "core"; "ops"; "deref"; "Deref" ]),
+      "alloc.boxed.Box.coreOpsDerefInst" );
+    (* core::ops::DerefMut<alloc::boxed::Box<T>> *)
+    ( ([ "alloc"; "boxed"; "Box" ], [ "core"; "ops"; "deref"; "DerefMut" ]),
+      "alloc.boxed.Box.coreOpsDerefMutInst" );
+  ]
+
+let mk_builtin_trait_impls_map () =
+  SimpleNamePairMap.of_list (builtin_trait_impls_info ())
+
+let builtin_trait_impls_map = mk_memoized mk_builtin_trait_impls_map
diff --git a/compiler/Translate.ml b/compiler/Translate.ml
index 95252b61..74a8537f 100644
--- a/compiler/Translate.ml
+++ b/compiler/Translate.ml
@@ -764,8 +764,23 @@ let export_trait_decl (fmt : Format.formatter) (_config : gen_config)
 (** Export a trait implementation. *)
 let export_trait_impl (fmt : Format.formatter) (_config : gen_config)
     (ctx : gen_ctx) (trait_impl_id : Pure.trait_impl_id) : unit =
+  (* Lookup the definition *)
   let trait_impl = T.TraitImplId.Map.find trait_impl_id ctx.trans_trait_impls in
-  Extract.extract_trait_impl ctx fmt trait_impl
+  let trait_decl =
+    Pure.TraitDeclId.Map.find trait_impl.impl_trait.trait_decl_id
+      ctx.trans_trait_decls
+  in
+  (* Check if the trait implementation is builtin *)
+  let builtin_info =
+    let open ExtractBuiltin in
+    let type_sname = name_to_simple_name trait_impl.name in
+    let trait_sname = name_to_simple_name trait_decl.name in
+    SimpleNamePairMap.find_opt (type_sname, trait_sname)
+      (builtin_trait_impls_map ())
+  in
+  match builtin_info with
+  | None -> Extract.extract_trait_impl ctx fmt trait_impl
+  | Some _ -> ()
 
 (** A generic utility to generate the extracted definitions: as we may want to
     split the definitions between different files (or not), we can control
-- 
cgit v1.3.1


From b631875f8166b3db81187a179eef2f21f52db2bd Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Tue, 24 Oct 2023 15:26:41 +0200
Subject: Remove the possibility of generating opaque module signatures

---
 compiler/Config.ml      |   7 --
 compiler/Extract.ml     | 167 +++++++++++-----------------------
 compiler/ExtractBase.ml | 233 ++++++++++++------------------------------------
 compiler/Translate.ml   |  34 +------
 4 files changed, 111 insertions(+), 330 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/compiler/Config.ml b/compiler/Config.ml
index 62f6c300..cd0903b6 100644
--- a/compiler/Config.ml
+++ b/compiler/Config.ml
@@ -306,13 +306,6 @@ let filter_useless_monadic_calls = ref true
  *)
 let filter_useless_functions = ref true
 
-(** Obsolete. TODO: remove.
-
-    For Lean we used to parameterize the entire development by a section variable
-    called opaque_defs, of type OpaqueDefs.
-  *)
-let wrap_opaque_in_sig = ref false
-
 (** Use short names for the record fields.
 
     Some backends can't disambiguate records when their field names have collisions.
diff --git a/compiler/Extract.ml b/compiler/Extract.ml
index a1c9605b..275cb3b9 100644
--- a/compiler/Extract.ml
+++ b/compiler/Extract.ml
@@ -758,12 +758,6 @@ let mk_formatter (ctx : trans_ctx) (crate_name : string)
     fname ^ lp_suffix ^ suffix
   in
 
-  let opaque_pre () =
-    match !Config.backend with
-    | FStar | Coq | HOL4 -> ""
-    | Lean -> if !Config.wrap_opaque_in_sig then "opaque_defs." else ""
-  in
-
   let var_basename (_varset : StringSet.t) (basename : string option) (ty : ty)
       : string =
     (* Small helper to derive var names from ADT type names.
@@ -934,7 +928,6 @@ let mk_formatter (ctx : trans_ctx) (crate_name : string)
     trait_type_name;
     trait_method_name;
     trait_type_clause_name;
-    opaque_pre;
     var_basename;
     type_var_basename;
     const_generic_var_basename;
@@ -983,11 +976,8 @@ let start_fun_decl_group (ctx : extraction_ctx) (fmt : F.formatter)
       (* In HOL4, opaque functions have a special treatment *)
       if is_single_opaque_fun_decl_group dg then ()
       else
-        let with_opaque_pre = false in
         let compute_fun_def_name (def : Pure.fun_decl) : string =
-          ctx_get_local_function with_opaque_pre def.def_id def.loop_id
-            def.back_id ctx
-          ^ "_def"
+          ctx_get_local_function def.def_id def.loop_id def.back_id ctx ^ "_def"
         in
         let names = List.map compute_fun_def_name dg in
         (* Add a break before *)
@@ -1110,7 +1100,7 @@ let extract_const_generic (ctx : extraction_ctx) (fmt : F.formatter)
     (inside : bool) (cg : const_generic) : unit =
   match cg with
   | ConstGenericGlobal id ->
-      let s = ctx_get_global ctx.use_opaque_pre id ctx in
+      let s = ctx_get_global id ctx in
       F.pp_print_string fmt s
   | ConstGenericValue v -> ctx.fmt.extract_literal fmt inside v
   | ConstGenericVar id ->
@@ -1178,14 +1168,13 @@ let rec extract_ty (ctx : extraction_ctx) (fmt : F.formatter)
              In HOL4 we would write:
              `('a, 'b) tree`
           *)
-          let with_opaque_pre = false in
           match !backend with
           | FStar | Coq | Lean ->
               let print_paren = inside && has_params in
               if print_paren then F.pp_print_string fmt "(";
               (* TODO: for now, only the opaque *functions* are extracted in the
                  opaque module. The opaque *types* are assumed. *)
-              F.pp_print_string fmt (ctx_get_type with_opaque_pre type_id ctx);
+              F.pp_print_string fmt (ctx_get_type type_id ctx);
               extract_generic_args ctx fmt no_params_tys generics;
               if print_paren then F.pp_print_string fmt ")"
           | HOL4 ->
@@ -1208,7 +1197,7 @@ let rec extract_ty (ctx : extraction_ctx) (fmt : F.formatter)
                   (extract_rec true) types;
                 if print_paren then F.pp_print_string fmt ")";
                 F.pp_print_space fmt ());
-              F.pp_print_string fmt (ctx_get_type with_opaque_pre type_id ctx);
+              F.pp_print_string fmt (ctx_get_type type_id ctx);
               if trait_refs <> [] then (
                 F.pp_print_space fmt ();
                 Collections.List.iter_link (F.pp_print_space fmt)
@@ -1273,8 +1262,7 @@ and extract_trait_decl_ref (ctx : extraction_ctx) (fmt : F.formatter)
     (no_params_tys : TypeDeclId.Set.t) (inside : bool) (tr : trait_decl_ref) :
     unit =
   let use_brackets = tr.decl_generics <> empty_generic_args && inside in
-  let is_opaque = false in
-  let name = ctx_get_trait_decl is_opaque tr.trait_decl_id ctx in
+  let name = ctx_get_trait_decl tr.trait_decl_id ctx in
   if use_brackets then F.pp_print_string fmt "(";
   F.pp_print_string fmt name;
   (* There is something subtle here: the trait obligations for the implemented
@@ -1307,14 +1295,13 @@ and extract_generic_args (ctx : extraction_ctx) (fmt : F.formatter)
 and extract_trait_instance_id (ctx : extraction_ctx) (fmt : F.formatter)
     (no_params_tys : TypeDeclId.Set.t) (inside : bool) (id : trait_instance_id)
     : unit =
-  let with_opaque_pre = false in
   match id with
   | Self ->
       (* This has specific treatment depending on the item we're extracting
          (associated type, etc.). We should have caught this elsewhere. *)
       raise (Failure "Unexpected")
   | TraitImpl id ->
-      let name = ctx_get_trait_impl with_opaque_pre id ctx in
+      let name = ctx_get_trait_impl id ctx in
       F.pp_print_string fmt name
   | Clause id ->
       let name = ctx_get_local_trait_clause id ctx in
@@ -1354,8 +1341,7 @@ let extract_type_decl_register_names (ctx : extraction_ctx) (def : type_decl) :
     | None -> ctx.fmt.type_name def.name
     | Some info -> String.concat "." info.rust_name
   in
-  let is_opaque = def.kind = Opaque in
-  let ctx = ctx_add is_opaque (TypeId (AdtId def.def_id)) def_name ctx in
+  let ctx = ctx_add (TypeId (AdtId def.def_id)) def_name ctx in
   (* Compute and register:
    * - the variant names, if this is an enumeration
    * - the field names, if this is a structure
@@ -1392,11 +1378,11 @@ let extract_type_decl_register_names (ctx : extraction_ctx) (def : type_decl) :
         let ctx =
           List.fold_left
             (fun ctx (fid, name) ->
-              ctx_add is_opaque (FieldId (AdtId def.def_id, fid)) name ctx)
+              ctx_add (FieldId (AdtId def.def_id, fid)) name ctx)
             ctx field_names
         in
         (* Add the constructor name *)
-        ctx_add is_opaque (StructId (AdtId def.def_id)) cons_name ctx
+        ctx_add (StructId (AdtId def.def_id)) cons_name ctx
     | Enum variants ->
         let variant_names =
           match info with
@@ -1432,7 +1418,7 @@ let extract_type_decl_register_names (ctx : extraction_ctx) (def : type_decl) :
         in
         List.fold_left
           (fun ctx (vid, vname) ->
-            ctx_add is_opaque (VariantId (AdtId def.def_id, vid)) vname ctx)
+            ctx_add (VariantId (AdtId def.def_id, vid)) vname ctx)
           ctx variant_names
     | Opaque ->
         (* Nothing to do *)
@@ -1635,9 +1621,7 @@ let extract_type_decl_struct_body (ctx : extraction_ctx) (fmt : F.formatter)
       (* If Coq: print the constructor name *)
       (* TODO: remove superfluous test not is_rec below *)
       if !backend = Coq && not is_rec then (
-        let with_opaque_pre = false in
-        F.pp_print_string fmt
-          (ctx_get_struct with_opaque_pre (AdtId def.def_id) ctx);
+        F.pp_print_string fmt (ctx_get_struct (AdtId def.def_id) ctx);
         F.pp_print_string fmt " ");
       (match !backend with
       | Lean -> ()
@@ -1681,16 +1665,14 @@ let extract_type_decl_struct_body (ctx : extraction_ctx) (fmt : F.formatter)
       (* We extract for Coq or Lean, and we have a recursive record, or a record in
          a group of mutually recursive types: we extract it as an inductive type *)
       assert (is_rec && (!backend = Coq || !backend = Lean));
-      let with_opaque_pre = false in
       (* Small trick: in Lean we use namespaces, meaning we don't need to prefix
          the constructor name with the name of the type at definition site,
          i.e., instead of generating `inductive Foo := | MkFoo ...` like in Coq
          we generate `inductive Foo := | mk ... *)
       let cons_name =
-        if !backend = Lean then "mk"
-        else ctx_get_struct with_opaque_pre (AdtId def.def_id) ctx
+        if !backend = Lean then "mk" else ctx_get_struct (AdtId def.def_id) ctx
       in
-      let def_name = ctx_get_local_type with_opaque_pre def.def_id ctx in
+      let def_name = ctx_get_local_type def.def_id ctx in
       extract_type_decl_variant ctx fmt type_decl_group def_name type_params
         cg_params cons_name fields)
   in
@@ -1720,8 +1702,7 @@ let extract_comment (fmt : F.formatter) (sl : string list) : unit =
 
 let extract_trait_clause_type (ctx : extraction_ctx) (fmt : F.formatter)
     (no_params_tys : TypeDeclId.Set.t) (clause : trait_clause) : unit =
-  let with_opaque_pre = false in
-  let trait_name = ctx_get_trait_decl with_opaque_pre clause.trait_id ctx in
+  let trait_name = ctx_get_trait_decl clause.trait_id ctx in
   F.pp_print_string fmt trait_name;
   extract_generic_args ctx fmt no_params_tys clause.generics
 
@@ -1743,8 +1724,7 @@ let extract_trait_self_clause (insert_req_space : unit -> unit)
   F.pp_print_space fmt ();
   F.pp_print_string fmt ":";
   F.pp_print_space fmt ();
-  let with_opaque_pre = false in
-  let trait_id = ctx_get_trait_decl with_opaque_pre trait_decl.def_id ctx in
+  let trait_id = ctx_get_trait_decl trait_decl.def_id ctx in
   F.pp_print_string fmt trait_id;
   List.iter
     (fun p ->
@@ -1913,8 +1893,7 @@ let extract_type_decl_gen (ctx : extraction_ctx) (fmt : F.formatter)
   let is_opaque_coq = !backend = Coq && is_opaque in
   let use_forall = is_opaque_coq && def.generics <> empty_generic_params in
   (* Retrieve the definition name *)
-  let with_opaque_pre = false in
-  let def_name = ctx_get_local_type with_opaque_pre def.def_id ctx in
+  let def_name = ctx_get_local_type def.def_id ctx in
   (* Add the type and const generic params - note that we need those bindings only for the
    * body translation (they are not top-level) *)
   let ctx_body, type_params, cg_params, trait_clauses =
@@ -2001,8 +1980,7 @@ let extract_type_decl_gen (ctx : extraction_ctx) (fmt : F.formatter)
 let extract_type_decl_hol4_opaque (ctx : extraction_ctx) (fmt : F.formatter)
     (def : type_decl) : unit =
   (* Retrieve the definition name *)
-  let with_opaque_pre = false in
-  let def_name = ctx_get_local_type with_opaque_pre def.def_id ctx in
+  let def_name = ctx_get_local_type def.def_id ctx in
   (* Generic parameters are unsupported *)
   assert (def.generics.const_generics = []);
   (* Trait clauses on type definitions are unsupported *)
@@ -2027,8 +2005,7 @@ let extract_type_decl_hol4_opaque (ctx : extraction_ctx) (fmt : F.formatter)
 let extract_type_decl_hol4_empty_record (ctx : extraction_ctx)
     (fmt : F.formatter) (def : type_decl) : unit =
   (* Retrieve the definition name *)
-  let with_opaque_pre = false in
-  let def_name = ctx_get_local_type with_opaque_pre def.def_id ctx in
+  let def_name = ctx_get_local_type def.def_id ctx in
   (* Sanity check *)
   assert (def.generics = empty_generic_params);
   (* Generate the declaration *)
@@ -2111,8 +2088,7 @@ let extract_type_decl_coq_arguments (ctx : extraction_ctx) (fmt : F.formatter)
     | Struct fields ->
         let adt_id = AdtId decl.def_id in
         (* Generate the instruction for the record constructor *)
-        let with_opaque_pre = false in
-        let cons_name = ctx_get_struct with_opaque_pre adt_id ctx in
+        let cons_name = ctx_get_struct adt_id ctx in
         extract_arguments_info cons_name fields;
         (* Generate the instruction for the record projectors, if there are *)
         let is_rec = decl_is_from_rec_group kind in
@@ -2156,11 +2132,8 @@ let extract_type_decl_record_field_projectors (ctx : extraction_ctx)
         in
         let ctx, record_var = ctx_add_var "x" (VarId.of_int 0) ctx in
         let ctx, field_var = ctx_add_var "x" (VarId.of_int 1) ctx in
-        let with_opaque_pre = false in
-        let def_name = ctx_get_local_type with_opaque_pre decl.def_id ctx in
-        let cons_name =
-          ctx_get_struct with_opaque_pre (AdtId decl.def_id) ctx
-        in
+        let def_name = ctx_get_local_type decl.def_id ctx in
+        let cons_name = ctx_get_struct (AdtId decl.def_id) ctx in
         let extract_field_proj (field_id : FieldId.id) (_ : field) : unit =
           F.pp_print_space fmt ();
           (* Outer box for the projector definition *)
@@ -2391,7 +2364,6 @@ let extract_fun_decl_register_names (ctx : extraction_ctx)
       | Some (_filter, info) ->
           let backs = List.map (fun f -> f.f) def.backs in
           let funs = if def.keep_fwd then def.fwd.f :: backs else backs in
-          let is_opaque = false in
           List.fold_left
             (fun ctx (f : fun_decl) ->
               let open ExtractBuiltin in
@@ -2404,7 +2376,7 @@ let extract_fun_decl_register_names (ctx : extraction_ctx)
                    info)
                   .extract_name
               in
-              ctx_add is_opaque (FunId (FromLlbc fun_id)) fun_name ctx)
+              ctx_add (FunId (FromLlbc fun_id)) fun_name ctx)
             ctx funs
       | None ->
           let fwd = def.fwd in
@@ -2509,18 +2481,14 @@ let extract_adt_g_value
          * [{ field0=...; ...; fieldn=...; }] in case of structures.
          *)
         let cons =
-          (* The ADT shouldn't be opaque *)
-          let with_opaque_pre = false in
           match variant_id with
           | Some vid -> (
               (* In the case of Lean, we might have to add the type name as a prefix *)
               match (!backend, adt_id) with
               | Lean, Assumed _ ->
-                  ctx_get_type with_opaque_pre adt_id ctx
-                  ^ "."
-                  ^ ctx_get_variant adt_id vid ctx
+                  ctx_get_type adt_id ctx ^ "." ^ ctx_get_variant adt_id vid ctx
               | _ -> ctx_get_variant adt_id vid ctx)
-          | None -> ctx_get_struct with_opaque_pre adt_id ctx
+          | None -> ctx_get_struct adt_id ctx
         in
         let use_parentheses = inside && field_values <> [] in
         if use_parentheses then F.pp_print_string fmt "(";
@@ -2539,8 +2507,7 @@ let extract_adt_g_value
 (* Extract globals in the same way as variables *)
 let extract_global (ctx : extraction_ctx) (fmt : F.formatter)
     (id : A.GlobalDeclId.id) : unit =
-  let with_opaque_pre = ctx.use_opaque_pre in
-  F.pp_print_string fmt (ctx_get_global with_opaque_pre id ctx)
+  F.pp_print_string fmt (ctx_get_global id ctx)
 
 (** [inside]: see {!extract_ty}.
 
@@ -2676,9 +2643,9 @@ and extract_function_call (ctx : extraction_ctx) (fmt : F.formatter)
       if inside then F.pp_print_string fmt "(";
       (* Open a box for the function call *)
       F.pp_open_hovbox fmt ctx.indent_incr;
-      (* Print the function name *)
-      let with_opaque_pre = ctx.use_opaque_pre in
-      (* For the function name: the id is not the same depending on whether
+      (* Print the function name.
+
+         For the function name: the id is not the same depending on whether
          we call a trait method and a "regular" function (remark: trait
          method *implementations* are considered as regular functions here;
          only calls to method of traits which are parameterized in a where
@@ -2751,7 +2718,7 @@ and extract_function_call (ctx : extraction_ctx) (fmt : F.formatter)
             let fun_id =
               FromLlbc (FunId (Regular method_id.id), lp_id, rg_id)
             in
-            let fun_name = ctx_get_function with_opaque_pre fun_id ctx in
+            let fun_name = ctx_get_function fun_id ctx in
             F.pp_print_string fmt fun_name;
 
             (* Note that we do not need to print the generics for the trait
@@ -2762,7 +2729,7 @@ and extract_function_call (ctx : extraction_ctx) (fmt : F.formatter)
             F.pp_print_space fmt ();
             extract_trait_ref ctx fmt TypeDeclId.Set.empty true trait_ref
       | _ ->
-          let fun_name = ctx_get_function with_opaque_pre fun_id ctx in
+          let fun_name = ctx_get_function fun_id ctx in
           F.pp_print_string fmt fun_name);
 
       (* Sanity check: HOL4 doesn't support const generics *)
@@ -3260,7 +3227,7 @@ and extract_StructUpdate (ctx : extraction_ctx) (fmt : F.formatter)
         (* Open the box for `Array.replicate T N [` *)
         F.pp_open_hovbox fmt ctx.indent_incr;
         (* Print the array constructor *)
-        let cs = ctx_get_struct false (Assumed Array) ctx in
+        let cs = ctx_get_struct (Assumed Array) ctx in
         F.pp_print_string fmt cs;
         (* Print the parameters *)
         let _, generics = ty_as_adt e_ty in
@@ -3613,10 +3580,8 @@ let extract_fun_decl_gen (ctx : extraction_ctx) (fmt : F.formatter)
     (kind : decl_kind) (has_decreases_clause : bool) (def : fun_decl) : unit =
   assert (not def.is_global_decl_body);
   (* Retrieve the function name *)
-  let with_opaque_pre = false in
   let def_name =
-    ctx_get_local_function with_opaque_pre def.def_id def.loop_id def.back_id
-      ctx
+    ctx_get_local_function def.def_id def.loop_id def.back_id ctx
   in
   (* Add a break before *)
   if !backend <> HOL4 || not (decl_is_first_from_group kind) then
@@ -3649,8 +3614,7 @@ let extract_fun_decl_gen (ctx : extraction_ctx) (fmt : F.formatter)
      if `wrap_opaque_in_sig`: we generate a record of assumed funcions.
      TODO: this is obsolete.
   *)
-  (if not (!Config.wrap_opaque_in_sig && (kind = Assumed || kind = Declared))
-   then
+  (if not (kind = Assumed || kind = Declared) then
      let qualif = ctx.fmt.fun_decl_kind_to_qualif kind in
      match qualif with
      | Some qualif ->
@@ -3867,10 +3831,8 @@ let extract_fun_decl_gen (ctx : extraction_ctx) (fmt : F.formatter)
 let extract_fun_decl_hol4_opaque (ctx : extraction_ctx) (fmt : F.formatter)
     (def : fun_decl) : unit =
   (* Retrieve the definition name *)
-  let with_opaque_pre = false in
   let def_name =
-    ctx_get_local_function with_opaque_pre def.def_id def.loop_id def.back_id
-      ctx
+    ctx_get_local_function def.def_id def.loop_id def.back_id ctx
   in
   assert (def.signature.generics.const_generics = []);
   (* Add the type/const gen parameters - note that we need those bindings
@@ -4065,10 +4027,9 @@ let extract_global_decl (ctx : extraction_ctx) (fmt : F.formatter)
   extract_comment fmt [ "[" ^ Print.global_name_to_string global.name ^ "]" ];
   F.pp_print_space fmt ();
 
-  let with_opaque_pre = false in
-  let decl_name = ctx_get_global with_opaque_pre global.def_id ctx in
+  let decl_name = ctx_get_global global.def_id ctx in
   let body_name =
-    ctx_get_function with_opaque_pre
+    ctx_get_function
       (FromLlbc (Pure.FunId (Regular global.body_id), None, None))
       ctx
   in
@@ -4111,7 +4072,6 @@ let extract_trait_decl_register_parent_clause_names (ctx : extraction_ctx)
     (trait_decl : trait_decl)
     (builtin_info : ExtractBuiltin.builtin_trait_decl_info option) :
     extraction_ctx =
-  let is_opaque = false in
   let generics = trait_decl.generics in
   (* Compute the clause names *)
   let clause_names =
@@ -4135,7 +4095,7 @@ let extract_trait_decl_register_parent_clause_names (ctx : extraction_ctx)
   (* Register the names *)
   List.fold_left
     (fun ctx (cid, cname) ->
-      ctx_add is_opaque (TraitParentClauseId (trait_decl.def_id, cid)) cname ctx)
+      ctx_add (TraitParentClauseId (trait_decl.def_id, cid)) cname ctx)
     ctx clause_names
 
 (** Similar to {!extract_trait_decl_register_names} *)
@@ -4143,7 +4103,6 @@ let extract_trait_decl_register_constant_names (ctx : extraction_ctx)
     (trait_decl : trait_decl)
     (builtin_info : ExtractBuiltin.builtin_trait_decl_info option) :
     extraction_ctx =
-  let is_opaque = false in
   let consts = trait_decl.consts in
   (* Compute the names *)
   let constant_names =
@@ -4169,7 +4128,7 @@ let extract_trait_decl_register_constant_names (ctx : extraction_ctx)
   (* Register the names *)
   List.fold_left
     (fun ctx (item_name, name) ->
-      ctx_add is_opaque (TraitItemId (trait_decl.def_id, item_name)) name ctx)
+      ctx_add (TraitItemId (trait_decl.def_id, item_name)) name ctx)
     ctx constant_names
 
 (** Similar to {!extract_trait_decl_register_names} *)
@@ -4177,7 +4136,6 @@ let extract_trait_decl_type_names (ctx : extraction_ctx)
     (trait_decl : trait_decl)
     (builtin_info : ExtractBuiltin.builtin_trait_decl_info option) :
     extraction_ctx =
-  let is_opaque = false in
   let types = trait_decl.types in
   (* Compute the names *)
   let type_names =
@@ -4227,13 +4185,11 @@ let extract_trait_decl_type_names (ctx : extraction_ctx)
   List.fold_left
     (fun ctx (item_name, (type_name, clauses)) ->
       let ctx =
-        ctx_add is_opaque
-          (TraitItemId (trait_decl.def_id, item_name))
-          type_name ctx
+        ctx_add (TraitItemId (trait_decl.def_id, item_name)) type_name ctx
       in
       List.fold_left
         (fun ctx (clause_id, clause_name) ->
-          ctx_add is_opaque
+          ctx_add
             (TraitItemClauseId (trait_decl.def_id, item_name, clause_id))
             clause_name ctx)
         ctx clauses)
@@ -4244,7 +4200,6 @@ let extract_trait_decl_method_names (ctx : extraction_ctx)
     (trait_decl : trait_decl)
     (builtin_info : ExtractBuiltin.builtin_trait_decl_info option) :
     extraction_ctx =
-  let is_opaque = false in
   let required_methods = trait_decl.required_methods in
   (* Compute the names *)
   let method_names =
@@ -4305,7 +4260,7 @@ let extract_trait_decl_method_names (ctx : extraction_ctx)
       (* We add one field per required forward/backward function *)
       List.fold_left
         (fun ctx (rg, fun_name) ->
-          ctx_add is_opaque
+          ctx_add
             (TraitMethodId (trait_decl.def_id, item_name, rg))
             fun_name ctx)
         ctx funs)
@@ -4326,8 +4281,7 @@ let extract_trait_decl_register_names (ctx : extraction_ctx)
       | None -> ctx.fmt.trait_decl_name trait_decl
       | Some info -> info.extract_name
     in
-    let is_opaque = false in
-    ctx_add is_opaque (TraitDeclId trait_decl.def_id) trait_name ctx
+    ctx_add (TraitDeclId trait_decl.def_id) trait_name ctx
   in
   (* Parent clauses *)
   let ctx =
@@ -4369,8 +4323,7 @@ let extract_trait_impl_register_names (ctx : extraction_ctx)
     | None -> ctx.fmt.trait_impl_name trait_decl trait_impl
     | Some name -> name
   in
-  let is_opaque = false in
-  ctx_add is_opaque (TraitImplId trait_impl.def_id) name ctx
+  ctx_add (TraitImplId trait_impl.def_id) name ctx
 
 (** Small helper.
 
@@ -4446,8 +4399,7 @@ let extract_trait_decl_method_items (ctx : extraction_ctx) (fmt : F.formatter)
 let extract_trait_decl (ctx : extraction_ctx) (fmt : F.formatter)
     (decl : trait_decl) : unit =
   (* Retrieve the trait name *)
-  let with_opaque_pre = false in
-  let decl_name = ctx_get_trait_decl with_opaque_pre decl.def_id ctx in
+  let decl_name = ctx_get_trait_decl decl.def_id ctx in
   (* Add a break before *)
   F.pp_print_break fmt 0 0;
   (* Print a comment to link the extracted type to its original rust definition *)
@@ -4592,7 +4544,7 @@ let extract_trait_impl_method_items (ctx : extraction_ctx) (fmt : F.formatter)
       if use_forall then F.pp_print_string fmt ",";
       (* Extract the function call *)
       F.pp_print_space fmt ();
-      let id = ctx_get_local_function false f.def_id None f.back_id ctx in
+      let id = ctx_get_local_function f.def_id None f.back_id ctx in
       F.pp_print_string fmt id;
       let all_generics =
         let i_tys, i_cgs, i_tcs = impl_generics in
@@ -4613,8 +4565,7 @@ let extract_trait_impl (ctx : extraction_ctx) (fmt : F.formatter)
     (impl : trait_impl) : unit =
   log#ldebug (lazy ("extract_trait_impl: " ^ Names.name_to_string impl.name));
   (* Retrieve the impl name *)
-  let with_opaque_pre = false in
-  let impl_name = ctx_get_trait_impl with_opaque_pre impl.def_id ctx in
+  let impl_name = ctx_get_trait_impl impl.def_id ctx in
   (* Add a break before *)
   F.pp_print_break fmt 0 0;
   (* Print a comment to link the extracted type to its original rust definition *)
@@ -4690,7 +4641,7 @@ let extract_trait_impl (ctx : extraction_ctx) (fmt : F.formatter)
       let item_name = ctx_get_trait_const trait_decl_id name ctx in
       let ty () =
         F.pp_print_space fmt ();
-        F.pp_print_string fmt (ctx_get_global false id ctx)
+        F.pp_print_string fmt (ctx_get_global id ctx)
       in
 
       extract_trait_impl_item ctx fmt item_name ty)
@@ -4776,12 +4727,8 @@ let extract_unit_test_if_unit_fun (ctx : extraction_ctx) (fmt : F.formatter)
         F.pp_print_string fmt "assert_norm";
         F.pp_print_space fmt ();
         F.pp_print_string fmt "(";
-        (* Note that if the function is opaque, the unit test will fail
-           because the normalizer will get stuck *)
-        let with_opaque_pre = ctx.use_opaque_pre in
         let fun_name =
-          ctx_get_local_function with_opaque_pre def.def_id def.loop_id
-            def.back_id ctx
+          ctx_get_local_function def.def_id def.loop_id def.back_id ctx
         in
         F.pp_print_string fmt fun_name;
         if sg.inputs <> [] then (
@@ -4796,12 +4743,8 @@ let extract_unit_test_if_unit_fun (ctx : extraction_ctx) (fmt : F.formatter)
         F.pp_print_string fmt "Check";
         F.pp_print_space fmt ();
         F.pp_print_string fmt "(";
-        (* Note that if the function is opaque, the unit test will fail
-           because the normalizer will get stuck *)
-        let with_opaque_pre = ctx.use_opaque_pre in
         let fun_name =
-          ctx_get_local_function with_opaque_pre def.def_id def.loop_id
-            def.back_id ctx
+          ctx_get_local_function def.def_id def.loop_id def.back_id ctx
         in
         F.pp_print_string fmt fun_name;
         if sg.inputs <> [] then (
@@ -4813,12 +4756,8 @@ let extract_unit_test_if_unit_fun (ctx : extraction_ctx) (fmt : F.formatter)
         F.pp_print_string fmt "#assert";
         F.pp_print_space fmt ();
         F.pp_print_string fmt "(";
-        (* Note that if the function is opaque, the unit test will fail
-           because the normalizer will get stuck *)
-        let with_opaque_pre = ctx.use_opaque_pre in
         let fun_name =
-          ctx_get_local_function with_opaque_pre def.def_id def.loop_id
-            def.back_id ctx
+          ctx_get_local_function def.def_id def.loop_id def.back_id ctx
         in
         F.pp_print_string fmt fun_name;
         if sg.inputs <> [] then (
@@ -4832,12 +4771,8 @@ let extract_unit_test_if_unit_fun (ctx : extraction_ctx) (fmt : F.formatter)
     | HOL4 ->
         F.pp_print_string fmt "val _ = assert_return (";
         F.pp_print_string fmt "“";
-        (* Note that if the function is opaque, the unit test will fail
-           because the normalizer will get stuck *)
-        let with_opaque_pre = ctx.use_opaque_pre in
         let fun_name =
-          ctx_get_local_function with_opaque_pre def.def_id def.loop_id
-            def.back_id ctx
+          ctx_get_local_function def.def_id def.loop_id def.back_id ctx
         in
         F.pp_print_string fmt fun_name;
         if sg.inputs <> [] then (
diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index 3ff299f2..f26beeb6 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -251,37 +251,6 @@ type formatter = {
   trait_type_name : trait_decl -> string -> string;
   trait_method_name : trait_decl -> string -> string;
   trait_type_clause_name : trait_decl -> string -> trait_clause -> string;
-  opaque_pre : unit -> string;
-      (** TODO: obsolete, remove.
-
-          The prefix to use for opaque definitions.
-
-          We need this because for some backends like Lean and Coq, we group
-          opaque definitions in module signatures, meaning that using those
-          definitions requires to prefix them with a module parameter name (such
-          as "opaque_defs.").
-
-          For instance, if we have an opaque function [f : int -> int], which
-          is used by the non-opaque function [g], we would generate (in Coq):
-          {[
-            (* The module signature declaring the opaque definitions *)
-            module type OpaqueDefs = {
-              f_fwd : int -> int
-              ... (* Other definitions *)
-            }
-
-            (* The definitions generated for the non-opaque definitions *)
-            module Funs (opaque: OpaqueDefs) = {
-              let g ... =
-                ...
-                opaque_defs.f_fwd
-                ...
-            }
-          ]}
-
-          Upon using [f] in [g], we don't directly use the the name "f_fwd",
-          but prefix it with the "opaque_defs." identifier.
-       *)
   var_basename : StringSet.t -> string option -> ty -> string;
       (** Generates a variable basename.
 
@@ -498,20 +467,6 @@ type names_map = {
           precisely which identifiers are mapped to the same name...
        *)
   names_set : StringSet.t;
-  opaque_ids : IdSet.t;
-      (** TODO: this is obsolete. Remove.
-
-          The set of opaque definitions.
-
-          See {!formatter.opaque_pre} for detailed explanations about why
-          we need to know which definitions are opaque to compute names.
-
-          Also note that the opaque ids don't contain the ids of the assumed
-          definitions. In practice, assumed definitions are opaque_defs. However, they
-          are not grouped in the opaque module, meaning we never need to
-          prefix them (with, say, "opaque_defs."): we thus consider them as non-opaque
-          with regards to the names map.
-       *)
 }
 
 let empty_names_map : names_map =
@@ -519,7 +474,6 @@ let empty_names_map : names_map =
     id_to_name = IdMap.empty;
     name_to_id = StringMap.empty;
     names_set = StringSet.empty;
-    opaque_ids = IdSet.empty;
   }
 
 (** Small helper to report name collision *)
@@ -547,8 +501,8 @@ let names_map_check_collision (id_to_string : id -> string) (id : id)
       (* There is a clash: print a nice debugging message for the user *)
       report_name_collision id_to_string clash id name
 
-let names_map_add (id_to_string : id -> string) (is_opaque : bool) (id : id)
-    (name : string) (nm : names_map) : names_map =
+let names_map_add (id_to_string : id -> string) (id : id) (name : string)
+    (nm : names_map) : names_map =
   (* Check if there is a clash *)
   names_map_check_collision id_to_string id name nm;
   (* Sanity check *)
@@ -564,32 +518,24 @@ let names_map_add (id_to_string : id -> string) (is_opaque : bool) (id : id)
   let id_to_name = IdMap.add id name nm.id_to_name in
   let name_to_id = StringMap.add name id nm.name_to_id in
   let names_set = StringSet.add name nm.names_set in
-  let opaque_ids =
-    if is_opaque then IdSet.add id nm.opaque_ids else nm.opaque_ids
-  in
-  { id_to_name; name_to_id; names_set; opaque_ids }
+  { id_to_name; name_to_id; names_set }
 
 let names_map_add_assumed_type (id_to_string : id -> string) (id : assumed_ty)
     (name : string) (nm : names_map) : names_map =
-  let is_opaque = false in
-  names_map_add id_to_string is_opaque (TypeId (Assumed id)) name nm
+  names_map_add id_to_string (TypeId (Assumed id)) name nm
 
 let names_map_add_assumed_struct (id_to_string : id -> string) (id : assumed_ty)
     (name : string) (nm : names_map) : names_map =
-  let is_opaque = false in
-  names_map_add id_to_string is_opaque (StructId (Assumed id)) name nm
+  names_map_add id_to_string (StructId (Assumed id)) name nm
 
 let names_map_add_assumed_variant (id_to_string : id -> string)
     (id : assumed_ty) (variant_id : VariantId.id) (name : string)
     (nm : names_map) : names_map =
-  let is_opaque = false in
-  names_map_add id_to_string is_opaque
-    (VariantId (Assumed id, variant_id))
-    name nm
+  names_map_add id_to_string (VariantId (Assumed id, variant_id)) name nm
 
-let names_map_add_function (id_to_string : id -> string) (is_opaque : bool)
-    (fid : fun_id) (name : string) (nm : names_map) : names_map =
-  names_map_add id_to_string is_opaque (FunId fid) name nm
+let names_map_add_function (id_to_string : id -> string) (fid : fun_id)
+    (name : string) (nm : names_map) : names_map =
+  names_map_add id_to_string (FunId fid) name nm
 
 (** The unsafe names map stores mappings from identifiers to names which might
     collide. For some backends and some names, it might be acceptable to have
@@ -667,14 +613,6 @@ type extraction_ctx = {
   fmt : formatter;
   indent_incr : int;
       (** The indent increment we insert whenever we need to indent more *)
-  use_opaque_pre : bool;
-      (** Do we use the "opaque_defs." prefix for the opaque definitions?
-
-          Opaque function definitions might refer opaque types: if we are in the
-          opaque module, we musn't use the "opaque_defs." prefix, otherwise we
-          use it.
-          Also see {!names_map.opaque_ids}.
-       *)
   use_dep_ite : bool;
       (** For Lean: do we use dependent-if then else expressions?
 
@@ -884,8 +822,7 @@ let allow_collisions (id : id) : bool =
       !Config.record_fields_short_names
   | _ -> false
 
-let ctx_add (is_opaque : bool) (id : id) (name : string) (ctx : extraction_ctx)
-    : extraction_ctx =
+let ctx_add (id : id) (name : string) (ctx : extraction_ctx) : extraction_ctx =
   (* The id_to_string function to print nice debugging messages if there are
    * collisions *)
   let id_to_string (id : id) : string = id_to_string id ctx in
@@ -902,7 +839,6 @@ let ctx_add (is_opaque : bool) (id : id) (name : string) (ctx : extraction_ctx)
      others (ex.: fields and keywords).
   *)
   if allow_collisions id then (
-    assert (not is_opaque);
     (* Check with the ids which are considered to be strict on collisions *)
     names_map_check_collision id_to_string id name ctx.strict_names_map;
     {
@@ -916,16 +852,13 @@ let ctx_add (is_opaque : bool) (id : id) (name : string) (ctx : extraction_ctx)
     *)
     let strict_names_map =
       if strict_collisions id then
-        names_map_add id_to_string is_opaque id name ctx.strict_names_map
+        names_map_add id_to_string id name ctx.strict_names_map
       else ctx.strict_names_map
     in
-    let names_map =
-      names_map_add id_to_string is_opaque id name ctx.names_map
-    in
+    let names_map = names_map_add id_to_string id name ctx.names_map in
     { ctx with strict_names_map; names_map }
 
-(** [with_opaque_pre]: if [true] and the definition is opaque, add the opaque prefix *)
-let ctx_get (with_opaque_pre : bool) (id : id) (ctx : extraction_ctx) : string =
+let ctx_get (id : id) (ctx : extraction_ctx) : string =
   (* We do not use the same name map if we allow/disallow collisions *)
   let map_to_string (m : string IdMap.t) : string =
     "[\n"
@@ -951,9 +884,7 @@ let ctx_get (with_opaque_pre : bool) (id : id) (ctx : extraction_ctx) : string =
   else
     let m = ctx.names_map.id_to_name in
     match IdMap.find_opt id m with
-    | Some s ->
-        let is_opaque = IdSet.mem id ctx.names_map.opaque_ids in
-        if with_opaque_pre && is_opaque then ctx.fmt.opaque_pre () ^ s else s
+    | Some s -> s
     | None ->
         let err =
           "Could not find: " ^ id_to_string id ctx ^ "\nNames map:\n"
@@ -963,53 +894,38 @@ let ctx_get (with_opaque_pre : bool) (id : id) (ctx : extraction_ctx) : string =
         if !Config.extract_fail_hard then raise (Failure err)
         else "(ERROR: \"" ^ id_to_string id ctx ^ "\")"
 
-let ctx_get_global (with_opaque_pre : bool) (id : A.GlobalDeclId.id)
-    (ctx : extraction_ctx) : string =
-  ctx_get with_opaque_pre (GlobalId id) ctx
+let ctx_get_global (id : A.GlobalDeclId.id) (ctx : extraction_ctx) : string =
+  ctx_get (GlobalId id) ctx
 
-let ctx_get_function (with_opaque_pre : bool) (id : fun_id)
-    (ctx : extraction_ctx) : string =
-  ctx_get with_opaque_pre (FunId id) ctx
+let ctx_get_function (id : fun_id) (ctx : extraction_ctx) : string =
+  ctx_get (FunId id) ctx
 
-let ctx_get_local_function (with_opaque_pre : bool) (id : A.FunDeclId.id)
-    (lp : LoopId.id option) (rg : RegionGroupId.id option)
-    (ctx : extraction_ctx) : string =
-  ctx_get_function with_opaque_pre (FromLlbc (FunId (Regular id), lp, rg)) ctx
+let ctx_get_local_function (id : A.FunDeclId.id) (lp : LoopId.id option)
+    (rg : RegionGroupId.id option) (ctx : extraction_ctx) : string =
+  ctx_get_function (FromLlbc (FunId (Regular id), lp, rg)) ctx
 
-let ctx_get_type (with_opaque_pre : bool) (id : type_id) (ctx : extraction_ctx)
-    : string =
+let ctx_get_type (id : type_id) (ctx : extraction_ctx) : string =
   assert (id <> Tuple);
-  ctx_get with_opaque_pre (TypeId id) ctx
+  ctx_get (TypeId id) ctx
 
-let ctx_get_local_type (with_opaque_pre : bool) (id : TypeDeclId.id)
-    (ctx : extraction_ctx) : string =
-  ctx_get_type with_opaque_pre (AdtId id) ctx
+let ctx_get_local_type (id : TypeDeclId.id) (ctx : extraction_ctx) : string =
+  ctx_get_type (AdtId id) ctx
 
 let ctx_get_assumed_type (id : assumed_ty) (ctx : extraction_ctx) : string =
-  (* In practice, the assumed types are opaque. However, assumed types
-     are never grouped in the opaque module, meaning we never need to
-     prefix them: we thus consider them as non-opaque with regards to the
-     names map.
-  *)
-  let is_opaque = false in
-  ctx_get_type is_opaque (Assumed id) ctx
+  ctx_get_type (Assumed id) ctx
 
 let ctx_get_trait_self_clause (ctx : extraction_ctx) : string =
-  let with_opaque_pre = false in
-  ctx_get with_opaque_pre TraitSelfClauseId ctx
+  ctx_get TraitSelfClauseId ctx
 
-let ctx_get_trait_decl (with_opaque_pre : bool) (id : trait_decl_id)
-    (ctx : extraction_ctx) : string =
-  ctx_get with_opaque_pre (TraitDeclId id) ctx
+let ctx_get_trait_decl (id : trait_decl_id) (ctx : extraction_ctx) : string =
+  ctx_get (TraitDeclId id) ctx
 
-let ctx_get_trait_impl (with_opaque_pre : bool) (id : trait_impl_id)
-    (ctx : extraction_ctx) : string =
-  ctx_get with_opaque_pre (TraitImplId id) ctx
+let ctx_get_trait_impl (id : trait_impl_id) (ctx : extraction_ctx) : string =
+  ctx_get (TraitImplId id) ctx
 
 let ctx_get_trait_item (id : trait_decl_id) (item_name : string)
     (ctx : extraction_ctx) : string =
-  let is_opaque = false in
-  ctx_get is_opaque (TraitItemId (id, item_name)) ctx
+  ctx_get (TraitItemId (id, item_name)) ctx
 
 let ctx_get_trait_const (id : trait_decl_id) (item_name : string)
     (ctx : extraction_ctx) : string =
@@ -1021,83 +937,69 @@ let ctx_get_trait_type (id : trait_decl_id) (item_name : string)
 
 let ctx_get_trait_method (id : trait_decl_id) (item_name : string)
     (rg_id : T.RegionGroupId.id option) (ctx : extraction_ctx) : string =
-  let with_opaque_pre = false in
-  ctx_get with_opaque_pre (TraitMethodId (id, item_name, rg_id)) ctx
+  ctx_get (TraitMethodId (id, item_name, rg_id)) ctx
 
 let ctx_get_trait_parent_clause (id : trait_decl_id) (clause : trait_clause_id)
     (ctx : extraction_ctx) : string =
-  let with_opaque_pre = false in
-  ctx_get with_opaque_pre (TraitParentClauseId (id, clause)) ctx
+  ctx_get (TraitParentClauseId (id, clause)) ctx
 
 let ctx_get_trait_item_clause (id : trait_decl_id) (item : string)
     (clause : trait_clause_id) (ctx : extraction_ctx) : string =
-  let with_opaque_pre = false in
-  ctx_get with_opaque_pre (TraitItemClauseId (id, item, clause)) ctx
+  ctx_get (TraitItemClauseId (id, item, clause)) ctx
 
 let ctx_get_var (id : VarId.id) (ctx : extraction_ctx) : string =
-  let is_opaque = false in
-  ctx_get is_opaque (VarId id) ctx
+  ctx_get (VarId id) ctx
 
 let ctx_get_type_var (id : TypeVarId.id) (ctx : extraction_ctx) : string =
-  let is_opaque = false in
-  ctx_get is_opaque (TypeVarId id) ctx
+  ctx_get (TypeVarId id) ctx
 
 let ctx_get_const_generic_var (id : ConstGenericVarId.id) (ctx : extraction_ctx)
     : string =
-  let is_opaque = false in
-  ctx_get is_opaque (ConstGenericVarId id) ctx
+  ctx_get (ConstGenericVarId id) ctx
 
 let ctx_get_local_trait_clause (id : TraitClauseId.id) (ctx : extraction_ctx) :
     string =
-  let is_opaque = false in
-  ctx_get is_opaque (LocalTraitClauseId id) ctx
+  ctx_get (LocalTraitClauseId id) ctx
 
 let ctx_get_field (type_id : type_id) (field_id : FieldId.id)
     (ctx : extraction_ctx) : string =
-  let is_opaque = false in
-  ctx_get is_opaque (FieldId (type_id, field_id)) ctx
+  ctx_get (FieldId (type_id, field_id)) ctx
 
-let ctx_get_struct (with_opaque_pre : bool) (def_id : type_id)
-    (ctx : extraction_ctx) : string =
-  ctx_get with_opaque_pre (StructId def_id) ctx
+let ctx_get_struct (def_id : type_id) (ctx : extraction_ctx) : string =
+  ctx_get (StructId def_id) ctx
 
 let ctx_get_variant (def_id : type_id) (variant_id : VariantId.id)
     (ctx : extraction_ctx) : string =
-  let is_opaque = false in
-  ctx_get is_opaque (VariantId (def_id, variant_id)) ctx
+  ctx_get (VariantId (def_id, variant_id)) ctx
 
 let ctx_get_decreases_proof (def_id : A.FunDeclId.id)
     (loop_id : LoopId.id option) (ctx : extraction_ctx) : string =
-  let is_opaque = false in
-  ctx_get is_opaque (DecreasesProofId (Regular def_id, loop_id)) ctx
+  ctx_get (DecreasesProofId (Regular def_id, loop_id)) ctx
 
 let ctx_get_termination_measure (def_id : A.FunDeclId.id)
     (loop_id : LoopId.id option) (ctx : extraction_ctx) : string =
-  let is_opaque = false in
-  ctx_get is_opaque (TerminationMeasureId (Regular def_id, loop_id)) ctx
+  ctx_get (TerminationMeasureId (Regular def_id, loop_id)) ctx
 
 (** Generate a unique type variable name and add it to the context *)
 let ctx_add_type_var (basename : string) (id : TypeVarId.id)
     (ctx : extraction_ctx) : extraction_ctx * string =
-  let is_opaque = false in
   let name = ctx.fmt.type_var_basename ctx.names_map.names_set basename in
   let name =
     basename_to_unique ctx.names_map.names_set ctx.fmt.append_index name
   in
-  let ctx = ctx_add is_opaque (TypeVarId id) name ctx in
+  let ctx = ctx_add (TypeVarId id) name ctx in
   (ctx, name)
 
 (** Generate a unique const generic variable name and add it to the context *)
 let ctx_add_const_generic_var (basename : string) (id : ConstGenericVarId.id)
     (ctx : extraction_ctx) : extraction_ctx * string =
-  let is_opaque = false in
   let name =
     ctx.fmt.const_generic_var_basename ctx.names_map.names_set basename
   in
   let name =
     basename_to_unique ctx.names_map.names_set ctx.fmt.append_index name
   in
-  let ctx = ctx_add is_opaque (ConstGenericVarId id) name ctx in
+  let ctx = ctx_add (ConstGenericVarId id) name ctx in
   (ctx, name)
 
 (** See {!ctx_add_type_var} *)
@@ -1110,31 +1012,28 @@ let ctx_add_type_vars (vars : (string * TypeVarId.id) list)
 (** Generate a unique variable name and add it to the context *)
 let ctx_add_var (basename : string) (id : VarId.id) (ctx : extraction_ctx) :
     extraction_ctx * string =
-  let is_opaque = false in
   let name =
     basename_to_unique ctx.names_map.names_set ctx.fmt.append_index basename
   in
-  let ctx = ctx_add is_opaque (VarId id) name ctx in
+  let ctx = ctx_add (VarId id) name ctx in
   (ctx, name)
 
 (** Generate a unique variable name for the trait self clause and add it to the context *)
 let ctx_add_trait_self_clause (ctx : extraction_ctx) : extraction_ctx * string =
-  let is_opaque = false in
   let basename = ctx.fmt.trait_self_clause_basename in
   let name =
     basename_to_unique ctx.names_map.names_set ctx.fmt.append_index basename
   in
-  let ctx = ctx_add is_opaque TraitSelfClauseId name ctx in
+  let ctx = ctx_add TraitSelfClauseId name ctx in
   (ctx, name)
 
 (** Generate a unique trait clause name and add it to the context *)
 let ctx_add_local_trait_clause (basename : string) (id : TraitClauseId.id)
     (ctx : extraction_ctx) : extraction_ctx * string =
-  let is_opaque = false in
   let name =
     basename_to_unique ctx.names_map.names_set ctx.fmt.append_index basename
   in
-  let ctx = ctx_add is_opaque (LocalTraitClauseId id) name ctx in
+  let ctx = ctx_add (LocalTraitClauseId id) name ctx in
   (ctx, name)
 
 (** See {!ctx_add_var} *)
@@ -1182,30 +1081,23 @@ let ctx_add_generic_params (generics : generic_params) (ctx : extraction_ctx) :
 
 let ctx_add_decreases_proof (def : fun_decl) (ctx : extraction_ctx) :
     extraction_ctx =
-  let is_opaque = false in
   let name =
     ctx.fmt.decreases_proof_name def.def_id def.basename def.num_loops
       def.loop_id
   in
-  ctx_add is_opaque
-    (DecreasesProofId (Regular def.def_id, def.loop_id))
-    name ctx
+  ctx_add (DecreasesProofId (Regular def.def_id, def.loop_id)) name ctx
 
 let ctx_add_termination_measure (def : fun_decl) (ctx : extraction_ctx) :
     extraction_ctx =
-  let is_opaque = false in
   let name =
     ctx.fmt.termination_measure_name def.def_id def.basename def.num_loops
       def.loop_id
   in
-  ctx_add is_opaque
-    (TerminationMeasureId (Regular def.def_id, def.loop_id))
-    name ctx
+  ctx_add (TerminationMeasureId (Regular def.def_id, def.loop_id)) name ctx
 
 let ctx_add_global_decl_and_body (def : A.global_decl) (ctx : extraction_ctx) :
     extraction_ctx =
   (* TODO: update once the body id can be an option *)
-  let is_opaque = false in
   let decl = GlobalId def.def_id in
 
   (* Check if the global corresponds to an assumed global that we should map
@@ -1215,13 +1107,13 @@ let ctx_add_global_decl_and_body (def : A.global_decl) (ctx : extraction_ctx) :
   match SimpleNameMap.find_opt sname builtin_globals_map with
   | Some name ->
       (* Yes: register the custom binding *)
-      ctx_add is_opaque decl name ctx
+      ctx_add decl name ctx
   | None ->
       (* Not the case: "standard" registration *)
       let name = ctx.fmt.global_name def.name in
       let body = FunId (FromLlbc (FunId (Regular def.body_id), None, None)) in
-      let ctx = ctx_add is_opaque decl (name ^ "_c") ctx in
-      let ctx = ctx_add is_opaque body (name ^ "_body") ctx in
+      let ctx = ctx_add decl (name ^ "_c") ctx in
+      let ctx = ctx_add body (name ^ "_body") ctx in
       ctx
 
 let ctx_compute_fun_name (trans_group : pure_fun_translation) (def : fun_decl)
@@ -1259,11 +1151,10 @@ let ctx_add_fun_decl (trans_group : pure_fun_translation) (def : fun_decl)
   let def_id = def.def_id in
   let { keep_fwd; fwd = _; backs } = trans_group in
   let num_backs = List.length backs in
-  let is_opaque = def.body = None in
   (* Add the function name *)
   let def_name = ctx_compute_fun_name trans_group def ctx in
   let fun_id = (Pure.FunId (Regular def_id), def.loop_id, def.back_id) in
-  let ctx = ctx_add is_opaque (FunId (FromLlbc fun_id)) def_name ctx in
+  let ctx = ctx_add (FunId (FromLlbc fun_id)) def_name ctx in
   (* Add the name info *)
   {
     ctx with
@@ -1296,12 +1187,11 @@ let initialize_names_map (fmt : formatter) (init : names_map_init) : names_map =
   let name_to_id =
     StringMap.of_list (List.map (fun x -> (x, UnknownId)) keywords)
   in
-  let opaque_ids = IdSet.empty in
   (* We fist initialize [id_to_name] as empty, because the id of a keyword is [UnknownId].
    * Also note that we don't need this mapping for keywords: we insert keywords only
    * to check collisions. *)
   let id_to_name = IdMap.empty in
-  let nm = { id_to_name; name_to_id; names_set; opaque_ids } in
+  let nm = { id_to_name; name_to_id; names_set } in
   (* For debugging - we are creating bindings for assumed types and functions, so
    * it is ok if we simply use the "show" function (those aren't simply identified
    * by numbers) *)
@@ -1338,15 +1228,8 @@ let initialize_names_map (fmt : formatter) (init : names_map_init) : names_map =
     @ List.map (fun (fid, name) -> (Pure fid, name)) init.assumed_pure_functions
   in
   let nm =
-    (* In practice, the assumed function are opaque. However, assumed functions
-       are never grouped in the opaque module, meaning we never need to
-       prefix them: we thus consider them as non-opaque with regards to the
-       names map.
-    *)
-    let is_opaque = false in
     List.fold_left
-      (fun nm (fid, name) ->
-        names_map_add_function id_to_string is_opaque fid name nm)
+      (fun nm (fid, name) -> names_map_add_function id_to_string fid name nm)
       nm assumed_functions
   in
   (* Return *)
diff --git a/compiler/Translate.ml b/compiler/Translate.ml
index 74a8537f..b3269aa2 100644
--- a/compiler/Translate.ml
+++ b/compiler/Translate.ml
@@ -851,37 +851,10 @@ let extract_definitions (fmt : Format.formatter) (config : gen_config)
   if config.extract_state_type && config.extract_fun_decls then
     export_state_type ();
 
-  (* Obsolete: (TODO: remove) For Lean we parameterize the entire development by a section
-     variable called opaque_defs, of type OpaqueDefs. The code below emits the type
-     definition for OpaqueDefs, which is a structure, in which each field is one of the
-     functions marked as Opaque. We emit the `structure ...` bit here, then rely on
-     `extract_fun_decl` to be aware of this, and skip the keyword (e.g. "axiom" or "val")
-     so as to generate valid syntax for records.
-
-     We also generate such a structure only if there actually are opaque definitions. *)
-  let wrap_in_sig =
-    config.extract_opaque && config.extract_fun_decls
-    && !Config.wrap_opaque_in_sig
-    &&
-    let _, opaque_funs = crate_has_opaque_decls ctx true in
-    opaque_funs
-  in
-  if wrap_in_sig then (
-    (* We change the name of the structure depending on whether we *only*
-       extract opaque definitions, or if we extract all definitions *)
-    let struct_name =
-      if config.extract_transparent then "Definitions" else "OpaqueDefs"
-    in
-    Format.pp_print_break fmt 0 0;
-    Format.pp_open_vbox fmt ctx.indent_incr;
-    Format.pp_print_string fmt ("structure " ^ struct_name ^ " where");
-    Format.pp_print_break fmt 0 0);
   List.iter export_decl_group ctx.crate.declarations;
 
   if config.extract_state_type && not config.extract_fun_decls then
-    export_state_type ();
-
-  if wrap_in_sig then Format.pp_close_box fmt ()
+    export_state_type ()
 
 type extract_file_info = {
   filename : string;
@@ -1029,10 +1002,9 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
         (fun (id, _) -> strict_collisions id)
         (IdMap.bindings names_map.id_to_name)
     in
-    let is_opaque = false in
     List.fold_left
       (* id_to_string: we shouldn't need to use it *)
-        (fun m (id, n) -> names_map_add show_id is_opaque id n m)
+        (fun m (id, n) -> names_map_add show_id id n m)
       empty_names_map ids
   in
 
@@ -1093,7 +1065,6 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
       strict_names_map;
       fmt;
       indent_incr = 2;
-      use_opaque_pre = !Config.split_files;
       use_dep_ite = !Config.backend = Lean && !Config.extract_decreases_clauses;
       fun_name_info = PureUtils.RegularFunIdMap.empty;
       trait_decl_id = None (* None by default *);
@@ -1389,7 +1360,6 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
              interface = true;
            }
          in
-         let ctx = { ctx with use_opaque_pre = false } in
          let file_info =
            {
              filename = opaque_filename;
-- 
cgit v1.3.1


From 9ddd174959970f87658191034b70d0cfa02ff451 Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Tue, 24 Oct 2023 15:49:54 +0200
Subject: Filter some type arguments for the builtin types/functions

---
 compiler/Extract.ml        | 67 ++++++++++++++++++++++++++++++++++++++++++++--
 compiler/ExtractBase.ml    | 13 +++++++++
 compiler/ExtractBuiltin.ml | 15 +++++------
 compiler/Translate.ml      |  2 ++
 4 files changed, 87 insertions(+), 10 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/compiler/Extract.ml b/compiler/Extract.ml
index 275cb3b9..bf90a411 100644
--- a/compiler/Extract.ml
+++ b/compiler/Extract.ml
@@ -1175,6 +1175,26 @@ let rec extract_ty (ctx : extraction_ctx) (fmt : F.formatter)
               (* TODO: for now, only the opaque *functions* are extracted in the
                  opaque module. The opaque *types* are assumed. *)
               F.pp_print_string fmt (ctx_get_type type_id ctx);
+              (* We might need to filter the type arguments, if the type
+                 is builtin (for instance, we filter the global allocator type
+                 argument for `Vec`). *)
+              let generics =
+                match type_id with
+                | AdtId id -> (
+                    match
+                      TypeDeclId.Map.find_opt id ctx.types_filter_type_args_map
+                    with
+                    | None -> generics
+                    | Some filter ->
+                        let types = List.combine filter generics.types in
+                        let types =
+                          List.filter_map
+                            (fun (b, ty) -> if b then Some ty else None)
+                            types
+                        in
+                        { generics with types })
+                | _ -> generics
+              in
               extract_generic_args ctx fmt no_params_tys generics;
               if print_paren then F.pp_print_string fmt ")"
           | HOL4 ->
@@ -1335,6 +1355,17 @@ let extract_type_decl_register_names (ctx : extraction_ctx) (def : type_decl) :
   let open ExtractBuiltin in
   let sname = name_to_simple_name def.name in
   let info = SimpleNameMap.find_opt sname (builtin_types_map ()) in
+  (* Register the filtering information, if there is *)
+  let ctx =
+    match info with
+    | Some { keep_params = Some keep; _ } ->
+        {
+          ctx with
+          types_filter_type_args_map =
+            TypeDeclId.Map.add def.def_id keep ctx.types_filter_type_args_map;
+        }
+    | _ -> ctx
+  in
   (* Compute and register the type def name *)
   let def_name =
     match info with
@@ -2361,7 +2392,19 @@ let extract_fun_decl_register_names (ctx : extraction_ctx)
       in
       (* Use the builtin names if necessary *)
       match builtin with
-      | Some (_filter, info) ->
+      | Some (filter_info, info) ->
+          (* Register the filtering information, if there is *)
+          let ctx =
+            match filter_info with
+            | Some keep ->
+                {
+                  ctx with
+                  funs_filter_type_args_map =
+                    FunDeclId.Map.add def.fwd.f.def_id keep
+                      ctx.funs_filter_type_args_map;
+                }
+            | _ -> ctx
+          in
           let backs = List.map (fun f -> f.f) def.backs in
           let funs = if def.keep_fwd then def.fwd.f :: backs else backs in
           List.fold_left
@@ -2734,7 +2777,27 @@ and extract_function_call (ctx : extraction_ctx) (fmt : F.formatter)
 
       (* Sanity check: HOL4 doesn't support const generics *)
       assert (generics.const_generics = [] || !backend <> HOL4);
-      (* Print the generics *)
+      (* Print the generics.
+
+         We might need to filter some of the type arguments, if the type
+         is builtin (for instance, we filter the global allocator type
+         argument for `Vec::new`).
+      *)
+      let generics =
+        match fun_id with
+        | FromLlbc (FunId (Regular id), _, _) -> (
+            match FunDeclId.Map.find_opt id ctx.funs_filter_type_args_map with
+            | None -> generics
+            | Some filter ->
+                let types = List.combine filter generics.types in
+                let types =
+                  List.filter_map
+                    (fun (b, ty) -> if b then Some ty else None)
+                    types
+                in
+                { generics with types })
+        | _ -> generics
+      in
       extract_generic_args ctx fmt TypeDeclId.Set.empty generics;
       (* Print the arguments *)
       List.iter
diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index f26beeb6..e004aba8 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -640,6 +640,19 @@ type extraction_ctx = {
   functions_with_decreases_clause : PureUtils.FunLoopIdSet.t;
   trans_trait_decls : Pure.trait_decl Pure.TraitDeclId.Map.t;
   trans_trait_impls : Pure.trait_impl Pure.TraitImplId.Map.t;
+  types_filter_type_args_map : bool list TypeDeclId.Map.t;
+      (** The map to filter the type arguments for the builtin type
+          definitions.
+
+          We need this for type `Vec`, for instance, which takes a useless
+          (in the context of the type translation) type argument for the
+          allocator which is used, and which we want to remove.
+
+          TODO: it would be cleaner to filter those types in a micro-pass,
+          rather than at code generation time.
+        *)
+  funs_filter_type_args_map : bool list FunDeclId.Map.t;
+      (** Same as {!types_filter_type_args_map}, but for functions *)
 }
 
 (** Debugging function, used when communicating name collisions to the user,
diff --git a/compiler/ExtractBuiltin.ml b/compiler/ExtractBuiltin.ml
index d3cea54e..65c18efd 100644
--- a/compiler/ExtractBuiltin.ml
+++ b/compiler/ExtractBuiltin.ml
@@ -203,9 +203,8 @@ type builtin_fun_info = {
 let builtin_funs () :
     (string list * bool list option * builtin_fun_info list) list =
   let rg0 = Some Types.RegionGroupId.zero in
-  (* TODO: fix the names below *)
   [
-    ( [ "core::mem::replace" ],
+    ( [ "core"; "mem"; "replace" ],
       None,
       [
         {
@@ -223,7 +222,7 @@ let builtin_funs () :
             | Lean -> "mem.replace_back");
         };
       ] );
-    ( [ "alloc::vec::Vec::new" ],
+    ( [ "alloc"; "vec"; "Vec"; "new" ],
       Some [ true; false ],
       [
         {
@@ -241,7 +240,7 @@ let builtin_funs () :
             | Lean -> "Vec.new_back");
         };
       ] );
-    ( [ "alloc::vec::Vec::push" ],
+    ( [ "alloc"; "vec"; "Vec"; "push" ],
       Some [ true; false ],
       [
         (* The forward function shouldn't be used *)
@@ -260,7 +259,7 @@ let builtin_funs () :
             | Lean -> "Vec.push");
         };
       ] );
-    ( [ "alloc::vec::Vec::insert" ],
+    ( [ "alloc"; "vec"; "Vec"; "insert" ],
       Some [ true; false ],
       [
         (* The forward function shouldn't be used *)
@@ -279,7 +278,7 @@ let builtin_funs () :
             | Lean -> "Vec.insert");
         };
       ] );
-    ( [ "alloc::vec::Vec::len" ],
+    ( [ "alloc"; "vec"; "Vec"; "len" ],
       Some [ true; false ],
       [
         {
@@ -290,7 +289,7 @@ let builtin_funs () :
             | Lean -> "Vec.len");
         };
       ] );
-    ( [ "alloc::vec::Vec::index" ],
+    ( [ "alloc"; "vec"; "Vec"; "index" ],
       Some [ true; false ],
       [
         {
@@ -309,7 +308,7 @@ let builtin_funs () :
             | Lean -> "Vec.index_shared_back");
         };
       ] );
-    ( [ "alloc::vec::Vec::index_mut" ],
+    ( [ "alloc"; "vec"; "Vec"; "index_mut" ],
       Some [ true; false ],
       [
         {
diff --git a/compiler/Translate.ml b/compiler/Translate.ml
index b3269aa2..35dff9e6 100644
--- a/compiler/Translate.ml
+++ b/compiler/Translate.ml
@@ -1074,6 +1074,8 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
       trans_types;
       trans_funs;
       functions_with_decreases_clause = rec_functions;
+      types_filter_type_args_map = Pure.TypeDeclId.Map.empty;
+      funs_filter_type_args_map = Pure.FunDeclId.Map.empty;
     }
   in
 
-- 
cgit v1.3.1


From 9c230dddebb171ee1b3e0176838441163836b875 Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Tue, 24 Oct 2023 18:16:53 +0200
Subject: Handle properly the builtin, non fallible functions

---
 backends/lean/Base/Primitives/Base.lean |  4 ++--
 compiler/ExtractBase.ml                 |  4 ++--
 compiler/ExtractBuiltin.ml              | 34 ++++++++++++++++++++++++++++++++-
 compiler/FunsAnalysis.ml                | 34 ++++++++++++++++++---------------
 tests/lean/NoNestedBorrows.lean         | 12 ++++++------
 5 files changed, 62 insertions(+), 26 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/backends/lean/Base/Primitives/Base.lean b/backends/lean/Base/Primitives/Base.lean
index 2bd081c0..10af8f67 100644
--- a/backends/lean/Base/Primitives/Base.lean
+++ b/backends/lean/Base/Primitives/Base.lean
@@ -120,8 +120,8 @@ def Result.attach {α: Type} (o : Result α): Result { x : α // o = ret x } :=
 -- MISC --
 ----------
 
-@[simp] def core.mem.replace (a : Type) (x : a) (_ : a) : Result a := ret x
-@[simp] def core.mem.replace_back (a : Type) (_ : a) (y : a) : Result a := ret y
+@[simp] def core.mem.replace (a : Type) (x : a) (_ : a) : a := x
+@[simp] def core.mem.replace_back (a : Type) (_ : a) (y : a) : a := y
 
 /-- Aeneas-translated function -- useful to reduce non-recursive definitions.
  Use with `simp [ aeneas ]` -/
diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index e004aba8..8f32ba44 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -22,8 +22,8 @@ type region_group_info = {
        *)
 }
 
-module StringSet = Collections.MakeSet (Collections.OrderedString)
-module StringMap = Collections.MakeMap (Collections.OrderedString)
+module StringSet = Collections.StringSet
+module StringMap = Collections.StringMap
 
 type name = Names.name
 type type_name = Names.type_name
diff --git a/compiler/ExtractBuiltin.ml b/compiler/ExtractBuiltin.ml
index 9cc7c226..4c6fe014 100644
--- a/compiler/ExtractBuiltin.ml
+++ b/compiler/ExtractBuiltin.ml
@@ -376,7 +376,39 @@ let mk_builtin_funs_map () =
 let builtin_funs_map = mk_memoized mk_builtin_funs_map
 
 let builtin_non_fallible_funs =
-  [ "alloc::boxed::Box::deref"; "alloc::boxed::Box::deref_mut" ]
+  let int_names =
+    [
+      "usize";
+      "u8";
+      "u16";
+      "u32";
+      "u64";
+      "u128";
+      "isize";
+      "i8";
+      "i16";
+      "i32";
+      "i64";
+      "i128";
+    ]
+  in
+  let int_ops =
+    [ "wrapping_add"; "wrapping_sub"; "rotate_left"; "rotate_right" ]
+  in
+  let int_funs =
+    List.map
+      (fun int_name ->
+        List.map (fun op -> "core::num::" ^ int_name ^ "::" ^ op) int_ops)
+      int_names
+  in
+  let int_funs = List.concat int_funs in
+  [
+    "alloc::boxed::Box::deref";
+    "alloc::boxed::Box::deref_mut";
+    "core::mem::replace";
+    "core::mem::take";
+  ]
+  @ int_funs
 
 let builtin_non_fallible_funs_set =
   SimpleNameSet.of_list
diff --git a/compiler/FunsAnalysis.ml b/compiler/FunsAnalysis.ml
index 1273f57d..3ba5d35d 100644
--- a/compiler/FunsAnalysis.ml
+++ b/compiler/FunsAnalysis.ml
@@ -57,21 +57,16 @@ let analyze_module (m : crate) (funs_map : fun_decl FunDeclId.Map.t)
     let stateful = ref false in
     let can_diverge = ref false in
     let is_rec = ref false in
+    let is_builtin_non_fallible_group = ref false in
 
     (* We have some specialized knowledge of some library functions; we don't
        have any more custom treatment than this, and these functions can be modeled
        suitably in Primitives.fst, rather than special-casing for them all the
        way. *)
-    let module M = struct type opaque_info = { fallible: bool; stateful: bool } end in
-    let open M in
-    let opaque_info (f: fun_decl) =
-      match f.name with
-      | [ Ident "core"; Ident "num"; Ident "u32"; _; Ident "wrapping_add" ]
-      | [ Ident "core"; Ident "num"; Ident "u32"; _; Ident "rotate_left" ] ->
-          { fallible = false; stateful = false }
-      | _ ->
-          (* Opaque function: we consider they fail by default *)
-          { fallible = true; stateful = true }
+    let is_builtin_non_fallible (f : fun_decl) : bool =
+      let open ExtractBuiltin in
+      let name = name_to_simple_name f.name in
+      SimpleNameSet.mem name builtin_non_fallible_funs_set
     in
 
     (* JP: Why not use a reduce visitor here with a tuple of the values to be
@@ -124,11 +119,16 @@ let analyze_module (m : crate) (funs_map : fun_decl FunDeclId.Map.t)
       in
       (* Sanity check: global bodies don't contain stateful calls *)
       assert ((not f.is_global_decl_body) || not !stateful);
+      let is_builtin_non_fallible = is_builtin_non_fallible f in
+      is_builtin_non_fallible_group :=
+        !is_builtin_non_fallible_group || is_builtin_non_fallible;
       match f.body with
       | None ->
-          let info = opaque_info f in
-          obj#may_fail info.fallible;
-          stateful := (not f.is_global_decl_body) && use_state && info.stateful
+          obj#may_fail (not is_builtin_non_fallible);
+          stateful :=
+            (not f.is_global_decl_body)
+            && use_state
+            && not is_builtin_non_fallible
       | Some body -> obj#visit_statement () body.body
     in
     List.iter visit_fun d;
@@ -136,12 +136,16 @@ let analyze_module (m : crate) (funs_map : fun_decl FunDeclId.Map.t)
      * groups containing globals contain exactly one declaration *)
     let is_global_decl_body = List.exists (fun f -> f.is_global_decl_body) d in
     assert ((not is_global_decl_body) || List.length d = 1);
+    assert ((not !is_builtin_non_fallible_group) || List.length d = 1);
     (* We ignore on purpose functions that cannot fail and consider they *can*
      * fail: the result of the analysis is not used yet to adjust the translation
      * so that the functions which syntactically can't fail don't use an error monad.
-     * However, we do keep the result of the analysis for global bodies.
+     * However, we do keep the result of the analysis for global bodies and for
+     * builtin functions which are marked as non-fallible.
      * *)
-    can_fail := (not is_global_decl_body) || !can_fail;
+    can_fail :=
+      ((not is_global_decl_body) && not !is_builtin_non_fallible_group)
+      || !can_fail;
     {
       can_fail = !can_fail;
       stateful = !stateful;
diff --git a/tests/lean/NoNestedBorrows.lean b/tests/lean/NoNestedBorrows.lean
index a90d6ea2..d6d603ce 100644
--- a/tests/lean/NoNestedBorrows.lean
+++ b/tests/lean/NoNestedBorrows.lean
@@ -139,9 +139,9 @@ def test_list1 : Result Unit :=
 
 /- [no_nested_borrows::test_box1]: forward function -/
 def test_box1 : Result Unit :=
-  let b := (I32.ofInt 1)
+  let b := 1#i32
   let x := b
-  if not (x = (I32.ofInt 1))
+  if not (x = 1#i32)
   then Result.fail Error.panic
   else Result.ret ()
 
@@ -316,7 +316,7 @@ divergent def list_rev_aux
 /- [no_nested_borrows::list_rev]: merged forward/backward function
    (there is a single backward function, and the forward function returns ()) -/
 def list_rev (T : Type) (l : List T) : Result (List T) :=
-  let li := mem.replace (List T) l List.Nil
+  let li := core.mem.replace (List T) l List.Nil
   list_rev_aux T li List.Nil
 
 /- [no_nested_borrows::test_list_functions]: forward function -/
@@ -478,10 +478,10 @@ def test_weird_borrows1 : Result Unit :=
 /- [no_nested_borrows::test_mem_replace]: merged forward/backward function
    (there is a single backward function, and the forward function returns ()) -/
 def test_mem_replace (px : U32) : Result U32 :=
-  let y := mem.replace U32 px (U32.ofInt 1)
-  if not (y = (U32.ofInt 0))
+  let y := core.mem.replace U32 px 1#u32
+  if not (y = 0#u32)
   then Result.fail Error.panic
-  else Result.ret (U32.ofInt 2)
+  else Result.ret 2#u32
 
 /- [no_nested_borrows::test_shared_borrow_bool1]: forward function -/
 def test_shared_borrow_bool1 (b : Bool) : Result U32 :=
-- 
cgit v1.3.1


From ece74df70f12790bab7ecfe0c590c2c637e89801 Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Wed, 25 Oct 2023 11:40:31 +0200
Subject: Update following the addition of raw pointers

---
 compiler/Assumed.ml              |  1 +
 compiler/Extract.ml              |  5 ++++-
 compiler/ExtractBase.ml          |  5 +++--
 compiler/InterpreterExpansion.ml |  3 ++-
 compiler/Print.ml                | 30 ++++++++++++++++++++++++------
 compiler/PrintPure.ml            |  8 +++++---
 compiler/Pure.ml                 | 18 +++++++++++++++++-
 compiler/PureTypeCheck.ml        |  2 +-
 compiler/SymbolicToPure.ml       | 13 +++++++++++++
 compiler/SynthesizeSymbolic.ml   |  4 +++-
 compiler/TypesAnalysis.ml        |  3 +++
 compiler/dune                    |  2 +-
 12 files changed, 77 insertions(+), 17 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/compiler/Assumed.ml b/compiler/Assumed.ml
index 94fb7a72..79f6b0d4 100644
--- a/compiler/Assumed.ml
+++ b/compiler/Assumed.ml
@@ -85,6 +85,7 @@ module Sig = struct
       { regions_outlive = []; types_outlive = []; trait_type_constraints = [] }
     in
     {
+      is_unsafe = false;
       generics;
       preds;
       parent_params_info = None;
diff --git a/compiler/Extract.ml b/compiler/Extract.ml
index 91827a31..afd722e5 100644
--- a/compiler/Extract.ml
+++ b/compiler/Extract.ml
@@ -64,7 +64,9 @@ let named_binop_name (binop : E.binop) (int_ty : integer_type) : string =
     | BitAnd -> "and"
     | BitOr -> "or"
     | Shl -> "lsl"
-    | Shr -> "asr" (* NOTE: make sure arithmetic shift right is implemented, i.e. OCaml's asr operator, not lsr *)
+    | Shr ->
+        "asr"
+        (* NOTE: make sure arithmetic shift right is implemented, i.e. OCaml's asr operator, not lsr *)
     | _ -> raise (Failure "Unreachable")
   in
   (* Remark: the Lean case is actually not used *)
@@ -798,6 +800,7 @@ let mk_formatter (ctx : trans_ctx) (crate_name : string)
             | Assumed Slice -> "s"
             | Assumed Str -> "s"
             | Assumed State -> ConstStrings.state_basename
+            | Assumed (RawPtr _) -> "p"
             | AdtId adt_id ->
                 let def = TypeDeclId.Map.find adt_id ctx.type_ctx.type_decls in
                 (* Derive the var name from the last ident of the type name
diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index 8f32ba44..3eef6b3b 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -758,7 +758,7 @@ let id_to_string (id : id) (ctx : extraction_ctx) : string =
             if variant_id = fuel_zero_id then "@fuel::0"
             else if variant_id = fuel_succ_id then "@fuel::Succ"
             else raise (Failure "Unreachable")
-        | Assumed (State | Array | Slice | Str) ->
+        | Assumed (State | Array | Slice | Str | RawPtr _) ->
             raise
               (Failure
                  ("Unreachable: variant id ("
@@ -777,7 +777,8 @@ let id_to_string (id : id) (ctx : extraction_ctx) : string =
       let field_name =
         match id with
         | Tuple -> raise (Failure "Unreachable")
-        | Assumed (State | Result | Error | Fuel | Array | Slice | Str) ->
+        | Assumed
+            (State | Result | Error | Fuel | Array | Slice | Str | RawPtr _) ->
             (* We can't directly have access to the fields of those types *)
             raise (Failure "Unreachable")
         | AdtId id -> (
diff --git a/compiler/InterpreterExpansion.ml b/compiler/InterpreterExpansion.ml
index 167e3d58..b267bb51 100644
--- a/compiler/InterpreterExpansion.ml
+++ b/compiler/InterpreterExpansion.ml
@@ -696,7 +696,8 @@ let greedy_expand_symbolics_with_borrows (config : C.config) : cm_fun =
             raise
               (Failure
                  "Attempted to greedily expand an ADT which can't be expanded ")
-        | T.TypeVar _ | T.Literal _ | Never | T.TraitType _ | T.Arrow _ ->
+        | T.TypeVar _ | T.Literal _ | Never | T.TraitType _ | T.Arrow _
+        | T.RawPtr _ ->
             raise (Failure "Unreachable")
       in
       (* Compose and continue *)
diff --git a/compiler/Print.ml b/compiler/Print.ml
index aeacfbf0..7f0d95ff 100644
--- a/compiler/Print.ml
+++ b/compiler/Print.ml
@@ -660,6 +660,30 @@ module EvalCtxLlbcAst = struct
     let fmt = PC.ctx_to_stype_formatter fmt in
     PT.sty_to_string fmt t
 
+  let generic_params_to_strings (ctx : C.eval_ctx) (x : T.generic_params) :
+      string list * string list =
+    let fmt = PC.eval_ctx_to_ctx_formatter ctx in
+    let fmt = PC.ctx_to_stype_formatter fmt in
+    PT.generic_params_to_strings fmt x
+
+  let egeneric_args_to_string (ctx : C.eval_ctx) (x : T.egeneric_args) : string
+      =
+    let fmt = PC.eval_ctx_to_ctx_formatter ctx in
+    let fmt = PC.ctx_to_etype_formatter fmt in
+    PT.egeneric_args_to_string fmt x
+
+  let rgeneric_args_to_string (ctx : C.eval_ctx) (x : T.rgeneric_args) : string
+      =
+    let fmt = PC.eval_ctx_to_ctx_formatter ctx in
+    let fmt = PC.ctx_to_rtype_formatter fmt in
+    PT.rgeneric_args_to_string fmt x
+
+  let sgeneric_args_to_string (ctx : C.eval_ctx) (x : T.sgeneric_args) : string
+      =
+    let fmt = PC.eval_ctx_to_ctx_formatter ctx in
+    let fmt = PC.ctx_to_stype_formatter fmt in
+    PT.sgeneric_args_to_string fmt x
+
   let etrait_ref_to_string (ctx : C.eval_ctx) (x : T.etrait_ref) : string =
     let fmt = PC.eval_ctx_to_ctx_formatter ctx in
     let fmt = PC.ctx_to_etype_formatter fmt in
@@ -693,12 +717,6 @@ module EvalCtxLlbcAst = struct
     let fmt = PC.ctx_to_stype_formatter fmt in
     PT.strait_instance_id_to_string fmt x
 
-  let egeneric_args_to_string (ctx : C.eval_ctx) (x : T.egeneric_args) : string
-      =
-    let fmt = PC.eval_ctx_to_ctx_formatter ctx in
-    let fmt = PC.ctx_to_etype_formatter fmt in
-    PT.egeneric_args_to_string fmt x
-
   let borrow_content_to_string (ctx : C.eval_ctx) (bc : V.borrow_content) :
       string =
     let fmt = PC.eval_ctx_to_ctx_formatter ctx in
diff --git a/compiler/PrintPure.ml b/compiler/PrintPure.ml
index 6396fe96..ec75fcfd 100644
--- a/compiler/PrintPure.ml
+++ b/compiler/PrintPure.ml
@@ -198,6 +198,8 @@ let assumed_ty_to_string (aty : assumed_ty) : string =
   | Array -> "Array"
   | Slice -> "Slice"
   | Str -> "Str"
+  | RawPtr Mut -> "MutRawPtr"
+  | RawPtr Const -> "ConstRawPtr"
 
 let type_id_to_string (fmt : type_formatter) (id : type_id) : string =
   match id with
@@ -385,7 +387,7 @@ let adt_variant_to_string (fmt : value_formatter) (adt_id : type_id)
   | Assumed aty -> (
       (* Assumed type *)
       match aty with
-      | State | Array | Slice | Str ->
+      | State | Array | Slice | Str | RawPtr _ ->
           (* Those types are opaque: we can't get there *)
           raise (Failure "Unreachable")
       | Result ->
@@ -423,7 +425,7 @@ let adt_field_to_string (fmt : value_formatter) (adt_id : type_id)
       | State | Fuel | Array | Slice | Str ->
           (* Opaque types: we can't get there *)
           raise (Failure "Unreachable")
-      | Result | Error ->
+      | Result | Error | RawPtr _ ->
           (* Enumerations: we can't get there *)
           raise (Failure "Unreachable"))
 
@@ -463,7 +465,7 @@ let adt_g_value_to_string (fmt : value_formatter)
   | Adt (Assumed aty, _) -> (
       (* Assumed type *)
       match aty with
-      | State ->
+      | State | RawPtr _ ->
           (* This type is opaque: we can't get there *)
           raise (Failure "Unreachable")
       | Result ->
diff --git a/compiler/Pure.ml b/compiler/Pure.ml
index 81e13af7..9a3654b8 100644
--- a/compiler/Pure.ml
+++ b/compiler/Pure.ml
@@ -47,6 +47,7 @@ type trait_clause_id = T.trait_clause_id [@@deriving show, ord]
 type trait_item_name = T.trait_item_name [@@deriving show, ord]
 type global_decl_id = T.global_decl_id [@@deriving show, ord]
 type fun_decl_id = A.fun_decl_id [@@deriving show, ord]
+type mutability = Mut | Const [@@deriving show, ord]
 
 (** The assumed types for the pure AST.
 
@@ -64,7 +65,22 @@ type fun_decl_id = A.fun_decl_id [@@deriving show, ord]
         this state is opaque to Aeneas (the user can define it, or leave it as
         assumed)
   *)
-type assumed_ty = State | Result | Error | Fuel | Array | Slice | Str
+type assumed_ty =
+  | State
+  | Result
+  | Error
+  | Fuel
+  | Array
+  | Slice
+  | Str
+  | RawPtr of mutability
+      (** The bool
+          Raw pointers don't make sense in the pure world, but we don't know
+          how to translate them yet and we have to handle some functions which
+          use raw pointers in their signature (for instance some trait declarations
+          for the slices). For now, we use a dedicated type to "mark" the raw pointers,
+          and make sure that those functions are actually not used in the translation.
+       *)
 [@@deriving show, ord]
 
 (* TODO: we should never directly manipulate [Return] and [Fail], but rather
diff --git a/compiler/PureTypeCheck.ml b/compiler/PureTypeCheck.ml
index d31f0cf9..2ad942bb 100644
--- a/compiler/PureTypeCheck.ml
+++ b/compiler/PureTypeCheck.ml
@@ -46,7 +46,7 @@ let get_adt_field_types (type_decls : type_decl TypeDeclId.Map.t)
           if variant_id = fuel_zero_id then []
           else if variant_id = fuel_succ_id then [ mk_fuel_ty ]
           else raise (Failure "Unreachable: improper variant id for fuel type")
-      | Array | Slice | Str ->
+      | Array | Slice | Str | RawPtr _ ->
           (* Array: when not symbolic values (for instance, because of aggregates),
              the array expressions are introduced as struct updates *)
           raise (Failure "Attempting to access the fields of an opaque type"))
diff --git a/compiler/SymbolicToPure.ml b/compiler/SymbolicToPure.ml
index 9c698b51..4ba5296f 100644
--- a/compiler/SymbolicToPure.ml
+++ b/compiler/SymbolicToPure.ml
@@ -421,6 +421,11 @@ let rec translate_sty (ty : T.sty) : ty =
   | Literal ty -> Literal ty
   | Never -> raise (Failure "Unreachable")
   | Ref (_, rty, _) -> translate rty
+  | RawPtr (ty, rkind) ->
+      let mut = match rkind with Mut -> Mut | Shared -> Const in
+      let ty = translate ty in
+      let generics = { types = [ ty ]; const_generics = []; trait_refs = [] } in
+      Adt (Assumed (RawPtr mut), generics)
   | TraitType (trait_ref, generics, type_name) ->
       let trait_ref = translate_strait_ref trait_ref in
       let generics = translate_sgeneric_args generics in
@@ -560,6 +565,11 @@ let rec translate_fwd_ty (type_infos : TA.type_infos) (ty : 'r T.ty) : ty =
   | Never -> raise (Failure "Unreachable")
   | Literal lty -> Literal lty
   | Ref (_, rty, _) -> translate rty
+  | RawPtr (ty, rkind) ->
+      let mut = match rkind with Mut -> Mut | Shared -> Const in
+      let ty = translate ty in
+      let generics = { types = [ ty ]; const_generics = []; trait_refs = [] } in
+      Adt (Assumed (RawPtr mut), generics)
   | TraitType (trait_ref, generics, type_name) ->
       let trait_ref = translate_fwd_trait_ref type_infos trait_ref in
       let generics = translate_fwd_generic_args type_infos generics in
@@ -646,6 +656,9 @@ let rec translate_back_ty (type_infos : TA.type_infos)
           if keep_region r then
             translate_back_ty type_infos keep_region inside_mut rty
           else None)
+  | RawPtr _ ->
+      (* TODO: not sure what to do here *)
+      None
   | TraitType (trait_ref, generics, type_name) ->
       assert (generics.regions = []);
       (* Translate the trait ref and the generics as "forward" generics -
diff --git a/compiler/SynthesizeSymbolic.ml b/compiler/SynthesizeSymbolic.ml
index 9084f2b3..9dd65c84 100644
--- a/compiler/SynthesizeSymbolic.ml
+++ b/compiler/SynthesizeSymbolic.ml
@@ -85,7 +85,9 @@ let synthesize_symbolic_expansion (sv : V.symbolic_value)
             match ls with
             | [ (Some see, exp) ] -> ExpandNoBranch (see, exp)
             | _ -> raise (Failure "Ill-formed borrow expansion"))
-        | T.TypeVar _ | T.Literal Char | Never | T.TraitType _ | T.Arrow _ ->
+        | T.TypeVar _
+        | T.Literal Char
+        | Never | T.TraitType _ | T.Arrow _ | T.RawPtr _ ->
             raise (Failure "Ill-formed symbolic expansion")
       in
       Some (Expansion (place, sv, expansion))
diff --git a/compiler/TypesAnalysis.ml b/compiler/TypesAnalysis.ml
index 16f8c5f9..38d350b1 100644
--- a/compiler/TypesAnalysis.ml
+++ b/compiler/TypesAnalysis.ml
@@ -168,6 +168,9 @@ let analyze_full_ty (r_is_static : 'r -> bool) (updated : bool ref)
         in
         (* Continue exploring *)
         analyze expl_info ty_info rty
+    | RawPtr (rty, _) ->
+        (* TODO: not sure what to do here *)
+        analyze expl_info ty_info rty
     | Adt ((Tuple | Assumed (Box | Slice | Array | Str)), generics) ->
         (* Nothing to update: just explore the type parameters *)
         List.fold_left
diff --git a/compiler/dune b/compiler/dune
index 4ec46b70..a4b09df4 100644
--- a/compiler/dune
+++ b/compiler/dune
@@ -92,4 +92,4 @@
    -g
    ;-dsource
    -warn-error
-   -5-8-9-11-14-33-20-21-26-27-39)))
+   -5@8-9-11-14-33-20-21-26-27-39)))
-- 
cgit v1.3.1


From 81b7a7d706bc1a0f2f57bc254a8af158039a10cf Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Wed, 25 Oct 2023 18:44:28 +0200
Subject: Make the hashmap files typecheck again in Lean

---
 Makefile                                      |    6 +-
 backends/lean/Base/Primitives/ArraySlice.lean |   61 +-
 backends/lean/Base/Primitives/Range.lean      |    2 +-
 backends/lean/Base/Primitives/Vec.lean        |   74 +-
 backends/lean/Base/Progress/Progress.lean     |    3 +-
 compiler/Extract.ml                           | 2500 ++-----------------------
 compiler/ExtractBase.ml                       |    2 +
 compiler/ExtractBuiltin.ml                    |  509 ++---
 compiler/ExtractTypes.ml                      | 2390 +++++++++++++++++++++++
 compiler/Pure.ml                              |    4 +-
 compiler/Translate.ml                         |    1 +
 compiler/dune                                 |    1 +
 12 files changed, 2778 insertions(+), 2775 deletions(-)
 create mode 100644 compiler/ExtractTypes.ml

(limited to 'compiler/ExtractBase.ml')

diff --git a/Makefile b/Makefile
index 2c996345..958ae8d7 100644
--- a/Makefile
+++ b/Makefile
@@ -142,7 +142,8 @@ tcoq-loops: OPTIONS += -use-fuel -no-split-files
 tlean-loops: SUBDIR :=
 thol4-loops: SUBDIR := misc-loops
 
-trans-hashmap: OPTIONS += -no-state -test-trans-units
+# TODO: reactivate -test-trans-units
+trans-hashmap: OPTIONS += -no-state
 trans-hashmap: SUBDIR := hashmap
 tfstar-hashmap: OPTIONS += -decreases-clauses -template-clauses
 tcoq-hashmap: OPTIONS += -use-fuel
@@ -150,7 +151,8 @@ tlean-hashmap: SUBDIR :=
 tlean-hashmap: OPTIONS += -no-gen-lib-entry # We add a custom import in the Hashmap.lean file: we do not want to overwrite it
 thol4-hashmap: OPTIONS +=
 
-trans-hashmap_main: OPTIONS += -test-trans-units
+# TODO: reactivate -test-trans-units
+trans-hashmap_main: OPTIONS +=
 trans-hashmap_main: SUBDIR := hashmap_on_disk
 tfstar-hashmap_main: OPTIONS += -decreases-clauses -template-clauses
 tcoq-hashmap_main: OPTIONS += -use-fuel
diff --git a/backends/lean/Base/Primitives/ArraySlice.lean b/backends/lean/Base/Primitives/ArraySlice.lean
index 47807a0d..615e0783 100644
--- a/backends/lean/Base/Primitives/ArraySlice.lean
+++ b/backends/lean/Base/Primitives/ArraySlice.lean
@@ -13,7 +13,7 @@ import Base.Progress.Base
 
 namespace Primitives
 
-open Result Error
+open Result Error core.ops.range
 
 def Array (α : Type u) (n : Usize) := { l : List α // l.length = n.val }
 
@@ -406,7 +406,7 @@ structure core.slice.index.private_slice_index.Sealed (Self : Type) where
 
 /- Trait declaration: [core::slice::index::SliceIndex] -/
 structure core.slice.index.SliceIndex (Self T0 : Type) where
-  sealedInst :core.slice.index.private_slice_index.Sealed Self
+  sealedInst : core.slice.index.private_slice_index.Sealed Self
   Output : Type
   get : Self → T0 → Result (Option Output)
   get_mut : Self → T0 → Result (Option Output)
@@ -557,4 +557,61 @@ def core.array.Array.coreopsindexIndexMutInst (T0 I : Type) (N : Usize)
   index_mut_back := core.array.Array.index_mut_back T0 I N inst
 }
 
+/- [core::slice::index::usize::get]: forward function -/
+def core.slice.index.Usize.get
+  (T : Type) : Usize → Slice T → Result (Option T) :=
+  sorry -- TODO
+
+/- [core::slice::index::usize::get_mut]: forward function -/
+def core.slice.index.Usize.get_mut
+  (T : Type) : Usize → Slice T → Result (Option T) :=
+  sorry -- TODO
+
+/- [core::slice::index::usize::get_mut]: backward function 0 -/
+def core.slice.index.Usize.get_mut_back
+  (T : Type) : Usize → Slice T → Option T → Result (Slice T) :=
+  sorry -- TODO
+
+/- [core::slice::index::usize::get_unchecked]: forward function -/
+def core.slice.index.Usize.get_unchecked
+  (T : Type) : Usize → ConstRawPtr (Slice T) → Result (ConstRawPtr T) :=
+  sorry -- TODO
+
+/- [core::slice::index::usize::get_unchecked_mut]: forward function -/
+def core.slice.index.Usize.get_unchecked_mut
+  (T : Type) : Usize → MutRawPtr (Slice T) → Result (MutRawPtr T) :=
+  sorry -- TODO
+
+/- [core::slice::index::usize::index]: forward function -/
+def core.slice.index.Usize.index (T : Type) : Usize → Slice T → Result T :=
+  sorry -- TODO
+
+/- [core::slice::index::usize::index_mut]: forward function -/
+def core.slice.index.Usize.index_mut (T : Type) : Usize → Slice T → Result T :=
+  sorry -- TODO
+
+/- [core::slice::index::usize::index_mut]: backward function 0 -/
+def core.slice.index.Usize.index_mut_back
+  (T : Type) : Usize → Slice T → T → Result (Slice T) :=
+  sorry -- TODO
+
+/- Trait implementation: [core::slice::index::private_slice_index::usize] -/
+def core.slice.index.private_slice_index.usize.coresliceindexprivate_slice_indexSealedInst
+  : core.slice.index.private_slice_index.Sealed Usize := {}
+
+/- Trait implementation: [core::slice::index::usize] -/
+def core.slice.index.usize.coresliceindexSliceIndexInst (T : Type) :
+  core.slice.index.SliceIndex Usize (Slice T) := {
+  sealedInst := core.slice.index.private_slice_index.usize.coresliceindexprivate_slice_indexSealedInst
+  Output := T
+  get := core.slice.index.Usize.get T
+  get_mut := core.slice.index.Usize.get_mut T
+  get_mut_back := core.slice.index.Usize.get_mut_back T
+  get_unchecked := core.slice.index.Usize.get_unchecked T
+  get_unchecked_mut := core.slice.index.Usize.get_unchecked_mut T
+  index := core.slice.index.Usize.index T
+  index_mut := core.slice.index.Usize.index_mut T
+  index_mut_back := core.slice.index.Usize.index_mut_back T
+}
+
 end Primitives
diff --git a/backends/lean/Base/Primitives/Range.lean b/backends/lean/Base/Primitives/Range.lean
index 26cbee42..a268bcba 100644
--- a/backends/lean/Base/Primitives/Range.lean
+++ b/backends/lean/Base/Primitives/Range.lean
@@ -11,7 +11,7 @@ import Base.Progress.Base
 
 namespace Primitives
 
-structure Range (α : Type u) where
+structure core.ops.range.Range (α : Type u) where
   mk ::
   start: α
   end_: α
diff --git a/backends/lean/Base/Primitives/Vec.lean b/backends/lean/Base/Primitives/Vec.lean
index 99fcedc6..e1b7e87b 100644
--- a/backends/lean/Base/Primitives/Vec.lean
+++ b/backends/lean/Base/Primitives/Vec.lean
@@ -14,6 +14,8 @@ namespace Primitives
 
 open Result Error
 
+namespace alloc.vec
+
 def Vec (α : Type u) := { l : List α // l.length ≤ Usize.max }
 
 instance (a : Type u) : Arith.HasIntProp (Vec a) where
@@ -79,7 +81,7 @@ theorem Vec.insert_spec {α : Type u} (v: Vec α) (i: Usize) (x: α)
   ∃ nv, v.insert α i x = ret nv ∧ nv.val = v.val.update i.val x := by
   simp [insert, *]
 
-def Vec.index_shared (α : Type u) (v: Vec α) (i: Usize) : Result α :=
+def Vec.index_usize (α : Type u) (v: Vec α) (i: Usize) : Result α :=
   match v.val.indexOpt i.val with
   | none => fail .arrayOutOfBounds
   | some x => ret x
@@ -90,51 +92,65 @@ def Vec.index_shared (α : Type u) (v: Vec α) (i: Usize) : Result α :=
  -/
 
 @[pspec]
-theorem Vec.index_shared_spec {α : Type u} [Inhabited α] (v: Vec α) (i: Usize)
+theorem Vec.index_usize_spec {α : Type u} [Inhabited α] (v: Vec α) (i: Usize)
   (hbound : i.val < v.length) :
-  ∃ x, v.index_shared α i = ret x ∧ x = v.val.index i.val := by
-  simp only [index_shared]
+  ∃ x, v.index_usize α i = ret x ∧ x = v.val.index i.val := by
+  simp only [index_usize]
   -- TODO: dependent rewrite
   have h := List.indexOpt_eq_index v.val i.val (by scalar_tac) (by simp [*])
   simp [*]
 
--- This shouldn't be used
-def Vec.index_back (α : Type u) (v: Vec α) (i: Usize) (_: α) : Result Unit :=
-  if i.val < List.length v.val then
-    .ret ()
-  else
-    .fail arrayOutOfBounds
-
-def Vec.index_mut (α : Type u) (v: Vec α) (i: Usize) : Result α :=
-  match v.val.indexOpt i.val with
-  | none => fail .arrayOutOfBounds
-  | some x => ret x
-
-@[pspec]
-theorem Vec.index_mut_spec {α : Type u} [Inhabited α] (v: Vec α) (i: Usize)
-  (hbound : i.val < v.length) :
-  ∃ x, v.index_mut α i = ret x ∧ x = v.val.index i.val := by
-  simp only [index_mut]
-  -- TODO: dependent rewrite
-  have h := List.indexOpt_eq_index v.val i.val (by scalar_tac) (by simp [*])
-  simp [*]
-
-def Vec.index_mut_back (α : Type u) (v: Vec α) (i: Usize) (x: α) : Result (Vec α) :=
+def Vec.update_usize (α : Type u) (v: Vec α) (i: Usize) (x: α) : Result (Vec α) :=
   match v.val.indexOpt i.val with
   | none => fail .arrayOutOfBounds
   | some _ =>
     .ret ⟨ v.val.update i.val x, by have := v.property; simp [*] ⟩
 
 @[pspec]
-theorem Vec.index_mut_back_spec {α : Type u} (v: Vec α) (i: Usize) (x : α)
+theorem Vec.update_usize_spec {α : Type u} (v: Vec α) (i: Usize) (x : α)
   (hbound : i.val < v.length) :
-  ∃ nv, v.index_mut_back α i x = ret nv ∧
+  ∃ nv, v.update_usize α i x = ret nv ∧
   nv.val = v.val.update i.val x
   := by
-  simp only [index_mut_back]
+  simp only [update_usize]
   have h := List.indexOpt_bounds v.val i.val
   split
   . simp_all [length]; cases h <;> scalar_tac
   . simp_all
 
+/- [alloc::vec::Vec::index]: forward function -/
+def Vec.index (T I : Type) (inst : core.slice.index.SliceIndex I (Slice T))
+  (self : Vec T) (i : I) : Result inst.Output :=
+  sorry -- TODO
+
+/- [alloc::vec::Vec::index_mut]: forward function -/
+def Vec.index_mut (T I : Type) (inst : core.slice.index.SliceIndex I (Slice T))
+  (self : Vec T) (i : I) : Result inst.Output :=
+  sorry -- TODO
+
+/- [alloc::vec::Vec::index_mut]: backward function 0 -/
+def Vec.index_mut_back
+  (T I : Type) (inst : core.slice.index.SliceIndex I (Slice T))
+  (self : Vec T) (i : I) (x : inst.Output) : Result (alloc.vec.Vec T) :=
+  sorry -- TODO
+
+/- Trait implementation: [alloc::vec::Vec] -/
+def Vec.coreopsindexIndexInst (T I : Type)
+  (inst : core.slice.index.SliceIndex I (Slice T)) :
+  core.ops.index.Index (alloc.vec.Vec T) I := {
+  Output := inst.Output
+  index := Vec.index T I inst
+}
+
+/- Trait implementation: [alloc::vec::Vec] -/
+def Vec.coreopsindexIndexMutInst (T I : Type)
+  (inst : core.slice.index.SliceIndex I (Slice T)) :
+  core.ops.index.IndexMut (alloc.vec.Vec T) I := {
+  indexInst := Vec.coreopsindexIndexInst T I inst
+  index_mut := Vec.index_mut T I inst
+  index_mut_back := Vec.index_mut_back T I inst
+}
+
+end alloc.vec
+
 end Primitives
diff --git a/backends/lean/Base/Progress/Progress.lean b/backends/lean/Base/Progress/Progress.lean
index ecf05dab..24c6f912 100644
--- a/backends/lean/Base/Progress/Progress.lean
+++ b/backends/lean/Base/Progress/Progress.lean
@@ -383,6 +383,7 @@ namespace Test
   -- #eval showStoredPSpec
   -- #eval showStoredPSpecClass
   -- #eval showStoredPSpecExprClass
+  open alloc.vec
 
   example {ty} {x y : Scalar ty}
     (hmin : Scalar.min ty ≤ x.val + y.val)
@@ -408,7 +409,7 @@ namespace Test
      `α : Type u` where u is quantified, while here we use `α : Type 0` -/
   example {α : Type} (v: Vec α) (i: Usize) (x : α)
     (hbounds : i.val < v.length) :
-    ∃ nv, v.index_mut_back α i x = ret nv ∧
+    ∃ nv, v.update_usize α i x = ret nv ∧
     nv.val = v.val.update i.val x := by
     progress
     simp [*]
diff --git a/compiler/Extract.ml b/compiler/Extract.ml
index 6b6a2686..caa4835f 100644
--- a/compiler/Extract.ml
+++ b/compiler/Extract.ml
@@ -7,2370 +7,8 @@ open Pure
 open PureUtils
 open TranslateCore
 open ExtractBase
-open StringUtils
 open Config
-module F = Format
-
-(** Small helper to compute the name of an int type *)
-let int_name (int_ty : integer_type) =
-  let isize, usize, i_format, u_format =
-    match !backend with
-    | FStar | Coq | HOL4 ->
-        ("isize", "usize", format_of_string "i%d", format_of_string "u%d")
-    | Lean -> ("Isize", "Usize", format_of_string "I%d", format_of_string "U%d")
-  in
-  match int_ty with
-  | Isize -> isize
-  | I8 -> Printf.sprintf i_format 8
-  | I16 -> Printf.sprintf i_format 16
-  | I32 -> Printf.sprintf i_format 32
-  | I64 -> Printf.sprintf i_format 64
-  | I128 -> Printf.sprintf i_format 128
-  | Usize -> usize
-  | U8 -> Printf.sprintf u_format 8
-  | U16 -> Printf.sprintf u_format 16
-  | U32 -> Printf.sprintf u_format 32
-  | U64 -> Printf.sprintf u_format 64
-  | U128 -> Printf.sprintf u_format 128
-
-(** Small helper to compute the name of a unary operation *)
-let unop_name (unop : unop) : string =
-  match unop with
-  | Not -> (
-      match !backend with FStar | Lean -> "not" | Coq -> "negb" | HOL4 -> "~")
-  | Neg (int_ty : integer_type) -> (
-      match !backend with Lean -> "-" | _ -> int_name int_ty ^ "_neg")
-  | Cast _ ->
-      (* We never directly use the unop name in this case *)
-      raise (Failure "Unsupported")
-
-(** Small helper to compute the name of a binary operation (note that many
-    binary operations like "less than" are extracted to primitive operations,
-    like [<]).
- *)
-let named_binop_name (binop : E.binop) (int_ty : integer_type) : string =
-  let binop =
-    match binop with
-    | Div -> "div"
-    | Rem -> "rem"
-    | Add -> "add"
-    | Sub -> "sub"
-    | Mul -> "mul"
-    | Lt -> "lt"
-    | Le -> "le"
-    | Ge -> "ge"
-    | Gt -> "gt"
-    | BitXor -> "xor"
-    | BitAnd -> "and"
-    | BitOr -> "or"
-    | Shl -> "lsl"
-    | Shr ->
-        "asr"
-        (* NOTE: make sure arithmetic shift right is implemented, i.e. OCaml's asr operator, not lsr *)
-    | _ -> raise (Failure "Unreachable")
-  in
-  (* Remark: the Lean case is actually not used *)
-  match !backend with
-  | Lean -> int_name int_ty ^ "." ^ binop
-  | FStar | Coq | HOL4 -> int_name int_ty ^ "_" ^ binop
-
-(** A list of keywords/identifiers used by the backend and with which we
-    want to check collision.
-
-    Remark: this is useful mostly to look for collisions when generating
-    names for *variables*.
- *)
-let keywords () =
-  let named_unops =
-    unop_name Not
-    :: List.map (fun it -> unop_name (Neg it)) T.all_signed_int_types
-  in
-  let named_binops = [ E.Div; Rem; Add; Sub; Mul ] in
-  let named_binops =
-    List.concat_map
-      (fun bn -> List.map (fun it -> named_binop_name bn it) T.all_int_types)
-      named_binops
-  in
-  let misc =
-    match !backend with
-    | FStar ->
-        [
-          "assert";
-          "assert_norm";
-          "assume";
-          "else";
-          "fun";
-          "fn";
-          "FStar";
-          "FStar.Mul";
-          "if";
-          "in";
-          "include";
-          "int";
-          "let";
-          "list";
-          "match";
-          "not";
-          "open";
-          "rec";
-          "scalar_cast";
-          "then";
-          "type";
-          "Type0";
-          "Type";
-          "unit";
-          "val";
-          "with";
-        ]
-    | Coq ->
-        [
-          "assert";
-          "Arguments";
-          "Axiom";
-          "char_of_byte";
-          "Check";
-          "Declare";
-          "Definition";
-          "else";
-          "End";
-          "fun";
-          "Fixpoint";
-          "if";
-          "in";
-          "int";
-          "Inductive";
-          "Import";
-          "let";
-          "Lemma";
-          "match";
-          "Module";
-          "not";
-          "Notation";
-          "Proof";
-          "Qed";
-          "rec";
-          "Record";
-          "Require";
-          "Scope";
-          "Search";
-          "SearchPattern";
-          "Set";
-          "then";
-          (* [tt] is unit *)
-          "tt";
-          "type";
-          "Type";
-          "unit";
-          "with";
-        ]
-    | Lean ->
-        [
-          "by";
-          "class";
-          "decreasing_by";
-          "def";
-          "deriving";
-          "do";
-          "else";
-          "end";
-          "for";
-          "have";
-          "if";
-          "inductive";
-          "instance";
-          "import";
-          "let";
-          "macro";
-          "match";
-          "namespace";
-          "opaque";
-          "open";
-          "run_cmd";
-          "set_option";
-          "simp";
-          "structure";
-          "syntax";
-          "termination_by";
-          "then";
-          "Type";
-          "unsafe";
-          "where";
-          "with";
-          "opaque_defs";
-        ]
-    | HOL4 ->
-        [
-          "Axiom";
-          "case";
-          "Definition";
-          "else";
-          "End";
-          "fix";
-          "fix_exec";
-          "fn";
-          "fun";
-          "if";
-          "in";
-          "int";
-          "Inductive";
-          "let";
-          "of";
-          "Proof";
-          "QED";
-          "then";
-          "Theorem";
-        ]
-  in
-  List.concat [ named_unops; named_binops; misc ]
-
-let assumed_adts () : (assumed_ty * string) list =
-  match !backend with
-  | Lean ->
-      [
-        (State, "State");
-        (Result, "Result");
-        (Error, "Error");
-        (Fuel, "Nat");
-        (Array, "Array");
-        (Slice, "Slice");
-        (Str, "Str");
-        (RawPtr Mut, "MutRawPtr");
-        (RawPtr Const, "ConstRawPtr");
-      ]
-  | Coq | FStar | HOL4 ->
-      [
-        (State, "state");
-        (Result, "result");
-        (Error, "error");
-        (Fuel, if !backend = HOL4 then "num" else "nat");
-        (Array, "array");
-        (Slice, "slice");
-        (Str, "str");
-        (RawPtr Mut, "mut_raw_ptr");
-        (RawPtr Const, "const_raw_ptr");
-      ]
-
-let assumed_struct_constructors () : (assumed_ty * string) list =
-  match !backend with
-  | Lean -> [ (Array, "Array.make") ]
-  | Coq -> [ (Array, "mk_array") ]
-  | FStar -> [ (Array, "mk_array") ]
-  | HOL4 -> [ (Array, "mk_array") ]
-
-let assumed_variants () : (assumed_ty * VariantId.id * string) list =
-  match !backend with
-  | FStar ->
-      [
-        (Result, result_return_id, "Return");
-        (Result, result_fail_id, "Fail");
-        (Error, error_failure_id, "Failure");
-        (Error, error_out_of_fuel_id, "OutOfFuel");
-        (* No Fuel::Zero on purpose *)
-        (* No Fuel::Succ on purpose *)
-      ]
-  | Coq ->
-      [
-        (Result, result_return_id, "Return");
-        (Result, result_fail_id, "Fail_");
-        (Error, error_failure_id, "Failure");
-        (Error, error_out_of_fuel_id, "OutOfFuel");
-        (Fuel, fuel_zero_id, "O");
-        (Fuel, fuel_succ_id, "S");
-      ]
-  | Lean ->
-      [
-        (Result, result_return_id, "ret");
-        (Result, result_fail_id, "fail");
-        (Error, error_failure_id, "panic");
-        (* No Fuel::Zero on purpose *)
-        (* No Fuel::Succ on purpose *)
-      ]
-  | HOL4 ->
-      [
-        (Result, result_return_id, "Return");
-        (Result, result_fail_id, "Fail");
-        (Error, error_failure_id, "Failure");
-        (* No Fuel::Zero on purpose *)
-        (* No Fuel::Succ on purpose *)
-      ]
-
-let assumed_llbc_functions () :
-    (A.assumed_fun_id * T.RegionGroupId.id option * string) list =
-  let rg0 = Some T.RegionGroupId.zero in
-  match !backend with
-  | FStar | Coq | HOL4 ->
-      [
-        (ArrayIndexShared, None, "array_index_shared");
-        (ArrayIndexMut, None, "array_index_mut_fwd");
-        (ArrayIndexMut, rg0, "array_index_mut_back");
-        (ArrayToSliceShared, None, "array_to_slice_shared");
-        (ArrayToSliceMut, None, "array_to_slice_mut_fwd");
-        (ArrayToSliceMut, rg0, "array_to_slice_mut_back");
-        (ArrayRepeat, None, "array_repeat");
-        (SliceIndexShared, None, "slice_index_shared");
-        (SliceIndexMut, None, "slice_index_mut_fwd");
-        (SliceIndexMut, rg0, "slice_index_mut_back");
-        (SliceLen, None, "slice_len");
-      ]
-  | Lean ->
-      [
-        (ArrayIndexShared, None, "Array.index_shared");
-        (ArrayIndexMut, None, "Array.index_mut");
-        (ArrayIndexMut, rg0, "Array.index_mut_back");
-        (ArrayToSliceShared, None, "Array.to_slice_shared");
-        (ArrayToSliceMut, None, "Array.to_slice_mut");
-        (ArrayToSliceMut, rg0, "Array.to_slice_mut_back");
-        (ArrayRepeat, None, "Array.repeat");
-        (SliceIndexShared, None, "Slice.index_shared");
-        (SliceIndexMut, None, "Slice.index_mut");
-        (SliceIndexMut, rg0, "Slice.index_mut_back");
-        (SliceLen, None, "Slice.len");
-      ]
-
-let assumed_pure_functions () : (pure_assumed_fun_id * string) list =
-  match !backend with
-  | FStar ->
-      [
-        (Return, "return");
-        (Fail, "fail");
-        (Assert, "massert");
-        (FuelDecrease, "decrease");
-        (FuelEqZero, "is_zero");
-      ]
-  | Coq ->
-      (* We don't provide [FuelDecrease] and [FuelEqZero] on purpose *)
-      [ (Return, "return_"); (Fail, "fail_"); (Assert, "massert") ]
-  | Lean ->
-      (* We don't provide [FuelDecrease] and [FuelEqZero] on purpose *)
-      [ (Return, "return"); (Fail, "fail_"); (Assert, "massert") ]
-  | HOL4 ->
-      (* We don't provide [FuelDecrease] and [FuelEqZero] on purpose *)
-      [ (Return, "return"); (Fail, "fail"); (Assert, "massert") ]
-
-let names_map_init () : names_map_init =
-  {
-    keywords = keywords ();
-    assumed_adts = assumed_adts ();
-    assumed_structs = assumed_struct_constructors ();
-    assumed_variants = assumed_variants ();
-    assumed_llbc_functions = assumed_llbc_functions ();
-    assumed_pure_functions = assumed_pure_functions ();
-  }
-
-let extract_unop (extract_expr : bool -> texpression -> unit)
-    (fmt : F.formatter) (inside : bool) (unop : unop) (arg : texpression) : unit
-    =
-  match unop with
-  | Not | Neg _ ->
-      let unop = unop_name unop in
-      if inside then F.pp_print_string fmt "(";
-      F.pp_print_string fmt unop;
-      F.pp_print_space fmt ();
-      extract_expr true arg;
-      if inside then F.pp_print_string fmt ")"
-  | Cast (src, tgt) -> (
-      (* HOL4 has a special treatment: because it doesn't support dependent
-         types, we don't have a specific operator for the cast *)
-      match !backend with
-      | HOL4 ->
-          (* Casting, say, an u32 to an i32 would be done as follows:
-             {[
-               mk_i32 (u32_to_int x)
-             ]}
-          *)
-          if inside then F.pp_print_string fmt "(";
-          F.pp_print_string fmt ("mk_" ^ int_name tgt);
-          F.pp_print_space fmt ();
-          F.pp_print_string fmt "(";
-          F.pp_print_string fmt (int_name src ^ "_to_int");
-          F.pp_print_space fmt ();
-          extract_expr true arg;
-          F.pp_print_string fmt ")";
-          if inside then F.pp_print_string fmt ")"
-      | FStar | Coq | Lean ->
-          (* Rem.: the source type is an implicit parameter *)
-          if inside then F.pp_print_string fmt "(";
-          let cast_str =
-            match !backend with
-            | Coq | FStar -> "scalar_cast"
-            | Lean -> (* TODO: I8.cast, I16.cast, etc.*) "Scalar.cast"
-            | HOL4 -> raise (Failure "Unreachable")
-          in
-          F.pp_print_string fmt cast_str;
-          F.pp_print_space fmt ();
-          if !backend <> Lean then (
-            F.pp_print_string fmt
-              (StringUtils.capitalize_first_letter
-                 (PrintPure.integer_type_to_string src));
-            F.pp_print_space fmt ());
-          if !backend = Lean then F.pp_print_string fmt ("." ^ int_name tgt)
-          else
-            F.pp_print_string fmt
-              (StringUtils.capitalize_first_letter
-                 (PrintPure.integer_type_to_string tgt));
-          F.pp_print_space fmt ();
-          extract_expr true arg;
-          if inside then F.pp_print_string fmt ")")
-
-(** [extract_expr] : the boolean argument is [inside] *)
-let extract_binop (extract_expr : bool -> texpression -> unit)
-    (fmt : F.formatter) (inside : bool) (binop : E.binop)
-    (int_ty : integer_type) (arg0 : texpression) (arg1 : texpression) : unit =
-  if inside then F.pp_print_string fmt "(";
-  (* Some binary operations have a special notation depending on the backend *)
-  (match (!backend, binop) with
-  | HOL4, (Eq | Ne)
-  | (FStar | Coq | Lean), (Eq | Lt | Le | Ne | Ge | Gt)
-  | Lean, (Div | Rem | Add | Sub | Mul) ->
-      let binop =
-        match binop with
-        | Eq -> "="
-        | Lt -> "<"
-        | Le -> "<="
-        | Ne -> if !backend = Lean then "!=" else "<>"
-        | Ge -> ">="
-        | Gt -> ">"
-        | Div -> "/"
-        | Rem -> "%"
-        | Add -> "+"
-        | Sub -> "-"
-        | Mul -> "*"
-        | _ -> raise (Failure "Unreachable")
-      in
-      let binop =
-        match !backend with FStar | Lean | HOL4 -> binop | Coq -> "s" ^ binop
-      in
-      extract_expr false arg0;
-      F.pp_print_space fmt ();
-      F.pp_print_string fmt binop;
-      F.pp_print_space fmt ();
-      extract_expr false arg1
-  | _ ->
-      let binop = named_binop_name binop int_ty in
-      F.pp_print_string fmt binop;
-      F.pp_print_space fmt ();
-      extract_expr true arg0;
-      F.pp_print_space fmt ();
-      extract_expr true arg1);
-  if inside then F.pp_print_string fmt ")"
-
-let type_decl_kind_to_qualif (kind : decl_kind)
-    (type_kind : type_decl_kind option) : string option =
-  match !backend with
-  | FStar -> (
-      match kind with
-      | SingleNonRec -> Some "type"
-      | SingleRec -> Some "type"
-      | MutRecFirst -> Some "type"
-      | MutRecInner -> Some "and"
-      | MutRecLast -> Some "and"
-      | Assumed -> Some "assume type"
-      | Declared -> Some "val")
-  | Coq -> (
-      match (kind, type_kind) with
-      | SingleNonRec, Some Enum -> Some "Inductive"
-      | SingleNonRec, Some Struct -> Some "Record"
-      | (SingleRec | MutRecFirst), Some _ -> Some "Inductive"
-      | (MutRecInner | MutRecLast), Some _ ->
-          (* Coq doesn't support groups of mutually recursive definitions which mix
-           * records and inducties: we convert everything to records if this happens
-           *)
-          Some "with"
-      | (Assumed | Declared), None -> Some "Axiom"
-      | SingleNonRec, None ->
-          (* This is for traits *)
-          Some "Record"
-      | _ ->
-          raise
-            (Failure
-               ("Unexpected: (" ^ show_decl_kind kind ^ ", "
-               ^ Print.option_to_string show_type_decl_kind type_kind
-               ^ ")")))
-  | Lean -> (
-      match kind with
-      | SingleNonRec ->
-          if type_kind = Some Struct then Some "structure" else Some "inductive"
-      | SingleRec -> Some "inductive"
-      | MutRecFirst -> Some "inductive"
-      | MutRecInner -> Some "inductive"
-      | MutRecLast -> Some "inductive"
-      | Assumed -> Some "axiom"
-      | Declared -> Some "axiom")
-  | HOL4 -> None
-
-let fun_decl_kind_to_qualif (kind : decl_kind) : string option =
-  match !backend with
-  | FStar -> (
-      match kind with
-      | SingleNonRec -> Some "let"
-      | SingleRec -> Some "let rec"
-      | MutRecFirst -> Some "let rec"
-      | MutRecInner -> Some "and"
-      | MutRecLast -> Some "and"
-      | Assumed -> Some "assume val"
-      | Declared -> Some "val")
-  | Coq -> (
-      match kind with
-      | SingleNonRec -> Some "Definition"
-      | SingleRec -> Some "Fixpoint"
-      | MutRecFirst -> Some "Fixpoint"
-      | MutRecInner -> Some "with"
-      | MutRecLast -> Some "with"
-      | Assumed -> Some "Axiom"
-      | Declared -> Some "Axiom")
-  | Lean -> (
-      match kind with
-      | SingleNonRec -> Some "def"
-      | SingleRec -> Some "divergent def"
-      | MutRecFirst -> Some "mutual divergent def"
-      | MutRecInner -> Some "divergent def"
-      | MutRecLast -> Some "divergent def"
-      | Assumed -> Some "axiom"
-      | Declared -> Some "axiom")
-  | HOL4 -> None
-
-(** The type of types.
-
-    TODO: move inside the formatter?
- *)
-let type_keyword () =
-  match !backend with
-  | FStar -> "Type0"
-  | Coq | Lean -> "Type"
-  | HOL4 -> raise (Failure "Unexpected")
-
-(**
-   [ctx]: we use the context to lookup type definitions, to retrieve type names.
-   This is used to compute variable names, when they have no basenames: in this
-   case we use the first letter of the type name.
-
-   [variant_concatenate_type_name]: if true, add the type name as a prefix
-   to the variant names.
-   Ex.:
-   In Rust:
-     {[
-       enum List = {
-         Cons(u32, Box<List>),x
-         Nil,
-       }
-     ]}
-
-   F*, if option activated:
-     {[
-       type list =
-       | ListCons : u32 -> list -> list
-       | ListNil : list
-     ]}
-
-   F*, if option not activated:
-     {[
-       type list =
-       | Cons : u32 -> list -> list
-       | Nil : list
-     ]}
-
-   Rk.: this should be true by default, because in Rust all the variant names
-   are actively uniquely identifier by the type name [List::Cons(...)], while
-   in other languages it is not necessarily the case, and thus clashes can mess
-   up type checking. Note that some languages actually forbids the name clashes
-   (it is the case of F* ).
- *)
-let mk_formatter (ctx : trans_ctx) (crate_name : string)
-    (variant_concatenate_type_name : bool) : formatter =
-  let int_name = int_name in
-
-  (* Prepare a name.
-   * The first id elem is always the crate: if it is the local crate,
-   * we remove it.
-   * We also remove all the disambiguators, then convert everything to strings.
-   * **Rmk:** because we remove the disambiguators, there may be name collisions
-   * (which is ok, because we check for name collisions and fail if there is any).
-   *)
-  let get_name (name : name) : string list =
-    (* Rmk.: initially we only filtered the disambiguators equal to 0 *)
-    let name = Names.filter_disambiguators name in
-    match name with
-    | Ident crate :: name ->
-        let name = if crate = crate_name then name else Ident crate :: name in
-        let name =
-          List.map
-            (function
-              | Names.Ident s -> s
-              | Disambiguator d -> Names.Disambiguator.to_string d)
-            name
-        in
-        name
-    | _ ->
-        raise (Failure ("Unexpected name shape: " ^ Print.name_to_string name))
-  in
-  let flatten_name (name : string list) : string =
-    match !backend with
-    | FStar | Coq | HOL4 -> String.concat "_" name
-    | Lean -> String.concat "." name
-  in
-  let get_type_name = get_name in
-  let type_name_to_camel_case name =
-    let name = get_type_name name in
-    let name = List.map to_camel_case name in
-    String.concat "" name
-  in
-  let type_name_to_snake_case name =
-    let name = get_type_name name in
-    let name = List.map to_snake_case name in
-    let name = String.concat "_" name in
-    match !backend with
-    | FStar | Lean | HOL4 -> name
-    | Coq -> capitalize_first_letter name
-  in
-  let type_name name =
-    match !backend with
-    | FStar | Coq | HOL4 -> type_name_to_snake_case name ^ "_t"
-    | Lean -> String.concat "." (get_type_name name)
-  in
-  let field_name (def_name : name) (field_id : FieldId.id)
-      (field_name : string option) : string =
-    let field_name_s =
-      match field_name with
-      | Some field_name -> field_name
-      | None ->
-          (* TODO: extract structs with no field names to tuples *)
-          FieldId.to_string field_id
-    in
-    if !Config.record_fields_short_names then
-      if field_name = None then (* TODO: this is a bit ugly *)
-        "_" ^ field_name_s
-      else field_name_s
-    else
-      let def_name = type_name_to_snake_case def_name ^ "_" in
-      def_name ^ field_name_s
-  in
-  let variant_name (def_name : name) (variant : string) : string =
-    match !backend with
-    | FStar | Coq | HOL4 ->
-        let variant = to_camel_case variant in
-        if variant_concatenate_type_name then
-          type_name_to_camel_case def_name ^ variant
-        else variant
-    | Lean -> variant
-  in
-  let struct_constructor (basename : name) : string =
-    let tname = type_name basename in
-    let prefix =
-      match !backend with FStar -> "Mk" | Coq | HOL4 -> "mk" | Lean -> ""
-    in
-    let suffix =
-      match !backend with FStar | Coq | HOL4 -> "" | Lean -> ".mk"
-    in
-    prefix ^ tname ^ suffix
-  in
-  let get_fun_name fname =
-    let fname = get_name fname in
-    (* TODO: don't convert to snake case for Coq, HOL4, F* *)
-    flatten_name fname
-  in
-  let global_name (name : global_name) : string =
-    (* Converting to snake case also lowercases the letters (in Rust, global
-     * names are written in capital letters). *)
-    let parts = List.map to_snake_case (get_name name) in
-    String.concat "_" parts
-  in
-  let fun_name (fname : fun_name) (num_loops : int) (loop_id : LoopId.id option)
-      (num_rgs : int) (rg : region_group_info option) (filter_info : bool * int)
-      : string =
-    let fname = get_fun_name fname in
-    (* Compute the suffix *)
-    let suffix = default_fun_suffix num_loops loop_id num_rgs rg filter_info in
-    (* Concatenate *)
-    fname ^ suffix
-  in
-
-  let trait_decl_name (trait_decl : trait_decl) : string =
-    type_name trait_decl.name
-  in
-
-  let trait_impl_name (trait_decl : trait_decl) (trait_impl : trait_impl) :
-      string =
-    (* TODO: provisional: we concatenate the trait impl name (which is its type)
-       with the trait decl name *)
-    let trait_decl =
-      let name = trait_decl.name in
-      match !backend with
-      | FStar | Coq | HOL4 -> type_name_to_snake_case name ^ "_inst"
-      | Lean -> String.concat "" (get_type_name name) ^ "Inst"
-    in
-    flatten_name (get_type_name trait_impl.name @ [ trait_decl ])
-  in
-
-  let trait_parent_clause_name (trait_decl : trait_decl) (clause : trait_clause)
-      : string =
-    (* TODO: improve - it would be better to not use indices *)
-    let clause = "parent_clause_" ^ TraitClauseId.to_string clause.clause_id in
-    if !Config.record_fields_short_names then clause
-    else trait_decl_name trait_decl ^ "_" ^ clause
-  in
-  let trait_type_name (trait_decl : trait_decl) (item : string) : string =
-    if !Config.record_fields_short_names then item
-    else trait_decl_name trait_decl ^ "_" ^ item
-  in
-  let trait_const_name (trait_decl : trait_decl) (item : string) : string =
-    if !Config.record_fields_short_names then item
-    else trait_decl_name trait_decl ^ "_" ^ item
-  in
-  let trait_method_name (trait_decl : trait_decl) (item : string) : string =
-    if !Config.record_fields_short_names then item
-    else trait_decl_name trait_decl ^ "_" ^ item
-  in
-  let trait_type_clause_name (trait_decl : trait_decl) (item : string)
-      (clause : trait_clause) : string =
-    (* TODO: improve - it would be better to not use indices *)
-    trait_type_name trait_decl item
-    ^ "_clause_"
-    ^ TraitClauseId.to_string clause.clause_id
-  in
-
-  let termination_measure_name (_fid : A.FunDeclId.id) (fname : fun_name)
-      (num_loops : int) (loop_id : LoopId.id option) : string =
-    let fname = get_fun_name fname in
-    let lp_suffix = default_fun_loop_suffix num_loops loop_id in
-    (* Compute the suffix *)
-    let suffix =
-      match !Config.backend with
-      | FStar -> "_decreases"
-      | Lean -> "_terminates"
-      | Coq | HOL4 -> raise (Failure "Unexpected")
-    in
-    (* Concatenate *)
-    fname ^ lp_suffix ^ suffix
-  in
-
-  let decreases_proof_name (_fid : A.FunDeclId.id) (fname : fun_name)
-      (num_loops : int) (loop_id : LoopId.id option) : string =
-    let fname = get_fun_name fname in
-    let lp_suffix = default_fun_loop_suffix num_loops loop_id in
-    (* Compute the suffix *)
-    let suffix =
-      match !Config.backend with
-      | Lean -> "_decreases"
-      | FStar | Coq | HOL4 -> raise (Failure "Unexpected")
-    in
-    (* Concatenate *)
-    fname ^ lp_suffix ^ suffix
-  in
-
-  let var_basename (_varset : StringSet.t) (basename : string option) (ty : ty)
-      : string =
-    (* Small helper to derive var names from ADT type names.
-
-       We do the following:
-       - convert the type name to snake case
-       - take the first letter of every "letter group"
-       Ex.: "HashMap" -> "hash_map" -> "hm"
-    *)
-    let name_from_type_ident (name : string) : string =
-      let cl = to_snake_case name in
-      let cl = String.split_on_char '_' cl in
-      let cl = List.filter (fun s -> String.length s > 0) cl in
-      assert (List.length cl > 0);
-      let cl = List.map (fun s -> s.[0]) cl in
-      StringUtils.string_of_chars cl
-    in
-    (* If there is a basename, we use it *)
-    match basename with
-    | Some basename ->
-        (* This should be a no-op *)
-        to_snake_case basename
-    | None -> (
-        (* No basename: we use the first letter of the type *)
-        match ty with
-        | Adt (type_id, generics) -> (
-            match type_id with
-            | Tuple ->
-                (* The "pair" case is frequent enough to have its special treatment *)
-                if List.length generics.types = 2 then "p" else "t"
-            | Assumed Result -> "r"
-            | Assumed Error -> ConstStrings.error_basename
-            | Assumed Fuel -> ConstStrings.fuel_basename
-            | Assumed Array -> "a"
-            | Assumed Slice -> "s"
-            | Assumed Str -> "s"
-            | Assumed State -> ConstStrings.state_basename
-            | Assumed (RawPtr _) -> "p"
-            | AdtId adt_id ->
-                let def = TypeDeclId.Map.find adt_id ctx.type_ctx.type_decls in
-                (* Derive the var name from the last ident of the type name
-                 * Ex.: ["hashmap"; "HashMap"] ~~> "HashMap" -> "hash_map" -> "hm"
-                 *)
-                (* The name shouldn't be empty, and its last element should
-                 * be an ident *)
-                let cl = List.nth def.name (List.length def.name - 1) in
-                name_from_type_ident (Names.as_ident cl))
-        | TypeVar _ -> (
-            (* TODO: use "t" also for F* *)
-            match !backend with
-            | FStar -> "x" (* lacking inspiration here... *)
-            | Coq | Lean | HOL4 -> "t" (* lacking inspiration here... *))
-        | Literal lty -> (
-            match lty with Bool -> "b" | Char -> "c" | Integer _ -> "i")
-        | Arrow _ -> "f"
-        | TraitType (_, _, name) -> name_from_type_ident name)
-  in
-  let type_var_basename (_varset : StringSet.t) (basename : string) : string =
-    (* Rust type variables are snake-case and start with a capital letter *)
-    match !backend with
-    | FStar ->
-        (* This is *not* a no-op: this removes the capital letter *)
-        to_snake_case basename
-    | HOL4 ->
-        (* In HOL4, type variable names must start with "'" *)
-        "'" ^ to_snake_case basename
-    | Coq | Lean -> basename
-  in
-  let const_generic_var_basename (_varset : StringSet.t) (basename : string) :
-      string =
-    (* Rust type variables are snake-case and start with a capital letter *)
-    match !backend with
-    | FStar | HOL4 ->
-        (* This is *not* a no-op: this removes the capital letter *)
-        to_snake_case basename
-    | Coq | Lean -> basename
-  in
-  let trait_clause_basename (_varset : StringSet.t) (_clause : trait_clause) :
-      string =
-    (* TODO: actually use the clause to derive the name *)
-    "inst"
-  in
-  let trait_self_clause_basename = "self_clause" in
-  let append_index (basename : string) (i : int) : string =
-    basename ^ string_of_int i
-  in
-
-  let extract_literal (fmt : F.formatter) (inside : bool) (cv : literal) : unit
-      =
-    match cv with
-    | Scalar sv -> (
-        match !backend with
-        | FStar -> F.pp_print_string fmt (Z.to_string sv.PV.value)
-        | Coq | HOL4 | Lean ->
-            let print_brackets = inside && !backend = HOL4 in
-            if print_brackets then F.pp_print_string fmt "(";
-            (match !backend with
-            | Coq | Lean -> ()
-            | HOL4 ->
-                F.pp_print_string fmt ("int_to_" ^ int_name sv.PV.int_ty);
-                F.pp_print_space fmt ()
-            | _ -> raise (Failure "Unreachable"));
-            (* We need to add parentheses if the value is negative *)
-            if sv.PV.value >= Z.of_int 0 then
-              F.pp_print_string fmt (Z.to_string sv.PV.value)
-            else if !backend = Lean then
-              (* TODO: parsing issues with Lean because there are ambiguous
-                 interpretations between int values and nat values *)
-              F.pp_print_string fmt
-                ("(-(" ^ Z.to_string (Z.neg sv.PV.value) ^ ":Int))")
-            else F.pp_print_string fmt ("(" ^ Z.to_string sv.PV.value ^ ")");
-            (match !backend with
-            | Coq ->
-                let iname = int_name sv.PV.int_ty in
-                F.pp_print_string fmt ("%" ^ iname)
-            | Lean ->
-                let iname = String.lowercase_ascii (int_name sv.PV.int_ty) in
-                F.pp_print_string fmt ("#" ^ iname)
-            | HOL4 -> ()
-            | _ -> raise (Failure "Unreachable"));
-            if print_brackets then F.pp_print_string fmt ")")
-    | Bool b ->
-        let b =
-          match !backend with
-          | HOL4 -> if b then "T" else "F"
-          | Coq | FStar | Lean -> if b then "true" else "false"
-        in
-        F.pp_print_string fmt b
-    | Char c -> (
-        match !backend with
-        | HOL4 ->
-            (* [#"a"] is a notation for [CHR 97] (97 is the ASCII code for 'a') *)
-            F.pp_print_string fmt ("#\"" ^ String.make 1 c ^ "\"")
-        | FStar | Lean -> F.pp_print_string fmt ("'" ^ String.make 1 c ^ "'")
-        | Coq ->
-            if inside then F.pp_print_string fmt "(";
-            F.pp_print_string fmt "char_of_byte";
-            F.pp_print_space fmt ();
-            (* Convert the the char to ascii *)
-            let c =
-              let i = Char.code c in
-              let x0 = i / 16 in
-              let x1 = i mod 16 in
-              "Coq.Init.Byte.x" ^ string_of_int x0 ^ string_of_int x1
-            in
-            F.pp_print_string fmt c;
-            if inside then F.pp_print_string fmt ")")
-  in
-  let bool_name = if !backend = Lean then "Bool" else "bool" in
-  let char_name = if !backend = Lean then "Char" else "char" in
-  let str_name = if !backend = Lean then "String" else "string" in
-  {
-    bool_name;
-    char_name;
-    int_name;
-    str_name;
-    type_decl_kind_to_qualif;
-    fun_decl_kind_to_qualif;
-    field_name;
-    variant_name;
-    struct_constructor;
-    type_name;
-    global_name;
-    fun_name;
-    termination_measure_name;
-    decreases_proof_name;
-    trait_decl_name;
-    trait_impl_name;
-    trait_parent_clause_name;
-    trait_const_name;
-    trait_type_name;
-    trait_method_name;
-    trait_type_clause_name;
-    var_basename;
-    type_var_basename;
-    const_generic_var_basename;
-    trait_self_clause_basename;
-    trait_clause_basename;
-    append_index;
-    extract_literal;
-    extract_unop;
-    extract_binop;
-  }
-
-let mk_formatter_and_names_map (ctx : trans_ctx) (crate_name : string)
-    (variant_concatenate_type_name : bool) : formatter * names_map =
-  let fmt = mk_formatter ctx crate_name variant_concatenate_type_name in
-  let names_map = initialize_names_map fmt (names_map_init ()) in
-  (fmt, names_map)
-
-let is_single_opaque_fun_decl_group (dg : Pure.fun_decl list) : bool =
-  match dg with [ d ] -> d.body = None | _ -> false
-
-let is_single_opaque_type_decl_group (dg : Pure.type_decl list) : bool =
-  match dg with [ d ] -> d.kind = Opaque | _ -> false
-
-let is_empty_record_type_decl (d : Pure.type_decl) : bool = d.kind = Struct []
-
-let is_empty_record_type_decl_group (dg : Pure.type_decl list) : bool =
-  match dg with [ d ] -> is_empty_record_type_decl d | _ -> false
-
-(** In some provers, groups of definitions must be delimited.
-
-    - in Coq, *every* group (including singletons) must end with "."
-    - in Lean, groups of mutually recursive definitions must end with "end"
-    - in HOL4 (in most situations) the whole group must be within a `Define` command
-
-    Calls to {!extract_fun_decl} should be inserted between calls to
-    {!start_fun_decl_group} and {!end_fun_decl_group}.
-
-    TODO: maybe those [{start/end}_decl_group] functions are not that much a good
-    idea and we should merge them with the corresponding [extract_decl] functions.
- *)
-let start_fun_decl_group (ctx : extraction_ctx) (fmt : F.formatter)
-    (is_rec : bool) (dg : Pure.fun_decl list) =
-  match !backend with
-  | FStar | Coq | Lean -> ()
-  | HOL4 ->
-      (* In HOL4, opaque functions have a special treatment *)
-      if is_single_opaque_fun_decl_group dg then ()
-      else
-        let compute_fun_def_name (def : Pure.fun_decl) : string =
-          ctx_get_local_function def.def_id def.loop_id def.back_id ctx ^ "_def"
-        in
-        let names = List.map compute_fun_def_name dg in
-        (* Add a break before *)
-        F.pp_print_break fmt 0 0;
-        (* Open the box for the delimiters *)
-        F.pp_open_vbox fmt 0;
-        (* Open the box for the definitions themselves *)
-        F.pp_open_vbox fmt ctx.indent_incr;
-        (* Print the delimiters *)
-        if is_rec then
-          F.pp_print_string fmt
-            ("val [" ^ String.concat ", " names ^ "] = DefineDiv ‘")
-        else (
-          assert (List.length names = 1);
-          let name = List.hd names in
-          F.pp_print_string fmt ("val " ^ name ^ " = Define ‘"));
-        F.pp_print_cut fmt ()
-
-(** See {!start_fun_decl_group}. *)
-let end_fun_decl_group (fmt : F.formatter) (is_rec : bool)
-    (dg : Pure.fun_decl list) =
-  match !backend with
-  | FStar -> ()
-  | Coq ->
-      (* For aesthetic reasons, we print the Coq end group delimiter directly
-         in {!extract_fun_decl}. *)
-      ()
-  | Lean ->
-      (* We must add the "end" keyword to groups of mutually recursive functions *)
-      if is_rec && List.length dg > 1 then (
-        F.pp_print_cut fmt ();
-        F.pp_print_string fmt "end";
-        (* Add breaks to insert new lines between definitions *)
-        F.pp_print_break fmt 0 0)
-      else ()
-  | HOL4 ->
-      (* In HOL4, opaque functions have a special treatment *)
-      if is_single_opaque_fun_decl_group dg then ()
-      else (
-        (* Close the box for the definitions *)
-        F.pp_close_box fmt ();
-        (* Print the end delimiter *)
-        F.pp_print_cut fmt ();
-        F.pp_print_string fmt "’";
-        (* Close the box for the delimiters *)
-        F.pp_close_box fmt ();
-        (* Add breaks to insert new lines between definitions *)
-        F.pp_print_break fmt 0 0)
-
-(** See {!start_fun_decl_group}: similar usage, but for the type declarations. *)
-let start_type_decl_group (ctx : extraction_ctx) (fmt : F.formatter)
-    (is_rec : bool) (dg : Pure.type_decl list) =
-  match !backend with
-  | FStar | Coq -> ()
-  | Lean ->
-      if is_rec && List.length dg > 1 then (
-        F.pp_print_space fmt ();
-        F.pp_print_string fmt "mutual";
-        F.pp_print_space fmt ())
-  | HOL4 ->
-      (* In HOL4, opaque types and empty records have a special treatment *)
-      if
-        is_single_opaque_type_decl_group dg
-        || is_empty_record_type_decl_group dg
-      then ()
-      else (
-        (* Add a break before *)
-        F.pp_print_break fmt 0 0;
-        (* Open the box for the delimiters *)
-        F.pp_open_vbox fmt 0;
-        (* Open the box for the definitions themselves *)
-        F.pp_open_vbox fmt ctx.indent_incr;
-        (* Print the delimiters *)
-        F.pp_print_string fmt "Datatype:";
-        F.pp_print_cut fmt ())
-
-(** See {!start_fun_decl_group}. *)
-let end_type_decl_group (fmt : F.formatter) (is_rec : bool)
-    (dg : Pure.type_decl list) =
-  match !backend with
-  | FStar -> ()
-  | Coq ->
-      (* For aesthetic reasons, we print the Coq end group delimiter directly
-         in {!extract_fun_decl}. *)
-      ()
-  | Lean ->
-      (* We must add the "end" keyword to groups of mutually recursive functions *)
-      if is_rec && List.length dg > 1 then (
-        F.pp_print_cut fmt ();
-        F.pp_print_string fmt "end";
-        (* Add breaks to insert new lines between definitions *)
-        F.pp_print_break fmt 0 0)
-      else ()
-  | HOL4 ->
-      (* In HOL4, opaque types and empty records have a special treatment *)
-      if
-        is_single_opaque_type_decl_group dg
-        || is_empty_record_type_decl_group dg
-      then ()
-      else (
-        (* Close the box for the definitions *)
-        F.pp_close_box fmt ();
-        (* Print the end delimiter *)
-        F.pp_print_cut fmt ();
-        F.pp_print_string fmt "End";
-        (* Close the box for the delimiters *)
-        F.pp_close_box fmt ();
-        (* Add breaks to insert new lines between definitions *)
-        F.pp_print_break fmt 0 0)
-
-let unit_name () =
-  match !backend with Lean -> "Unit" | Coq | FStar | HOL4 -> "unit"
-
-(** Small helper *)
-let extract_arrow (fmt : F.formatter) () : unit =
-  if !Config.backend = Lean then F.pp_print_string fmt "→"
-  else F.pp_print_string fmt "->"
-
-let extract_const_generic (ctx : extraction_ctx) (fmt : F.formatter)
-    (inside : bool) (cg : const_generic) : unit =
-  match cg with
-  | ConstGenericGlobal id ->
-      let s = ctx_get_global id ctx in
-      F.pp_print_string fmt s
-  | ConstGenericValue v -> ctx.fmt.extract_literal fmt inside v
-  | ConstGenericVar id ->
-      let s = ctx_get_const_generic_var id ctx in
-      F.pp_print_string fmt s
-
-let extract_literal_type (ctx : extraction_ctx) (fmt : F.formatter)
-    (ty : literal_type) : unit =
-  match ty with
-  | Bool -> F.pp_print_string fmt ctx.fmt.bool_name
-  | Char -> F.pp_print_string fmt ctx.fmt.char_name
-  | Integer int_ty -> F.pp_print_string fmt (ctx.fmt.int_name int_ty)
-
-(** [inside] constrols whether we should add parentheses or not around type
-    applications (if [true] we add parentheses).
-
-    [no_params_tys]: for all the types inside this set, do not print the type parameters.
-    This is used for HOL4. As polymorphism is uniform in HOL4, printing the
-    type parameters in the recursive definitions is useless (and actually
-    forbidden).
-
-    For instance, where in F* we would write:
-    {[
-      type list a = | Nil : list a | Cons : a -> list a -> list a
-    ]}
-
-    In HOL4 we would simply write:
-    {[
-      Datatype:
-        list = Nil 'a | Cons 'a list
-      End
-    ]}
- *)
-let rec extract_ty (ctx : extraction_ctx) (fmt : F.formatter)
-    (no_params_tys : TypeDeclId.Set.t) (inside : bool) (ty : ty) : unit =
-  let extract_rec = extract_ty ctx fmt no_params_tys in
-  match ty with
-  | Adt (type_id, generics) -> (
-      let has_params = generics <> empty_generic_args in
-      match type_id with
-      | Tuple ->
-          (* This is a bit annoying, but in F*/Coq/HOL4 [()] is not the unit type:
-           * we have to write [unit]... *)
-          if generics.types = [] then F.pp_print_string fmt (unit_name ())
-          else (
-            F.pp_print_string fmt "(";
-            Collections.List.iter_link
-              (fun () ->
-                F.pp_print_space fmt ();
-                let product =
-                  match !backend with
-                  | FStar -> "&"
-                  | Coq -> "*"
-                  | Lean -> "×"
-                  | HOL4 -> "#"
-                in
-                F.pp_print_string fmt product;
-                F.pp_print_space fmt ())
-              (extract_rec true) generics.types;
-            F.pp_print_string fmt ")")
-      | AdtId _ | Assumed _ -> (
-          (* HOL4 behaves differently. Where in Coq/FStar/Lean we would write:
-             `tree a b`
-
-             In HOL4 we would write:
-             `('a, 'b) tree`
-          *)
-          match !backend with
-          | FStar | Coq | Lean ->
-              let print_paren = inside && has_params in
-              if print_paren then F.pp_print_string fmt "(";
-              (* TODO: for now, only the opaque *functions* are extracted in the
-                 opaque module. The opaque *types* are assumed. *)
-              F.pp_print_string fmt (ctx_get_type type_id ctx);
-              (* We might need to filter the type arguments, if the type
-                 is builtin (for instance, we filter the global allocator type
-                 argument for `Vec`). *)
-              let generics =
-                match type_id with
-                | AdtId id -> (
-                    match
-                      TypeDeclId.Map.find_opt id ctx.types_filter_type_args_map
-                    with
-                    | None -> generics
-                    | Some filter ->
-                        let types = List.combine filter generics.types in
-                        let types =
-                          List.filter_map
-                            (fun (b, ty) -> if b then Some ty else None)
-                            types
-                        in
-                        { generics with types })
-                | _ -> generics
-              in
-              extract_generic_args ctx fmt no_params_tys generics;
-              if print_paren then F.pp_print_string fmt ")"
-          | HOL4 ->
-              let { types; const_generics; trait_refs } = generics in
-              (* Const generics are not supported in HOL4 *)
-              assert (const_generics = []);
-              let print_tys =
-                match type_id with
-                | AdtId id -> not (TypeDeclId.Set.mem id no_params_tys)
-                | Assumed _ -> true
-                | _ -> raise (Failure "Unreachable")
-              in
-              if types <> [] && print_tys then (
-                let print_paren = List.length types > 1 in
-                if print_paren then F.pp_print_string fmt "(";
-                Collections.List.iter_link
-                  (fun () ->
-                    F.pp_print_string fmt ",";
-                    F.pp_print_space fmt ())
-                  (extract_rec true) types;
-                if print_paren then F.pp_print_string fmt ")";
-                F.pp_print_space fmt ());
-              F.pp_print_string fmt (ctx_get_type type_id ctx);
-              if trait_refs <> [] then (
-                F.pp_print_space fmt ();
-                Collections.List.iter_link (F.pp_print_space fmt)
-                  (extract_trait_ref ctx fmt no_params_tys true)
-                  trait_refs)))
-  | TypeVar vid -> F.pp_print_string fmt (ctx_get_type_var vid ctx)
-  | Literal lty -> extract_literal_type ctx fmt lty
-  | Arrow (arg_ty, ret_ty) ->
-      if inside then F.pp_print_string fmt "(";
-      extract_rec false arg_ty;
-      F.pp_print_space fmt ();
-      extract_arrow fmt ();
-      F.pp_print_space fmt ();
-      extract_rec false ret_ty;
-      if inside then F.pp_print_string fmt ")"
-  | TraitType (trait_ref, generics, type_name) ->
-      if !parameterize_trait_types then raise (Failure "Unimplemented")
-      else if trait_ref.trait_id <> Self then (
-        (* HOL4 doesn't have 1st class types *)
-        assert (!backend <> HOL4);
-        let use_brackets = generics <> empty_generic_args in
-        if use_brackets then F.pp_print_string fmt "(";
-        extract_trait_ref ctx fmt no_params_tys false trait_ref;
-        extract_generic_args ctx fmt no_params_tys generics;
-        let name =
-          ctx_get_trait_type trait_ref.trait_decl_ref.trait_decl_id type_name
-            ctx
-        in
-        if use_brackets then F.pp_print_string fmt ")";
-        F.pp_print_string fmt ("." ^ name))
-      else
-        (* There are two situations:
-           - we are extracting a declared item (typically a function signature)
-             for a trait declaration. We directly refer to the item (we extract
-             trait declarations as structures, so we can refer to their fields)
-           - we are extracting a provided method for a trait declaration. We
-             refer to the item in the self trait clause (see {!SelfTraitClauseId}).
-
-           Remark: we can't get there for trait *implementations* because then the
-           types should have been normalized.
-        *)
-        let trait_decl_id = Option.get ctx.trait_decl_id in
-        let item_name = ctx_get_trait_type trait_decl_id type_name ctx in
-        assert (generics = empty_generic_args);
-        if ctx.is_provided_method then
-          (* Provided method: use the trait self clause *)
-          let self_clause = ctx_get_trait_self_clause ctx in
-          F.pp_print_string fmt (self_clause ^ "." ^ item_name)
-        else
-          (* Declaration: directly refer to the item *)
-          F.pp_print_string fmt item_name
-
-and extract_trait_ref (ctx : extraction_ctx) (fmt : F.formatter)
-    (no_params_tys : TypeDeclId.Set.t) (inside : bool) (tr : trait_ref) : unit =
-  let use_brackets = tr.generics <> empty_generic_args && inside in
-  if use_brackets then F.pp_print_string fmt "(";
-  extract_trait_instance_id ctx fmt no_params_tys inside tr.trait_id;
-  extract_generic_args ctx fmt no_params_tys tr.generics;
-  if use_brackets then F.pp_print_string fmt ")"
-
-and extract_trait_decl_ref (ctx : extraction_ctx) (fmt : F.formatter)
-    (no_params_tys : TypeDeclId.Set.t) (inside : bool) (tr : trait_decl_ref) :
-    unit =
-  let use_brackets = tr.decl_generics <> empty_generic_args && inside in
-  let name = ctx_get_trait_decl tr.trait_decl_id ctx in
-  if use_brackets then F.pp_print_string fmt "(";
-  F.pp_print_string fmt name;
-  (* There is something subtle here: the trait obligations for the implemented
-     trait are put inside the parent clauses, so we must ignore them here *)
-  let generics = { tr.decl_generics with trait_refs = [] } in
-  extract_generic_args ctx fmt no_params_tys generics;
-  if use_brackets then F.pp_print_string fmt ")"
-
-and extract_generic_args (ctx : extraction_ctx) (fmt : F.formatter)
-    (no_params_tys : TypeDeclId.Set.t) (generics : generic_args) : unit =
-  let { types; const_generics; trait_refs } = generics in
-  if !backend <> HOL4 then (
-    if types <> [] then (
-      F.pp_print_space fmt ();
-      Collections.List.iter_link (F.pp_print_space fmt)
-        (extract_ty ctx fmt no_params_tys true)
-        types);
-    if const_generics <> [] then (
-      assert (!backend <> HOL4);
-      F.pp_print_space fmt ();
-      Collections.List.iter_link (F.pp_print_space fmt)
-        (extract_const_generic ctx fmt true)
-        const_generics));
-  if trait_refs <> [] then (
-    F.pp_print_space fmt ();
-    Collections.List.iter_link (F.pp_print_space fmt)
-      (extract_trait_ref ctx fmt no_params_tys true)
-      trait_refs)
-
-and extract_trait_instance_id (ctx : extraction_ctx) (fmt : F.formatter)
-    (no_params_tys : TypeDeclId.Set.t) (inside : bool) (id : trait_instance_id)
-    : unit =
-  match id with
-  | Self ->
-      (* This has specific treatment depending on the item we're extracting
-         (associated type, etc.). We should have caught this elsewhere. *)
-      raise (Failure "Unexpected")
-  | TraitImpl id ->
-      let name = ctx_get_trait_impl id ctx in
-      F.pp_print_string fmt name
-  | Clause id ->
-      let name = ctx_get_local_trait_clause id ctx in
-      F.pp_print_string fmt name
-  | ParentClause (inst_id, decl_id, clause_id) ->
-      (* Use the trait decl id to lookup the name *)
-      let name = ctx_get_trait_parent_clause decl_id clause_id ctx in
-      extract_trait_instance_id ctx fmt no_params_tys true inst_id;
-      F.pp_print_string fmt ("." ^ name)
-  | ItemClause (inst_id, decl_id, item_name, clause_id) ->
-      (* Use the trait decl id to lookup the name *)
-      let name = ctx_get_trait_item_clause decl_id item_name clause_id ctx in
-      extract_trait_instance_id ctx fmt no_params_tys true inst_id;
-      F.pp_print_string fmt ("." ^ name)
-  | TraitRef trait_ref ->
-      extract_trait_ref ctx fmt no_params_tys inside trait_ref
-  | UnknownTrait _ ->
-      (* This is an error case *)
-      raise (Failure "Unexpected")
-
-(** Compute the names for all the top-level identifiers used in a type
-    definition (type name, variant names, field names, etc. but not type
-    parameters).
-
-    We need to do this preemptively, beforce extracting any definition,
-    because of recursive definitions.
- *)
-let extract_type_decl_register_names (ctx : extraction_ctx) (def : type_decl) :
-    extraction_ctx =
-  (* Lookup the builtin information, if there is *)
-  let open ExtractBuiltin in
-  let sname = name_to_simple_name def.name in
-  let info = SimpleNameMap.find_opt sname (builtin_types_map ()) in
-  (* Register the filtering information, if there is *)
-  let ctx =
-    match info with
-    | Some { keep_params = Some keep; _ } ->
-        {
-          ctx with
-          types_filter_type_args_map =
-            TypeDeclId.Map.add def.def_id keep ctx.types_filter_type_args_map;
-        }
-    | _ -> ctx
-  in
-  (* Compute and register the type def name *)
-  let def_name =
-    match info with
-    | None -> ctx.fmt.type_name def.name
-    | Some info -> info.extract_name
-  in
-  let ctx = ctx_add (TypeId (AdtId def.def_id)) def_name ctx in
-  (* Compute and register:
-   * - the variant names, if this is an enumeration
-   * - the field names, if this is a structure
-   *)
-  let ctx =
-    match def.kind with
-    | Struct fields ->
-        (* Compute the names *)
-        let field_names, cons_name =
-          match info with
-          | None | Some { body_info = None; _ } ->
-              let field_names =
-                FieldId.mapi
-                  (fun fid (field : field) ->
-                    (fid, ctx.fmt.field_name def.name fid field.field_name))
-                  fields
-              in
-              let cons_name = ctx.fmt.struct_constructor def.name in
-              (field_names, cons_name)
-          | Some { body_info = Some (Struct (cons_name, field_names)); _ } ->
-              let field_names =
-                FieldId.mapi
-                  (fun fid (_, name) -> (fid, name))
-                  (List.combine fields field_names)
-              in
-              (field_names, cons_name)
-          | Some info ->
-              raise
-                (Failure
-                   ("Invalid builtin information: "
-                   ^ show_builtin_type_info info))
-        in
-        (* Add the fields *)
-        let ctx =
-          List.fold_left
-            (fun ctx (fid, name) ->
-              ctx_add (FieldId (AdtId def.def_id, fid)) name ctx)
-            ctx field_names
-        in
-        (* Add the constructor name *)
-        ctx_add (StructId (AdtId def.def_id)) cons_name ctx
-    | Enum variants ->
-        let variant_names =
-          match info with
-          | None ->
-              VariantId.mapi
-                (fun variant_id (variant : variant) ->
-                  let name =
-                    ctx.fmt.variant_name def.name variant.variant_name
-                  in
-                  (* Add the type name prefix for Lean *)
-                  let name =
-                    if !Config.backend = Lean then
-                      let type_name = ctx.fmt.type_name def.name in
-                      type_name ^ "." ^ name
-                    else name
-                  in
-                  (variant_id, name))
-                variants
-          | Some { body_info = Some (Enum variant_infos); _ } ->
-              (* We need to compute the map from variant to variant *)
-              let variant_map =
-                StringMap.of_list
-                  (List.map
-                     (fun (info : builtin_enum_variant_info) ->
-                       (info.rust_variant_name, info.extract_variant_name))
-                     variant_infos)
-              in
-              VariantId.mapi
-                (fun variant_id (variant : variant) ->
-                  (variant_id, StringMap.find variant.variant_name variant_map))
-                variants
-          | _ -> raise (Failure "Invalid builtin information")
-        in
-        List.fold_left
-          (fun ctx (vid, vname) ->
-            ctx_add (VariantId (AdtId def.def_id, vid)) vname ctx)
-          ctx variant_names
-    | Opaque ->
-        (* Nothing to do *)
-        ctx
-  in
-  (* Return *)
-  ctx
-
-(** Print the variants *)
-let extract_type_decl_variant (ctx : extraction_ctx) (fmt : F.formatter)
-    (type_decl_group : TypeDeclId.Set.t) (type_name : string)
-    (type_params : string list) (cg_params : string list) (cons_name : string)
-    (fields : field list) : unit =
-  F.pp_print_space fmt ();
-  (* variant box *)
-  F.pp_open_hvbox fmt ctx.indent_incr;
-  (* [| Cons :]
-   * Note that we really don't want any break above so we print everything
-   * at once. *)
-  let opt_colon = if !backend <> HOL4 then " :" else "" in
-  F.pp_print_string fmt ("| " ^ cons_name ^ opt_colon);
-  let print_field (fid : FieldId.id) (f : field) (ctx : extraction_ctx) :
-      extraction_ctx =
-    F.pp_print_space fmt ();
-    (* Open the field box *)
-    F.pp_open_box fmt ctx.indent_incr;
-    (* Print the field names, if the backend accepts it.
-     * [  x :]
-     * Note that when printing fields, we register the field names as
-     * *variables*: they don't need to be unique at the top level. *)
-    let ctx =
-      match !backend with
-      | FStar -> (
-          match f.field_name with
-          | None -> ctx
-          | Some field_name ->
-              let var_id = VarId.of_int (FieldId.to_int fid) in
-              let field_name =
-                ctx.fmt.var_basename ctx.names_map.names_set (Some field_name)
-                  f.field_ty
-              in
-              let ctx, field_name = ctx_add_var field_name var_id ctx in
-              F.pp_print_string fmt (field_name ^ " :");
-              F.pp_print_space fmt ();
-              ctx)
-      | Coq | Lean | HOL4 -> ctx
-    in
-    (* Print the field type *)
-    let inside = !backend = HOL4 in
-    extract_ty ctx fmt type_decl_group inside f.field_ty;
-    (* Print the arrow [->] *)
-    if !backend <> HOL4 then (
-      F.pp_print_space fmt ();
-      extract_arrow fmt ());
-    (* Close the field box *)
-    F.pp_close_box fmt ();
-    (* Return *)
-    ctx
-  in
-  (* Print the fields *)
-  let fields = FieldId.mapi (fun fid f -> (fid, f)) fields in
-  let _ =
-    List.fold_left (fun ctx (fid, f) -> print_field fid f ctx) ctx fields
-  in
-  (* Sanity check: HOL4 doesn't support const generics *)
-  assert (cg_params = [] || !backend <> HOL4);
-  (* Print the final type *)
-  if !backend <> HOL4 then (
-    F.pp_print_space fmt ();
-    F.pp_open_hovbox fmt 0;
-    F.pp_print_string fmt type_name;
-    List.iter
-      (fun p ->
-        F.pp_print_space fmt ();
-        F.pp_print_string fmt p)
-      (List.append type_params cg_params);
-    F.pp_close_box fmt ());
-  (* Close the variant box *)
-  F.pp_close_box fmt ()
-
-(* TODO: we don' need the [def_name] paramter: it can be retrieved from the context *)
-let extract_type_decl_enum_body (ctx : extraction_ctx) (fmt : F.formatter)
-    (type_decl_group : TypeDeclId.Set.t) (def : type_decl) (def_name : string)
-    (type_params : string list) (cg_params : string list)
-    (variants : variant list) : unit =
-  (* We want to generate a definition which looks like this (taking F* as example):
-     {[
-       type list a = | Cons : a -> list a -> list a | Nil : list a
-     ]}
-
-     If there isn't enough space on one line:
-     {[
-       type s =
-       | Cons : a -> list a -> list a
-       | Nil : list a
-     ]}
-
-     And if we need to write the type of a variant on several lines:
-     {[
-       type s =
-       | Cons :
-         a ->
-         list a ->
-         list a
-       | Nil : list a
-     ]}
-
-     Finally, it is possible to give names to the variant fields in Rust.
-     In this situation, we generate a definition like this:
-     {[
-       type s =
-       | Cons : hd:a -> tl:list a -> list a
-       | Nil : list a
-     ]}
-
-     Note that we already printed: [type s =]
-  *)
-  let print_variant _variant_id (v : variant) =
-    (* We don't lookup the name, because it may have a prefix for the type
-       id (in the case of Lean) *)
-    let cons_name = ctx.fmt.variant_name def.name v.variant_name in
-    let fields = v.fields in
-    extract_type_decl_variant ctx fmt type_decl_group def_name type_params
-      cg_params cons_name fields
-  in
-  (* Print the variants *)
-  let variants = VariantId.mapi (fun vid v -> (vid, v)) variants in
-  List.iter (fun (vid, v) -> print_variant vid v) variants
-
-let extract_type_decl_struct_body (ctx : extraction_ctx) (fmt : F.formatter)
-    (type_decl_group : TypeDeclId.Set.t) (kind : decl_kind) (def : type_decl)
-    (type_params : string list) (cg_params : string list) (fields : field list)
-    : unit =
-  (* We want to generate a definition which looks like this (taking F* as example):
-     {[
-       type t = { x : int; y : bool; }
-     ]}
-
-     If there isn't enough space on one line:
-     {[
-       type t =
-       {
-         x : int; y : bool;
-       }
-     ]}
-
-     And if there is even less space:
-     {[
-       type t =
-       {
-         x : int;
-         y : bool;
-       }
-     ]}
-
-     Also, in case there are no fields, we need to define the type as [unit]
-     ([type t = {}] doesn't work in F* ).
-
-     Coq:
-     ====
-     We need to define the constructor name upon defining the struct (record, in Coq).
-     The syntex is:
-     {[
-       Record Foo = mkFoo { x : int; y : bool; }.
-     }]
-
-     Also, Coq doesn't support groups of mutually recursive inductives and records.
-     This is fine, because we can then define records as inductives, and leverage
-     the fact that when record fields are accessed, the records are symbolically
-     expanded which introduces let bindings of the form: [let RecordCons ... = x in ...].
-     As a consequence, we never use the record projectors (unless we reconstruct
-     them in the micro passes of course).
-
-     HOL4:
-     =====
-     Type definitions are written as follows:
-     {[
-       Datatype:
-         tree =
-           TLeaf 'a
-         | TNode node ;
-
-         node =
-           Node (tree list)
-       End
-     ]}
-  *)
-  (* Note that we already printed: [type t =] *)
-  let is_rec = decl_is_from_rec_group kind in
-  let _ =
-    if !backend = FStar && fields = [] then (
-      F.pp_print_space fmt ();
-      F.pp_print_string fmt (unit_name ()))
-    else if !backend = Lean && fields = [] then ()
-      (* If the definition is recursive, we may need to extract it as an inductive
-         (instead of a record). We start with the "normal" case: we extract it
-         as a record. *)
-    else if (not is_rec) || (!backend <> Coq && !backend <> Lean) then (
-      if !backend <> Lean then F.pp_print_space fmt ();
-      (* If Coq: print the constructor name *)
-      (* TODO: remove superfluous test not is_rec below *)
-      if !backend = Coq && not is_rec then (
-        F.pp_print_string fmt (ctx_get_struct (AdtId def.def_id) ctx);
-        F.pp_print_string fmt " ");
-      (match !backend with
-      | Lean -> ()
-      | FStar | Coq -> F.pp_print_string fmt "{"
-      | HOL4 -> F.pp_print_string fmt "<|");
-      F.pp_print_break fmt 1 ctx.indent_incr;
-      (* The body itself *)
-      (* Open a box for the body *)
-      (match !backend with
-      | Coq | FStar | HOL4 -> F.pp_open_hvbox fmt 0
-      | Lean -> F.pp_open_vbox fmt 0);
-      (* Print the fields *)
-      let print_field (field_id : FieldId.id) (f : field) : unit =
-        let field_name = ctx_get_field (AdtId def.def_id) field_id ctx in
-        (* Open a box for the field *)
-        F.pp_open_box fmt ctx.indent_incr;
-        F.pp_print_string fmt field_name;
-        F.pp_print_space fmt ();
-        F.pp_print_string fmt ":";
-        F.pp_print_space fmt ();
-        extract_ty ctx fmt type_decl_group false f.field_ty;
-        if !backend <> Lean then F.pp_print_string fmt ";";
-        (* Close the box for the field *)
-        F.pp_close_box fmt ()
-      in
-      let fields = FieldId.mapi (fun fid f -> (fid, f)) fields in
-      Collections.List.iter_link (F.pp_print_space fmt)
-        (fun (fid, f) -> print_field fid f)
-        fields;
-      (* Close the box for the body *)
-      F.pp_close_box fmt ();
-      match !backend with
-      | Lean -> ()
-      | FStar | Coq ->
-          F.pp_print_space fmt ();
-          F.pp_print_string fmt "}"
-      | HOL4 ->
-          F.pp_print_space fmt ();
-          F.pp_print_string fmt "|>")
-    else (
-      (* We extract for Coq or Lean, and we have a recursive record, or a record in
-         a group of mutually recursive types: we extract it as an inductive type *)
-      assert (is_rec && (!backend = Coq || !backend = Lean));
-      (* Small trick: in Lean we use namespaces, meaning we don't need to prefix
-         the constructor name with the name of the type at definition site,
-         i.e., instead of generating `inductive Foo := | MkFoo ...` like in Coq
-         we generate `inductive Foo := | mk ... *)
-      let cons_name =
-        if !backend = Lean then "mk" else ctx_get_struct (AdtId def.def_id) ctx
-      in
-      let def_name = ctx_get_local_type def.def_id ctx in
-      extract_type_decl_variant ctx fmt type_decl_group def_name type_params
-        cg_params cons_name fields)
-  in
-  ()
-
-(** Extract a nestable, muti-line comment *)
-let extract_comment (fmt : F.formatter) (sl : string list) : unit =
-  (* Delimiters, space after we break a line *)
-  let ld, space, rd =
-    match !backend with
-    | Coq | FStar | HOL4 -> ("(** ", 4, " *)")
-    | Lean -> ("/- ", 3, " -/")
-  in
-  F.pp_open_vbox fmt space;
-  F.pp_print_string fmt ld;
-  (match sl with
-  | [] -> ()
-  | s :: sl ->
-      F.pp_print_string fmt s;
-      List.iter
-        (fun s ->
-          F.pp_print_space fmt ();
-          F.pp_print_string fmt s)
-        sl);
-  F.pp_print_string fmt rd;
-  F.pp_close_box fmt ()
-
-let extract_trait_clause_type (ctx : extraction_ctx) (fmt : F.formatter)
-    (no_params_tys : TypeDeclId.Set.t) (clause : trait_clause) : unit =
-  let trait_name = ctx_get_trait_decl clause.trait_id ctx in
-  F.pp_print_string fmt trait_name;
-  extract_generic_args ctx fmt no_params_tys clause.generics
-
-(** Insert a space, if necessary *)
-let insert_req_space (fmt : F.formatter) (space : bool ref) : unit =
-  if !space then space := false else F.pp_print_space fmt ()
-
-(** Extract the trait self clause.
-
-    We add the trait self clause for provided methods (see {!TraitSelfClauseId}).
- *)
-let extract_trait_self_clause (insert_req_space : unit -> unit)
-    (ctx : extraction_ctx) (fmt : F.formatter) (trait_decl : trait_decl)
-    (params : string list) : unit =
-  insert_req_space ();
-  F.pp_print_string fmt "(";
-  let self_clause = ctx_get_trait_self_clause ctx in
-  F.pp_print_string fmt self_clause;
-  F.pp_print_space fmt ();
-  F.pp_print_string fmt ":";
-  F.pp_print_space fmt ();
-  let trait_id = ctx_get_trait_decl trait_decl.def_id ctx in
-  F.pp_print_string fmt trait_id;
-  List.iter
-    (fun p ->
-      F.pp_print_space fmt ();
-      F.pp_print_string fmt p)
-    params;
-  F.pp_print_string fmt ")"
-
-(**
- - [trait_decl]: if [Some], it means we are extracting the generics for a provided
-   method and need to insert a trait self clause (see {!TraitSelfClauseId}).
- *)
-let extract_generic_params (ctx : extraction_ctx) (fmt : F.formatter)
-    (no_params_tys : TypeDeclId.Set.t) ?(use_forall = false)
-    ?(use_forall_use_sep = true) ?(as_implicits : bool = false)
-    ?(space : bool ref option = None) ?(trait_decl : trait_decl option = None)
-    (generics : generic_params) (type_params : string list)
-    (cg_params : string list) (trait_clauses : string list) : unit =
-  let all_params = List.concat [ type_params; cg_params; trait_clauses ] in
-  (* HOL4 doesn't support const generics *)
-  assert (cg_params = [] || !backend <> HOL4);
-  let left_bracket (implicit : bool) =
-    if implicit then F.pp_print_string fmt "{" else F.pp_print_string fmt "("
-  in
-  let right_bracket (implicit : bool) =
-    if implicit then F.pp_print_string fmt "}" else F.pp_print_string fmt ")"
-  in
-  let insert_req_space () =
-    match space with
-    | None -> F.pp_print_space fmt ()
-    | Some space -> insert_req_space fmt space
-  in
-  (* Print the type/const generic parameters *)
-  if all_params <> [] then (
-    if use_forall then (
-      if use_forall_use_sep then (
-        insert_req_space ();
-        F.pp_print_string fmt ":");
-      insert_req_space ();
-      F.pp_print_string fmt "forall");
-    (* Small helper - we may need to split the parameters *)
-    let print_generics (as_implicits : bool) (type_params : string list)
-        (const_generics : const_generic_var list)
-        (trait_clauses : trait_clause list) : unit =
-      (* Note that in HOL4 we don't print the type parameters. *)
-      if !backend <> HOL4 then (
-        (* Print the type parameters *)
-        if type_params <> [] then (
-          insert_req_space ();
-          (* ( *)
-          left_bracket as_implicits;
-          List.iter
-            (fun s ->
-              F.pp_print_string fmt s;
-              F.pp_print_space fmt ())
-            type_params;
-          F.pp_print_string fmt ":";
-          F.pp_print_space fmt ();
-          F.pp_print_string fmt (type_keyword ());
-          (* ) *)
-          right_bracket as_implicits);
-        (* Print the const generic parameters *)
-        List.iter
-          (fun (var : const_generic_var) ->
-            insert_req_space ();
-            (* ( *)
-            left_bracket as_implicits;
-            let n = ctx_get_const_generic_var var.index ctx in
-            F.pp_print_string fmt n;
-            F.pp_print_space fmt ();
-            F.pp_print_string fmt ":";
-            F.pp_print_space fmt ();
-            extract_literal_type ctx fmt var.ty;
-            (* ) *)
-            right_bracket as_implicits)
-          const_generics);
-      (* Print the trait clauses *)
-      List.iter
-        (fun (clause : trait_clause) ->
-          insert_req_space ();
-          (* ( *)
-          left_bracket as_implicits;
-          let n = ctx_get_local_trait_clause clause.clause_id ctx in
-          F.pp_print_string fmt n;
-          F.pp_print_space fmt ();
-          F.pp_print_string fmt ":";
-          F.pp_print_space fmt ();
-          extract_trait_clause_type ctx fmt no_params_tys clause;
-          (* ) *)
-          right_bracket as_implicits)
-        trait_clauses
-    in
-    (* If we extract the generics for a provided method for a trait declaration
-       (indicated by the trait decl given as input), we need to split the generics:
-       - we print the generics for the trait decl
-       - we print the trait self clause
-       - we print the generics for the trait method
-    *)
-    match trait_decl with
-    | None ->
-        print_generics as_implicits type_params generics.const_generics
-          generics.trait_clauses
-    | Some trait_decl ->
-        (* Split the generics between the generics specific to the trait decl
-           and those specific to the trait method *)
-        let open Collections.List in
-        let dtype_params, mtype_params =
-          split_at type_params (length trait_decl.generics.types)
-        in
-        let dcgs, mcgs =
-          split_at generics.const_generics
-            (length trait_decl.generics.const_generics)
-        in
-        let dtrait_clauses, mtrait_clauses =
-          split_at generics.trait_clauses
-            (length trait_decl.generics.trait_clauses)
-        in
-        (* Extract the trait decl generics - note that we can always deduce
-           those parameters from the trait self clause: for this reason
-           they are always implicit *)
-        print_generics true dtype_params dcgs dtrait_clauses;
-        (* Extract the trait self clause *)
-        let params =
-          concat
-            [
-              dtype_params;
-              map
-                (fun (cg : const_generic_var) ->
-                  ctx_get_const_generic_var cg.index ctx)
-                dcgs;
-              map
-                (fun c -> ctx_get_local_trait_clause c.clause_id ctx)
-                dtrait_clauses;
-            ]
-        in
-        extract_trait_self_clause insert_req_space ctx fmt trait_decl params;
-        (* Extract the method generics *)
-        print_generics as_implicits mtype_params mcgs mtrait_clauses)
-
-(** Extract a type declaration.
-
-    This function is for all type declarations and all backends **at the exception**
-    of opaque (assumed/declared) types format4 HOL4.
-
-    See {!extract_type_decl}.
- *)
-let extract_type_decl_gen (ctx : extraction_ctx) (fmt : F.formatter)
-    (type_decl_group : TypeDeclId.Set.t) (kind : decl_kind) (def : type_decl)
-    (extract_body : bool) : unit =
-  (* Sanity check *)
-  assert (extract_body || !backend <> HOL4);
-  let type_kind =
-    if extract_body then
-      match def.kind with
-      | Struct _ -> Some Struct
-      | Enum _ -> Some Enum
-      | Opaque -> None
-    else None
-  in
-  (* If in Coq and the declaration is opaque, it must have the shape:
-     [Axiom Ident : forall (T0 ... Tn : Type) (N0 : ...) ... (Nn : ...), ... -> ... -> ...].
-
-     The boolean [is_opaque_coq] is used to detect this case.
-  *)
-  let is_opaque = type_kind = None in
-  let is_opaque_coq = !backend = Coq && is_opaque in
-  let use_forall = is_opaque_coq && def.generics <> empty_generic_params in
-  (* Retrieve the definition name *)
-  let def_name = ctx_get_local_type def.def_id ctx in
-  (* Add the type and const generic params - note that we need those bindings only for the
-   * body translation (they are not top-level) *)
-  let ctx_body, type_params, cg_params, trait_clauses =
-    ctx_add_generic_params def.generics ctx
-  in
-  (* Add a break before *)
-  if !backend <> HOL4 || not (decl_is_first_from_group kind) then
-    F.pp_print_break fmt 0 0;
-  (* Print a comment to link the extracted type to its original rust definition *)
-  extract_comment fmt [ "[" ^ Print.name_to_string def.name ^ "]" ];
-  F.pp_print_break fmt 0 0;
-  (* Open a box for the definition, so that whenever possible it gets printed on
-   * one line. Note however that in the case of Lean line breaks are important
-   * for parsing: we thus use a hovbox. *)
-  (match !backend with
-  | Coq | FStar | HOL4 -> F.pp_open_hvbox fmt 0
-  | Lean -> F.pp_open_vbox fmt 0);
-  (* Open a box for "type TYPE_NAME (TYPE_PARAMS CONST_GEN_PARAMS) =" *)
-  F.pp_open_hovbox fmt ctx.indent_incr;
-  (* > "type TYPE_NAME" *)
-  let qualif = ctx.fmt.type_decl_kind_to_qualif kind type_kind in
-  (match qualif with
-  | Some qualif -> F.pp_print_string fmt (qualif ^ " " ^ def_name)
-  | None -> F.pp_print_string fmt def_name);
-  (* HOL4 doesn't support const generics, and type definitions in HOL4 don't
-     support trait clauses *)
-  assert ((cg_params = [] && trait_clauses = []) || !backend <> HOL4);
-  (* Print the generic parameters *)
-  extract_generic_params ctx_body fmt type_decl_group ~use_forall def.generics
-    type_params cg_params trait_clauses;
-  (* Print the "=" if we extract the body*)
-  if extract_body then (
-    F.pp_print_space fmt ();
-    let eq =
-      match !backend with
-      | FStar -> "="
-      | Coq -> ":="
-      | Lean ->
-          if type_kind = Some Struct && kind = SingleNonRec then "where"
-          else ":="
-      | HOL4 -> "="
-    in
-    F.pp_print_string fmt eq)
-  else (
-    (* Otherwise print ": Type", unless it is the HOL4 backend (in
-       which case we declare the type with `new_type`) *)
-    if use_forall then F.pp_print_string fmt ","
-    else (
-      F.pp_print_space fmt ();
-      F.pp_print_string fmt ":");
-    F.pp_print_space fmt ();
-    F.pp_print_string fmt (type_keyword ()));
-  (* Close the box for "type TYPE_NAME (TYPE_PARAMS) =" *)
-  F.pp_close_box fmt ();
-  (if extract_body then
-     match def.kind with
-     | Struct fields ->
-         extract_type_decl_struct_body ctx_body fmt type_decl_group kind def
-           type_params cg_params fields
-     | Enum variants ->
-         extract_type_decl_enum_body ctx_body fmt type_decl_group def def_name
-           type_params cg_params variants
-     | Opaque -> raise (Failure "Unreachable"));
-  (* Add the definition end delimiter *)
-  if !backend = HOL4 && decl_is_not_last_from_group kind then (
-    F.pp_print_space fmt ();
-    F.pp_print_string fmt ";")
-  else if !backend = Coq && decl_is_last_from_group kind then (
-    (* This is actually an end of group delimiter. For aesthetic reasons
-       we print it here instead of in {!end_type_decl_group}. *)
-    F.pp_print_cut fmt ();
-    F.pp_print_string fmt ".");
-  (* Close the box for the definition *)
-  F.pp_close_box fmt ();
-  (* Add breaks to insert new lines between definitions *)
-  if !backend <> HOL4 || decl_is_not_last_from_group kind then
-    F.pp_print_break fmt 0 0
-
-(** Extract an opaque type declaration to HOL4.
-
-    Remark (SH): having to treat this specific case separately is very annoying,
-    but I could not find a better way.
- *)
-let extract_type_decl_hol4_opaque (ctx : extraction_ctx) (fmt : F.formatter)
-    (def : type_decl) : unit =
-  (* Retrieve the definition name *)
-  let def_name = ctx_get_local_type def.def_id ctx in
-  (* Generic parameters are unsupported *)
-  assert (def.generics.const_generics = []);
-  (* Trait clauses on type definitions are unsupported *)
-  assert (def.generics.trait_clauses = []);
-  (* Types  *)
-  (* Count the number of parameters *)
-  let num_params = List.length def.generics.types in
-  (* Generate the declaration *)
-  F.pp_print_space fmt ();
-  F.pp_print_string fmt
-    ("val _ = new_type (\"" ^ def_name ^ "\", " ^ string_of_int num_params ^ ")");
-  F.pp_print_space fmt ()
-
-(** Extract an empty record type declaration to HOL4.
-
-    Empty records are not supported in HOL4, so we extract them as type
-    abbreviations to the unit type.
-
-    Remark (SH): having to treat this specific case separately is very annoying,
-    but I could not find a better way.
- *)
-let extract_type_decl_hol4_empty_record (ctx : extraction_ctx)
-    (fmt : F.formatter) (def : type_decl) : unit =
-  (* Retrieve the definition name *)
-  let def_name = ctx_get_local_type def.def_id ctx in
-  (* Sanity check *)
-  assert (def.generics = empty_generic_params);
-  (* Generate the declaration *)
-  F.pp_print_space fmt ();
-  F.pp_print_string fmt ("Type " ^ def_name ^ " = “: unit”");
-  F.pp_print_space fmt ()
-
-(** Extract a type declaration.
-
-    Note that all the names used for extraction should already have been
-    registered.
-
-    This function should be inserted between calls to {!start_type_decl_group}
-    and {!end_type_decl_group}.
- *)
-let extract_type_decl (ctx : extraction_ctx) (fmt : F.formatter)
-    (type_decl_group : TypeDeclId.Set.t) (kind : decl_kind) (def : type_decl) :
-    unit =
-  let extract_body =
-    match kind with
-    | SingleNonRec | SingleRec | MutRecFirst | MutRecInner | MutRecLast -> true
-    | Assumed | Declared -> false
-  in
-  if extract_body then
-    if !backend = HOL4 && is_empty_record_type_decl def then
-      extract_type_decl_hol4_empty_record ctx fmt def
-    else extract_type_decl_gen ctx fmt type_decl_group kind def extract_body
-  else
-    match !backend with
-    | FStar | Coq | Lean ->
-        extract_type_decl_gen ctx fmt type_decl_group kind def extract_body
-    | HOL4 -> extract_type_decl_hol4_opaque ctx fmt def
-
-(** Auxiliary function.
-
-    Generate [Arguments] instructions in Coq.
- *)
-let extract_type_decl_coq_arguments (ctx : extraction_ctx) (fmt : F.formatter)
-    (kind : decl_kind) (decl : type_decl) : unit =
-  assert (!backend = Coq);
-  (* Generating the [Arguments] instructions is useful only if there are type parameters *)
-  if decl.generics.types = [] && decl.generics.const_generics = [] then ()
-  else
-    (* Add the type params - note that we need those bindings only for the
-     * body translation (they are not top-level) *)
-    let _ctx_body, type_params, cg_params, trait_clauses =
-      ctx_add_generic_params decl.generics ctx
-    in
-    (* Auxiliary function to extract an [Arguments Cons {T} _ _.] instruction *)
-    let extract_arguments_info (cons_name : string) (fields : 'a list) : unit =
-      (* Add a break before *)
-      F.pp_print_break fmt 0 0;
-      (* Open a box *)
-      F.pp_open_hovbox fmt ctx.indent_incr;
-      F.pp_print_break fmt 0 0;
-      F.pp_print_string fmt "Arguments";
-      F.pp_print_space fmt ();
-      F.pp_print_string fmt cons_name;
-      (* Print the type/const params and the trait clauses (`{T}`) *)
-      List.iter
-        (fun (var : string) ->
-          F.pp_print_space fmt ();
-          F.pp_print_string fmt ("{" ^ var ^ "}"))
-        (List.concat [ type_params; cg_params; trait_clauses ]);
-      (* Print the fields (`_`) *)
-      List.iter
-        (fun _ ->
-          F.pp_print_space fmt ();
-          F.pp_print_string fmt "_")
-        fields;
-      F.pp_print_string fmt ".";
-
-      (* Close the box *)
-      F.pp_close_box fmt ()
-    in
-
-    (* Generate the [Arguments] instruction *)
-    match decl.kind with
-    | Opaque -> ()
-    | Struct fields ->
-        let adt_id = AdtId decl.def_id in
-        (* Generate the instruction for the record constructor *)
-        let cons_name = ctx_get_struct adt_id ctx in
-        extract_arguments_info cons_name fields;
-        (* Generate the instruction for the record projectors, if there are *)
-        let is_rec = decl_is_from_rec_group kind in
-        if not is_rec then
-          FieldId.iteri
-            (fun fid _ ->
-              let cons_name = ctx_get_field adt_id fid ctx in
-              extract_arguments_info cons_name [])
-            fields;
-        (* Add breaks to insert new lines between definitions *)
-        F.pp_print_break fmt 0 0
-    | Enum variants ->
-        (* Generate the instructions *)
-        VariantId.iteri
-          (fun vid (v : variant) ->
-            let cons_name = ctx_get_variant (AdtId decl.def_id) vid ctx in
-            extract_arguments_info cons_name v.fields)
-          variants;
-        (* Add breaks to insert new lines between definitions *)
-        F.pp_print_break fmt 0 0
-
-(** Auxiliary function.
-
-    Generate field projectors in Coq.
-
-    Sometimes we extract records as inductives in Coq: when this happens we
-    have to define the field projectors afterwards.
- *)
-let extract_type_decl_record_field_projectors (ctx : extraction_ctx)
-    (fmt : F.formatter) (kind : decl_kind) (decl : type_decl) : unit =
-  assert (!backend = Coq);
-  match decl.kind with
-  | Opaque | Enum _ -> ()
-  | Struct fields ->
-      (* Records are extracted as inductives only if they are recursive *)
-      let is_rec = decl_is_from_rec_group kind in
-      if is_rec then
-        (* Add the type params *)
-        let ctx, type_params, cg_params, trait_clauses =
-          ctx_add_generic_params decl.generics ctx
-        in
-        let ctx, record_var = ctx_add_var "x" (VarId.of_int 0) ctx in
-        let ctx, field_var = ctx_add_var "x" (VarId.of_int 1) ctx in
-        let def_name = ctx_get_local_type decl.def_id ctx in
-        let cons_name = ctx_get_struct (AdtId decl.def_id) ctx in
-        let extract_field_proj (field_id : FieldId.id) (_ : field) : unit =
-          F.pp_print_space fmt ();
-          (* Outer box for the projector definition *)
-          F.pp_open_hvbox fmt 0;
-          (* Inner box for the projector definition *)
-          F.pp_open_hvbox fmt ctx.indent_incr;
-          (* Open a box for the [Definition PROJ ... :=] *)
-          F.pp_open_hovbox fmt ctx.indent_incr;
-          F.pp_print_string fmt "Definition";
-          F.pp_print_space fmt ();
-          let field_name = ctx_get_field (AdtId decl.def_id) field_id ctx in
-          F.pp_print_string fmt field_name;
-          (* Print the generics *)
-          let as_implicits = true in
-          extract_generic_params ctx fmt TypeDeclId.Set.empty ~as_implicits
-            decl.generics type_params cg_params trait_clauses;
-          (* Print the record parameter *)
-          F.pp_print_space fmt ();
-          F.pp_print_string fmt "(";
-          F.pp_print_string fmt record_var;
-          F.pp_print_space fmt ();
-          F.pp_print_string fmt ":";
-          F.pp_print_space fmt ();
-          F.pp_print_string fmt def_name;
-          List.iter
-            (fun p ->
-              F.pp_print_space fmt ();
-              F.pp_print_string fmt p)
-            type_params;
-          F.pp_print_string fmt ")";
-          (* *)
-          F.pp_print_space fmt ();
-          F.pp_print_string fmt ":=";
-          (* Close the box for the [Definition PROJ ... :=] *)
-          F.pp_close_box fmt ();
-          F.pp_print_space fmt ();
-          (* Open a box for the whole match *)
-          F.pp_open_hvbox fmt 0;
-          (* Open a box for the [match ... with] *)
-          F.pp_open_hovbox fmt ctx.indent_incr;
-          F.pp_print_string fmt "match";
-          F.pp_print_space fmt ();
-          F.pp_print_string fmt record_var;
-          F.pp_print_space fmt ();
-          F.pp_print_string fmt "with";
-          (* Close the box for the [match ... with] *)
-          F.pp_close_box fmt ();
-
-          (* Open a box for the branch *)
-          F.pp_open_hovbox fmt ctx.indent_incr;
-          (* Print the match branch *)
-          F.pp_print_space fmt ();
-          F.pp_print_string fmt "|";
-          F.pp_print_space fmt ();
-          F.pp_print_string fmt cons_name;
-          FieldId.iteri
-            (fun id _ ->
-              F.pp_print_space fmt ();
-              if field_id = id then F.pp_print_string fmt field_var
-              else F.pp_print_string fmt "_")
-            fields;
-          F.pp_print_space fmt ();
-          F.pp_print_string fmt "=>";
-          F.pp_print_space fmt ();
-          F.pp_print_string fmt field_var;
-          (* Close the box for the branch *)
-          F.pp_close_box fmt ();
-          (* Print the [end] *)
-          F.pp_print_space fmt ();
-          F.pp_print_string fmt "end";
-          (* Close the box for the whole match *)
-          F.pp_close_box fmt ();
-          (* Close the inner box projector *)
-          F.pp_close_box fmt ();
-          (* If Coq: end the definition with a "." *)
-          if !backend = Coq then (
-            F.pp_print_cut fmt ();
-            F.pp_print_string fmt ".");
-          (* Close the outer box projector  *)
-          F.pp_close_box fmt ();
-          (* Add breaks to insert new lines between definitions *)
-          F.pp_print_break fmt 0 0
-        in
-
-        let extract_proj_notation (field_id : FieldId.id) (_ : field) : unit =
-          F.pp_print_space fmt ();
-          (* Outer box for the projector definition *)
-          F.pp_open_hvbox fmt 0;
-          (* Inner box for the projector definition *)
-          F.pp_open_hovbox fmt ctx.indent_incr;
-          let ctx, record_var = ctx_add_var "x" (VarId.of_int 0) ctx in
-          F.pp_print_string fmt "Notation";
-          F.pp_print_space fmt ();
-          let field_name = ctx_get_field (AdtId decl.def_id) field_id ctx in
-          F.pp_print_string fmt ("\"" ^ record_var ^ " .(" ^ field_name ^ ")\"");
-          F.pp_print_space fmt ();
-          F.pp_print_string fmt ":=";
-          F.pp_print_space fmt ();
-          F.pp_print_string fmt "(";
-          F.pp_print_string fmt field_name;
-          F.pp_print_space fmt ();
-          F.pp_print_string fmt record_var;
-          F.pp_print_string fmt ")";
-          F.pp_print_space fmt ();
-          F.pp_print_string fmt "(at level 9)";
-          (* Close the inner box projector *)
-          F.pp_close_box fmt ();
-          (* If Coq: end the definition with a "." *)
-          if !backend = Coq then (
-            F.pp_print_cut fmt ();
-            F.pp_print_string fmt ".");
-          (* Close the outer box projector  *)
-          F.pp_close_box fmt ();
-          (* Add breaks to insert new lines between definitions *)
-          F.pp_print_break fmt 0 0
-        in
-
-        let extract_field_proj_and_notation (field_id : FieldId.id)
-            (field : field) : unit =
-          extract_field_proj field_id field;
-          extract_proj_notation field_id field
-        in
-
-        FieldId.iteri extract_field_proj_and_notation fields
-
-(** Extract extra information for a type (e.g., [Arguments] instructions in Coq).
-
-    Note that all the names used for extraction should already have been
-    registered.
- *)
-let extract_type_decl_extra_info (ctx : extraction_ctx) (fmt : F.formatter)
-    (kind : decl_kind) (decl : type_decl) : unit =
-  match !backend with
-  | FStar | Lean | HOL4 -> ()
-  | Coq ->
-      extract_type_decl_coq_arguments ctx fmt kind decl;
-      extract_type_decl_record_field_projectors ctx fmt kind decl
-
-(** Extract the state type declaration. *)
-let extract_state_type (fmt : F.formatter) (ctx : extraction_ctx)
-    (kind : decl_kind) : unit =
-  (* Add a break before *)
-  F.pp_print_break fmt 0 0;
-  (* Print a comment  *)
-  extract_comment fmt [ "The state type used in the state-error monad" ];
-  F.pp_print_break fmt 0 0;
-  (* Open a box for the definition, so that whenever possible it gets printed on
-   * one line *)
-  F.pp_open_hvbox fmt 0;
-  (* Retrieve the name *)
-  let state_name = ctx_get_assumed_type State ctx in
-  (* The syntax for Lean and Coq is almost identical. *)
-  let print_axiom () =
-    let axiom =
-      match !backend with
-      | Coq -> "Axiom"
-      | Lean -> "axiom"
-      | FStar | HOL4 -> raise (Failure "Unexpected")
-    in
-    F.pp_print_string fmt axiom;
-    F.pp_print_space fmt ();
-    F.pp_print_string fmt state_name;
-    F.pp_print_space fmt ();
-    F.pp_print_string fmt ":";
-    F.pp_print_space fmt ();
-    F.pp_print_string fmt "Type";
-    if !backend = Coq then F.pp_print_string fmt "."
-  in
-  (* The kind should be [Assumed] or [Declared] *)
-  (match kind with
-  | SingleNonRec | SingleRec | MutRecFirst | MutRecInner | MutRecLast ->
-      raise (Failure "Unexpected")
-  | Assumed -> (
-      match !backend with
-      | FStar ->
-          F.pp_print_string fmt "assume";
-          F.pp_print_space fmt ();
-          F.pp_print_string fmt "type";
-          F.pp_print_space fmt ();
-          F.pp_print_string fmt state_name;
-          F.pp_print_space fmt ();
-          F.pp_print_string fmt ":";
-          F.pp_print_space fmt ();
-          F.pp_print_string fmt "Type0"
-      | HOL4 ->
-          F.pp_print_string fmt ("val _ = new_type (\"" ^ state_name ^ "\", 0)")
-      | Coq | Lean -> print_axiom ())
-  | Declared -> (
-      match !backend with
-      | FStar ->
-          F.pp_print_string fmt "val";
-          F.pp_print_space fmt ();
-          F.pp_print_string fmt state_name;
-          F.pp_print_space fmt ();
-          F.pp_print_string fmt ":";
-          F.pp_print_space fmt ();
-          F.pp_print_string fmt "Type0"
-      | HOL4 ->
-          F.pp_print_string fmt ("val _ = new_type (\"" ^ state_name ^ "\", 0)")
-      | Coq | Lean -> print_axiom ()));
-  (* Close the box for the definition *)
-  F.pp_close_box fmt ();
-  (* Add breaks to insert new lines between definitions *)
-  F.pp_print_break fmt 0 0
+include ExtractTypes
 
 (** Compute the names for all the pure functions generated from a rust function
     (forward function and backward functions).
@@ -2415,13 +53,23 @@ let extract_fun_decl_register_names (ctx : extraction_ctx)
               let fun_id =
                 (Pure.FunId (Regular f.def_id), f.loop_id, f.back_id)
               in
-              let fun_name =
-                (List.find
-                   (fun (x : builtin_fun_info) -> x.rg = f.back_id)
-                   info)
-                  .extract_name
+              let fun_info =
+                List.find_opt
+                  (fun (x : builtin_fun_info) -> x.rg = f.back_id)
+                  info
               in
-              ctx_add (FunId (FromLlbc fun_id)) fun_name ctx)
+              match fun_info with
+              | Some fun_info ->
+                  ctx_add (FunId (FromLlbc fun_id)) fun_info.extract_name ctx
+              | None ->
+                  raise
+                    (Failure
+                       ("Not found: "
+                       ^ Names.name_to_string f.basename
+                       ^ ", "
+                       ^ Print.option_to_string Pure.show_loop_id f.loop_id
+                       ^ Print.option_to_string Pure.show_region_group_id
+                           f.back_id)))
             ctx funs
       | None ->
           let fwd = def.fwd in
@@ -2554,6 +202,32 @@ let extract_global (ctx : extraction_ctx) (fmt : F.formatter)
     (id : A.GlobalDeclId.id) : unit =
   F.pp_print_string fmt (ctx_get_global id ctx)
 
+(* Filter the generics of a function if it is builtin *)
+let fun_builtin_filter_types (id : FunDeclId.id) (types : 'a list)
+    (ctx : extraction_ctx) : ('a list, 'a list * string) Result.result =
+  match FunDeclId.Map.find_opt id ctx.funs_filter_type_args_map with
+  | None -> Result.Ok types
+  | Some filter ->
+      if List.length filter <> List.length types then (
+        let decl = FunDeclId.Map.find id ctx.trans_funs in
+        let err =
+          "Ill-formed builtin information for function "
+          ^ Names.name_to_string decl.fwd.f.basename
+          ^ ": "
+          ^ string_of_int (List.length filter)
+          ^ " filtering arguments provided for "
+          ^ string_of_int (List.length types)
+          ^ " type arguments"
+        in
+        log#serror err;
+        Result.Error (types, err))
+      else
+        let types = List.combine filter types in
+        let types =
+          List.filter_map (fun (b, ty) -> if b then Some ty else None) types
+        in
+        Result.Ok types
+
 (** [inside]: see {!extract_ty}.
 
     As a pattern can introduce new variables, we return an extraction context
@@ -2785,22 +459,24 @@ and extract_function_call (ctx : extraction_ctx) (fmt : F.formatter)
          is builtin (for instance, we filter the global allocator type
          argument for `Vec::new`).
       *)
-      let generics =
+      let types =
         match fun_id with
-        | FromLlbc (FunId (Regular id), _, _) -> (
-            match FunDeclId.Map.find_opt id ctx.funs_filter_type_args_map with
-            | None -> generics
-            | Some filter ->
-                let types = List.combine filter generics.types in
-                let types =
-                  List.filter_map
-                    (fun (b, ty) -> if b then Some ty else None)
-                    types
-                in
-                { generics with types })
-        | _ -> generics
+        | FromLlbc (FunId (Regular id), _, _) ->
+            fun_builtin_filter_types id generics.types ctx
+        | _ -> Result.Ok generics.types
       in
-      extract_generic_args ctx fmt TypeDeclId.Set.empty generics;
+      (match types with
+      | Ok types ->
+          extract_generic_args ctx fmt TypeDeclId.Set.empty
+            { generics with types }
+      | Error (types, err) ->
+          extract_generic_args ctx fmt TypeDeclId.Set.empty
+            { generics with types };
+          if !Config.extract_fail_hard then raise (Failure err)
+          else
+            F.pp_print_string fmt
+              "(\"ERROR: ill-formed builtin: invalid number of filtering \
+               arguments\")");
       (* Print the arguments *)
       List.iter
         (fun ve ->
@@ -4353,10 +2029,8 @@ let extract_trait_decl_register_names (ctx : extraction_ctx)
 (** Similar to {!extract_type_decl_register_names} *)
 let extract_trait_impl_register_names (ctx : extraction_ctx)
     (trait_impl : trait_impl) : extraction_ctx =
-  let trait_decl =
-    TraitDeclId.Map.find trait_impl.impl_trait.trait_decl_id
-      ctx.trans_trait_decls
-  in
+  let decl_id = trait_impl.impl_trait.trait_decl_id in
+  let trait_decl = TraitDeclId.Map.find decl_id ctx.trans_trait_decls in
   (* Check if the trait implementation is builtin *)
   let builtin_info =
     let open ExtractBuiltin in
@@ -4365,6 +2039,24 @@ let extract_trait_impl_register_names (ctx : extraction_ctx)
     SimpleNamePairMap.find_opt (type_sname, trait_sname)
       (builtin_trait_impls_map ())
   in
+  (* Register some builtin information (if necessary) *)
+  let ctx, builtin_info =
+    match builtin_info with
+    | None -> (ctx, None)
+    | Some (filter, info) ->
+        let ctx =
+          match filter with
+          | None -> ctx
+          | Some filter ->
+              {
+                ctx with
+                trait_impls_filter_type_args_map =
+                  TraitImplId.Map.add trait_impl.def_id filter
+                    ctx.trait_impls_filter_type_args_map;
+              }
+        in
+        (ctx, Some info)
+  in
 
   (* For now we do not support overriding provided methods *)
   assert (trait_impl.provided_methods = []);
@@ -4596,12 +2288,36 @@ let extract_trait_impl_method_items (ctx : extraction_ctx) (fmt : F.formatter)
     let f = f.f in
     let fun_name = ctx_get_trait_method trait_decl_id item_name f.back_id ctx in
     let ty () =
+      (* Filter the generics if the method is a builtin *)
+      let i_tys, _, _ = impl_generics in
+      let impl_types, i_tys, f_tys =
+        match FunDeclId.Map.find_opt f.def_id ctx.funs_filter_type_args_map with
+        | None -> (impl.generics.types, i_tys, f.signature.generics.types)
+        | Some filter ->
+            let filter_list filter ls =
+              let ls = List.combine filter ls in
+              List.filter_map (fun (b, ty) -> if b then Some ty else None) ls
+            in
+            let impl_types = impl.generics.types in
+            let impl_filter =
+              Collections.List.prefix (List.length impl_types) filter
+            in
+            let i_tys = i_tys in
+            let i_filter = Collections.List.prefix (List.length i_tys) filter in
+            ( filter_list impl_filter impl_types,
+              filter_list i_filter i_tys,
+              filter_list filter f.signature.generics.types )
+      in
+      let f_generics = { f.signature.generics with types = f_tys } in
       (* Extract the generics - we need to quantify over the generics which
          are specific to the method, and call it will all the generics
          (trait impl + method generics) *)
       let f_generics =
-        generic_params_drop_prefix impl.generics f.signature.generics
+        generic_params_drop_prefix
+          { impl.generics with types = impl_types }
+          f_generics
       in
+      (* Register and print the quantified generics *)
       let ctx, f_tys, f_cgs, f_tcs = ctx_add_generic_params f_generics ctx in
       let use_forall = f_generics <> empty_generic_params in
       extract_generic_params ctx fmt TypeDeclId.Set.empty ~use_forall f_generics
@@ -4609,12 +2325,14 @@ let extract_trait_impl_method_items (ctx : extraction_ctx) (fmt : F.formatter)
       if use_forall then F.pp_print_string fmt ",";
       (* Extract the function call *)
       F.pp_print_space fmt ();
-      let id = ctx_get_local_function f.def_id None f.back_id ctx in
-      F.pp_print_string fmt id;
+      let fun_name = ctx_get_local_function f.def_id None f.back_id ctx in
+      F.pp_print_string fmt fun_name;
       let all_generics =
-        let i_tys, i_cgs, i_tcs = impl_generics in
+        let _, i_cgs, i_tcs = impl_generics in
         List.concat [ i_tys; f_tys; i_cgs; f_cgs; i_tcs; f_tcs ]
       in
+
+      (* Filter the generics if the function is builtin *)
       List.iter
         (fun p ->
           F.pp_print_space fmt ();
diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index 3eef6b3b..7e8e4ffc 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -653,6 +653,8 @@ type extraction_ctx = {
         *)
   funs_filter_type_args_map : bool list FunDeclId.Map.t;
       (** Same as {!types_filter_type_args_map}, but for functions *)
+  trait_impls_filter_type_args_map : bool list TraitImplId.Map.t;
+      (** Same as {!types_filter_type_args_map}, but for trait implementations *)
 }
 
 (** Debugging function, used when communicating name collisions to the user,
diff --git a/compiler/ExtractBuiltin.ml b/compiler/ExtractBuiltin.ml
index c781463e..fa873c6a 100644
--- a/compiler/ExtractBuiltin.ml
+++ b/compiler/ExtractBuiltin.ml
@@ -122,7 +122,7 @@ let builtin_types () : builtin_type_info list =
       extract_name =
         (match !backend with
         | Lean -> "alloc.alloc.Global"
-        | Coq | FStar | HOL4 -> "alloc_global");
+        | Coq | FStar | HOL4 -> "alloc_alloc_Global");
       keep_params = None;
       body_info = None;
     };
@@ -130,7 +130,9 @@ let builtin_types () : builtin_type_info list =
     {
       rust_name = [ "alloc"; "vec"; "Vec" ];
       extract_name =
-        (match !backend with Lean -> "Vec" | Coq | FStar | HOL4 -> "vec");
+        (match !backend with
+        | Lean -> "alloc.vec.Vec"
+        | Coq | FStar | HOL4 -> "alloc_vec_Vec");
       keep_params = Some [ true; false ];
       body_info = None;
     };
@@ -170,15 +172,17 @@ let builtin_types () : builtin_type_info list =
     {
       rust_name = [ "core"; "ops"; "range"; "Range" ];
       extract_name =
-        (match !backend with Lean -> "Range" | Coq | FStar | HOL4 -> "range");
+        (match !backend with
+        | Lean -> "core.ops.range.Range"
+        | Coq | FStar | HOL4 -> "core_ops_range_Range");
       keep_params = None;
       body_info =
         Some
           (Struct
              ( (match !backend with
-               | Lean -> "Range.mk"
-               | Coq | HOL4 -> "mk_range"
-               | FStar -> "Mkrange"),
+               | Lean -> "core.ops.range.Range.mk"
+               | Coq | HOL4 -> "mk_core_ops_range_Range"
+               | FStar -> "Mkcore_ops_range_Range"),
                [ "start"; "end_" ] ));
     };
   ]
@@ -204,340 +208,118 @@ type builtin_fun_info = {
 let builtin_funs () :
     (string list * bool list option * builtin_fun_info list) list =
   let rg0 = Some Types.RegionGroupId.zero in
+  (* Small utility *)
+  let mk_fun (name : string list) (extract_name : string list option)
+      (filter : bool list option) (with_back : bool) (back_no_suffix : bool) :
+      string list * bool list option * builtin_fun_info list =
+    let extract_name =
+      match extract_name with None -> name | Some name -> name
+    in
+    let fwd_name =
+      match !backend with
+      | FStar | Coq | HOL4 -> String.concat "_" extract_name
+      | Lean -> String.concat "." extract_name
+    in
+    let fwd_suffix = if with_back && back_no_suffix then "_fwd" else "" in
+    let fwd = [ { rg = None; extract_name = fwd_name ^ fwd_suffix } ] in
+    let back_suffix = if with_back && back_no_suffix then "" else "_back" in
+    let back =
+      if with_back then [ { rg = rg0; extract_name = fwd_name ^ back_suffix } ]
+      else []
+    in
+    (name, filter, fwd @ back)
+  in
   [
-    ( [ "core"; "mem"; "replace" ],
-      None,
-      [
-        {
-          rg = None;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "core_mem_replace_fwd"
-            | Lean -> "core.mem.replace");
-        };
-        {
-          rg = rg0;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "core_mem_replace_back"
-            | Lean -> "core.mem.replace_back");
-        };
-      ] );
-    ( [ "alloc"; "vec"; "Vec"; "new" ],
-      Some [ true; false ],
-      [
-        {
-          rg = None;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "vec_new"
-            | Lean -> "Vec.new");
-        };
-        {
-          rg = rg0;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "vec_new_back"
-            | Lean -> "Vec.new_back");
-        };
-      ] );
-    ( [ "alloc"; "vec"; "Vec"; "push" ],
-      Some [ true; false ],
-      [
-        (* The forward function shouldn't be used *)
-        {
-          rg = None;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "vec_push_fwd"
-            | Lean -> "Vec.push_fwd");
-        };
-        {
-          rg = rg0;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "vec_push_back"
-            | Lean -> "Vec.push");
-        };
-      ] );
-    ( [ "alloc"; "vec"; "Vec"; "insert" ],
-      Some [ true; false ],
-      [
-        (* The forward function shouldn't be used *)
-        {
-          rg = None;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "vec_insert_fwd"
-            | Lean -> "Vec.insert_fwd");
-        };
-        {
-          rg = rg0;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "vec_insert_back"
-            | Lean -> "Vec.insert");
-        };
-      ] );
-    ( [ "alloc"; "vec"; "Vec"; "len" ],
-      Some [ true; false ],
-      [
-        {
-          rg = None;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "vec_len"
-            | Lean -> "Vec.len");
-        };
-      ] );
-    ( [ "alloc"; "vec"; "Vec"; "index" ],
-      Some [ true; false ],
-      [
-        {
-          rg = None;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "vec_index_fwd"
-            | Lean -> "Vec.index_shared");
-        };
-        (* The backward function shouldn't be used *)
-        {
-          rg = rg0;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "vec_index_back"
-            | Lean -> "Vec.index_shared_back");
-        };
-      ] );
-    ( [ "alloc"; "vec"; "Vec"; "index_mut" ],
-      Some [ true; false ],
-      [
-        {
-          rg = None;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "vec_index_mut_fwd"
-            | Lean -> "Vec.index_mut");
-        };
-        (* The backward function shouldn't be used *)
-        {
-          rg = rg0;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "vec_index_mut_back"
-            | Lean -> "Vec.index_mut_back");
-        };
-      ] );
-    ( [ "alloc"; "boxed"; "Box"; "deref" ],
-      Some [ true; false ],
-      [
-        {
-          rg = None;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "alloc_boxed_Box_deref"
-            | Lean -> "alloc.boxed.Box.deref");
-        };
-        (* The backward function shouldn't be used *)
-        {
-          rg = rg0;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "alloc_boxed_Box_deref_back"
-            | Lean -> "alloc.boxed.Box.deref_back");
-        };
-      ] );
-    ( [ "alloc"; "boxed"; "Box"; "deref_mut" ],
-      Some [ true; false ],
-      [
-        {
-          rg = None;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "alloc_boxed_Box_deref_mut"
-            | Lean -> "alloc.boxed.Box.deref_mut");
-        };
-        {
-          rg = rg0;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "alloc_boxed_box_deref_mut_back"
-            | Lean -> "alloc.boxed.Box.deref_mut_back");
-        };
-      ] );
+    mk_fun [ "core"; "mem"; "replace" ] None None true false;
+    mk_fun [ "alloc"; "vec"; "Vec"; "new" ] None None false false;
+    mk_fun
+      [ "alloc"; "vec"; "Vec"; "push" ]
+      None
+      (Some [ true; false ])
+      true true;
+    mk_fun
+      [ "alloc"; "vec"; "Vec"; "insert" ]
+      None
+      (Some [ true; false ])
+      true true;
+    mk_fun
+      [ "alloc"; "vec"; "Vec"; "len" ]
+      None
+      (Some [ true; false ])
+      true false;
+    mk_fun
+      [ "alloc"; "vec"; "Vec"; "index" ]
+      None
+      (Some [ true; true; false ])
+      true false;
+    mk_fun
+      [ "alloc"; "vec"; "Vec"; "index_mut" ]
+      None
+      (Some [ true; true; false ])
+      true false;
+    mk_fun
+      [ "alloc"; "boxed"; "Box"; "deref" ]
+      None
+      (Some [ true; false ])
+      true false;
+    mk_fun
+      [ "alloc"; "boxed"; "Box"; "deref_mut" ]
+      None
+      (Some [ true; false ])
+      true false;
     (* TODO: fix the same like "[T]" below *)
-    ( [ "core"; "slice"; "index"; "[T]"; "index" ],
-      None,
-      [
-        {
-          rg = None;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "core_slice_index_Slice_index"
-            | Lean -> "core.slice.index.Slice.index");
-        };
-        (* The backward function shouldn't be used *)
-        {
-          rg = rg0;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "core_slice_index_Slice_index_back"
-            | Lean -> "core.slice.index.Slice.index_back");
-        };
-      ] );
-    ( [ "core"; "slice"; "index"; "[T]"; "index_mut" ],
-      None,
-      [
-        {
-          rg = None;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "core_slice_index_Slice_index_mut"
-            | Lean -> "core.slice.index.Slice.index_mut");
-        };
-        (* The backward function shouldn't be used *)
-        {
-          rg = rg0;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "core_slice_index_Slice_index_mut_back"
-            | Lean -> "core.slice.index.Slice.index_mut_back");
-        };
-      ] );
-    ( [ "core"; "array"; "[T; N]"; "index" ],
-      None,
-      [
-        {
-          rg = None;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "core_array_Array_index"
-            | Lean -> "core.array.Array.index");
-        };
-        (* The backward function shouldn't be used *)
-        {
-          rg = rg0;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "core_array_Array_index_back"
-            | Lean -> "core.array.Array.index_back");
-        };
-      ] );
-    ( [ "core"; "array"; "[T; N]"; "index_mut" ],
-      None,
-      [
-        {
-          rg = None;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "core_array_Array_index_mut"
-            | Lean -> "core.array.Array.index_mut");
-        };
-        (* The backward function shouldn't be used *)
-        {
-          rg = rg0;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "core_array_Array_index_mut_back"
-            | Lean -> "core.array.Array.index_mut_back");
-        };
-      ] );
-    ( [ "core"; "slice"; "index"; "Range"; "get" ],
-      None,
-      [
-        {
-          rg = None;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "core_slice_index_Range_get"
-            | Lean -> "core.slice.index.Range.get");
-        };
-        (* The backward function shouldn't be used *)
-        {
-          rg = rg0;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "core_slice_index_Range_get_back"
-            | Lean -> "core.slice.index.Range.get_back");
-        };
-      ] );
-    ( [ "core"; "slice"; "index"; "Range"; "get_mut" ],
-      None,
-      [
-        {
-          rg = None;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "core_slice_index_Range_get_mut"
-            | Lean -> "core.slice.index.Range.get_mut");
-        };
-        {
-          rg = rg0;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "core_slice_index_Range_get_mut_back"
-            | Lean -> "core.slice.index.Range.get_mut_back");
-        };
-      ] );
-    ( [ "core"; "slice"; "index"; "Range"; "index" ],
-      None,
-      [
-        {
-          rg = None;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "core_slice_index_Range_index"
-            | Lean -> "core.slice.index.Range.index");
-        };
-        (* The backward function shouldn't be used *)
-        {
-          rg = rg0;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "core_slice_index_Range_index_back"
-            | Lean -> "core.slice.index.Range.index_back");
-        };
-      ] );
-    ( [ "core"; "slice"; "index"; "Range"; "index_mut" ],
-      None,
-      [
-        {
-          rg = None;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "core_slice_index_Range_index_mut"
-            | Lean -> "core.slice.index.Range.index_mut");
-        };
-        {
-          rg = rg0;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "core_slice_index_Range_index_mut_back"
-            | Lean -> "core.slice.index.Range.index_mut_back");
-        };
-      ] );
-    ( [ "core"; "slice"; "index"; "Range"; "get_unchecked" ],
-      None,
-      [
-        {
-          rg = None;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "core_slice_index_Range_get_unchecked"
-            | Lean -> "core.slice.index.Range.get_unchecked");
-        };
-      ] );
-    ( [ "core"; "slice"; "index"; "Range"; "get_unchecked_mut" ],
-      None,
-      [
-        {
-          rg = None;
-          extract_name =
-            (match !backend with
-            | FStar | Coq | HOL4 -> "core_slice_index_Range_get_unchecked_mut"
-            | Lean -> "core.slice.index.Range.get_unchecked_mut");
-        };
-      ] );
+    mk_fun
+      [ "core"; "slice"; "index"; "[T]"; "index" ]
+      (Some [ "core"; "slice"; "index"; "Slice"; "index" ])
+      None true false;
+    mk_fun
+      [ "core"; "slice"; "index"; "[T]"; "index_mut" ]
+      (Some [ "core"; "slice"; "index"; "Slice"; "index_mut" ])
+      None true false;
+    mk_fun
+      [ "core"; "array"; "[T; N]"; "index" ]
+      (Some [ "core"; "array"; "Array"; "index" ])
+      None true false;
+    mk_fun
+      [ "core"; "array"; "[T; N]"; "index_mut" ]
+      (Some [ "core"; "array"; "Array"; "index_mut" ])
+      None true false;
+    mk_fun [ "core"; "slice"; "index"; "Range"; "get" ] None None true false;
+    mk_fun [ "core"; "slice"; "index"; "Range"; "get_mut" ] None None true false;
+    mk_fun [ "core"; "slice"; "index"; "Range"; "index" ] None None true false;
+    mk_fun
+      [ "core"; "slice"; "index"; "Range"; "index_mut" ]
+      None None true false;
+    mk_fun
+      [ "core"; "slice"; "index"; "Range"; "get_unchecked" ]
+      None None false false;
+    mk_fun
+      [ "core"; "slice"; "index"; "Range"; "get_unchecked_mut" ]
+      None None false false;
+    mk_fun
+      [ "core"; "slice"; "index"; "usize"; "get" ]
+      (Some [ "core"; "slice"; "index"; "Usize"; "get" ])
+      None true false;
+    mk_fun
+      [ "core"; "slice"; "index"; "usize"; "get_mut" ]
+      (Some [ "core"; "slice"; "index"; "Usize"; "get_mut" ])
+      None true false;
+    mk_fun
+      [ "core"; "slice"; "index"; "usize"; "get_unchecked" ]
+      (Some [ "core"; "slice"; "index"; "Usize"; "get_unchecked" ])
+      None false false;
+    mk_fun
+      [ "core"; "slice"; "index"; "usize"; "get_unchecked_mut" ]
+      (Some [ "core"; "slice"; "index"; "Usize"; "get_unchecked_mut" ])
+      None false false;
+    mk_fun
+      [ "core"; "slice"; "index"; "usize"; "index" ]
+      (Some [ "core"; "slice"; "index"; "Usize"; "index" ])
+      None true false;
+    mk_fun
+      [ "core"; "slice"; "index"; "usize"; "index_mut" ]
+      (Some [ "core"; "slice"; "index"; "Usize"; "index_mut" ])
+      None true false;
   ]
 
 let mk_builtin_funs_map () =
@@ -576,6 +358,8 @@ let builtin_non_fallible_funs =
   in
   let int_funs = List.concat int_funs in
   [
+    "alloc::vec::Vec::new";
+    "alloc::vec::Vec::len";
     "alloc::boxed::Box::deref";
     "alloc::boxed::Box::deref_mut";
     "core::mem::replace";
@@ -847,37 +631,68 @@ end
 
 module SimpleNamePairMap = Collections.MakeMap (SimpleNamePairOrd)
 
-let builtin_trait_impls_info () : ((string list * string list) * string) list =
+let builtin_trait_impls_info () :
+    ((string list * string list) * (bool list option * string)) list =
+  let fmt ?(filter : bool list option = None) (name : string) :
+      bool list option * string =
+    let name =
+      match !backend with
+      | Lean -> name
+      | FStar | Coq | HOL4 ->
+          let name = String.split_on_char '.' name in
+          String.concat "_" name
+    in
+    (filter, name)
+  in
   (* TODO: fix the names like "[T]" below *)
   [
     (* core::ops::Deref<alloc::boxed::Box<T>> *)
     ( ([ "alloc"; "boxed"; "Box" ], [ "core"; "ops"; "deref"; "Deref" ]),
-      "alloc.boxed.Box.coreOpsDerefInst" );
+      fmt "alloc.boxed.Box.coreOpsDerefInst" );
     (* core::ops::DerefMut<alloc::boxed::Box<T>> *)
     ( ([ "alloc"; "boxed"; "Box" ], [ "core"; "ops"; "deref"; "DerefMut" ]),
-      "alloc.boxed.Box.coreOpsDerefMutInst" );
+      fmt "alloc.boxed.Box.coreOpsDerefMutInst" );
     (* core::ops::index::Index<[T], I> *)
     ( ([ "core"; "slice"; "index"; "[T]" ], [ "core"; "ops"; "index"; "Index" ]),
-      "core.slice.index.Slice.coreopsindexIndexInst" );
+      fmt "core.slice.index.Slice.coreopsindexIndexInst" );
     (* core::slice::index::private_slice_index::Sealed<Range<usize>> *)
     ( ( [ "core"; "slice"; "index"; "private_slice_index"; "Range" ],
         [ "core"; "slice"; "index"; "private_slice_index"; "Sealed" ] ),
-      "core.slice.index.private_slice_index.Range.coresliceindexprivate_slice_indexSealedInst"
+      fmt
+        "core.slice.index.private_slice_index.Range.coresliceindexprivate_slice_indexSealedInst"
     );
     (* core::slice::index::SliceIndex<Range<usize>, [T]> *)
     ( ( [ "core"; "slice"; "index"; "Range" ],
         [ "core"; "slice"; "index"; "SliceIndex" ] ),
-      "core.slice.index.Range.coresliceindexSliceIndexInst" );
+      fmt "core.slice.index.Range.coresliceindexSliceIndexInst" );
     (* core::ops::index::IndexMut<[T], I> *)
     ( ( [ "core"; "slice"; "index"; "[T]" ],
         [ "core"; "ops"; "index"; "IndexMut" ] ),
-      "core.slice.index.Slice.coreopsindexIndexMutInst" );
+      fmt "core.slice.index.Slice.coreopsindexIndexMutInst" );
     (* core::ops::index::Index<[T; N], I> *)
     ( ([ "core"; "array"; "[T; N]" ], [ "core"; "ops"; "index"; "Index" ]),
-      "core.array.Array.coreopsindexIndexInst" );
+      fmt "core.array.Array.coreopsindexIndexInst" );
     (* core::ops::index::IndexMut<[T; N], I> *)
     ( ([ "core"; "array"; "[T; N]" ], [ "core"; "ops"; "index"; "IndexMut" ]),
-      "core.array.Array.coreopsindexIndexMutInst" );
+      fmt "core.array.Array.coreopsindexIndexMutInst" );
+    (* core::slice::index::private_slice_index::Sealed<usize> *)
+    ( ( [ "core"; "slice"; "index"; "private_slice_index"; "usize" ],
+        [ "core"; "slice"; "index"; "private_slice_index"; "Sealed" ] ),
+      fmt
+        "core.slice.index.private_slice_index.usize.coresliceindexprivate_slice_indexSealedInst"
+    );
+    (* core::slice::index::SliceIndex<usize, [T]> *)
+    ( ( [ "core"; "slice"; "index"; "usize" ],
+        [ "core"; "slice"; "index"; "SliceIndex" ] ),
+      fmt "core.slice.index.usize.coresliceindexSliceIndexInst" );
+    (* core::ops::index::Index<Vec<T>, T> *)
+    ( ([ "alloc"; "vec"; "Vec" ], [ "core"; "ops"; "index"; "Index" ]),
+      let filter = Some [ true; true; false ] in
+      fmt ~filter "alloc.vec.Vec.coreopsindexIndexInst" );
+    (* core::ops::index::IndexMut<Vec<T>, T> *)
+    ( ([ "alloc"; "vec"; "Vec" ], [ "core"; "ops"; "index"; "IndexMut" ]),
+      let filter = Some [ true; true; false ] in
+      fmt ~filter "alloc.vec.Vec.coreopsindexIndexMutInst" );
   ]
 
 let mk_builtin_trait_impls_map () =
diff --git a/compiler/ExtractTypes.ml b/compiler/ExtractTypes.ml
new file mode 100644
index 00000000..219f273f
--- /dev/null
+++ b/compiler/ExtractTypes.ml
@@ -0,0 +1,2390 @@
+(** The generic extraction *)
+(* Turn the whole module into a functor: it is very annoying to carry the
+   the formatter everywhere...
+*)
+
+open Pure
+open PureUtils
+open TranslateCore
+open ExtractBase
+open StringUtils
+open Config
+module F = Format
+
+(** Small helper to compute the name of an int type *)
+let int_name (int_ty : integer_type) =
+  let isize, usize, i_format, u_format =
+    match !backend with
+    | FStar | Coq | HOL4 ->
+        ("isize", "usize", format_of_string "i%d", format_of_string "u%d")
+    | Lean -> ("Isize", "Usize", format_of_string "I%d", format_of_string "U%d")
+  in
+  match int_ty with
+  | Isize -> isize
+  | I8 -> Printf.sprintf i_format 8
+  | I16 -> Printf.sprintf i_format 16
+  | I32 -> Printf.sprintf i_format 32
+  | I64 -> Printf.sprintf i_format 64
+  | I128 -> Printf.sprintf i_format 128
+  | Usize -> usize
+  | U8 -> Printf.sprintf u_format 8
+  | U16 -> Printf.sprintf u_format 16
+  | U32 -> Printf.sprintf u_format 32
+  | U64 -> Printf.sprintf u_format 64
+  | U128 -> Printf.sprintf u_format 128
+
+(** Small helper to compute the name of a unary operation *)
+let unop_name (unop : unop) : string =
+  match unop with
+  | Not -> (
+      match !backend with FStar | Lean -> "not" | Coq -> "negb" | HOL4 -> "~")
+  | Neg (int_ty : integer_type) -> (
+      match !backend with Lean -> "-" | _ -> int_name int_ty ^ "_neg")
+  | Cast _ ->
+      (* We never directly use the unop name in this case *)
+      raise (Failure "Unsupported")
+
+(** Small helper to compute the name of a binary operation (note that many
+    binary operations like "less than" are extracted to primitive operations,
+    like [<]).
+ *)
+let named_binop_name (binop : E.binop) (int_ty : integer_type) : string =
+  let binop =
+    match binop with
+    | Div -> "div"
+    | Rem -> "rem"
+    | Add -> "add"
+    | Sub -> "sub"
+    | Mul -> "mul"
+    | Lt -> "lt"
+    | Le -> "le"
+    | Ge -> "ge"
+    | Gt -> "gt"
+    | BitXor -> "xor"
+    | BitAnd -> "and"
+    | BitOr -> "or"
+    | Shl -> "lsl"
+    | Shr ->
+        "asr"
+        (* NOTE: make sure arithmetic shift right is implemented, i.e. OCaml's asr operator, not lsr *)
+    | _ -> raise (Failure "Unreachable")
+  in
+  (* Remark: the Lean case is actually not used *)
+  match !backend with
+  | Lean -> int_name int_ty ^ "." ^ binop
+  | FStar | Coq | HOL4 -> int_name int_ty ^ "_" ^ binop
+
+(** A list of keywords/identifiers used by the backend and with which we
+    want to check collision.
+
+    Remark: this is useful mostly to look for collisions when generating
+    names for *variables*.
+ *)
+let keywords () =
+  let named_unops =
+    unop_name Not
+    :: List.map (fun it -> unop_name (Neg it)) T.all_signed_int_types
+  in
+  let named_binops = [ E.Div; Rem; Add; Sub; Mul ] in
+  let named_binops =
+    List.concat_map
+      (fun bn -> List.map (fun it -> named_binop_name bn it) T.all_int_types)
+      named_binops
+  in
+  let misc =
+    match !backend with
+    | FStar ->
+        [
+          "assert";
+          "assert_norm";
+          "assume";
+          "else";
+          "fun";
+          "fn";
+          "FStar";
+          "FStar.Mul";
+          "if";
+          "in";
+          "include";
+          "int";
+          "let";
+          "list";
+          "match";
+          "not";
+          "open";
+          "rec";
+          "scalar_cast";
+          "then";
+          "type";
+          "Type0";
+          "Type";
+          "unit";
+          "val";
+          "with";
+        ]
+    | Coq ->
+        [
+          "assert";
+          "Arguments";
+          "Axiom";
+          "char_of_byte";
+          "Check";
+          "Declare";
+          "Definition";
+          "else";
+          "End";
+          "fun";
+          "Fixpoint";
+          "if";
+          "in";
+          "int";
+          "Inductive";
+          "Import";
+          "let";
+          "Lemma";
+          "match";
+          "Module";
+          "not";
+          "Notation";
+          "Proof";
+          "Qed";
+          "rec";
+          "Record";
+          "Require";
+          "Scope";
+          "Search";
+          "SearchPattern";
+          "Set";
+          "then";
+          (* [tt] is unit *)
+          "tt";
+          "type";
+          "Type";
+          "unit";
+          "with";
+        ]
+    | Lean ->
+        [
+          "by";
+          "class";
+          "decreasing_by";
+          "def";
+          "deriving";
+          "do";
+          "else";
+          "end";
+          "for";
+          "have";
+          "if";
+          "inductive";
+          "instance";
+          "import";
+          "let";
+          "macro";
+          "match";
+          "namespace";
+          "opaque";
+          "open";
+          "run_cmd";
+          "set_option";
+          "simp";
+          "structure";
+          "syntax";
+          "termination_by";
+          "then";
+          "Type";
+          "unsafe";
+          "where";
+          "with";
+          "opaque_defs";
+        ]
+    | HOL4 ->
+        [
+          "Axiom";
+          "case";
+          "Definition";
+          "else";
+          "End";
+          "fix";
+          "fix_exec";
+          "fn";
+          "fun";
+          "if";
+          "in";
+          "int";
+          "Inductive";
+          "let";
+          "of";
+          "Proof";
+          "QED";
+          "then";
+          "Theorem";
+        ]
+  in
+  List.concat [ named_unops; named_binops; misc ]
+
+let assumed_adts () : (assumed_ty * string) list =
+  match !backend with
+  | Lean ->
+      [
+        (State, "State");
+        (Result, "Result");
+        (Error, "Error");
+        (Fuel, "Nat");
+        (Array, "Array");
+        (Slice, "Slice");
+        (Str, "Str");
+        (RawPtr Mut, "MutRawPtr");
+        (RawPtr Const, "ConstRawPtr");
+      ]
+  | Coq | FStar | HOL4 ->
+      [
+        (State, "state");
+        (Result, "result");
+        (Error, "error");
+        (Fuel, if !backend = HOL4 then "num" else "nat");
+        (Array, "array");
+        (Slice, "slice");
+        (Str, "str");
+        (RawPtr Mut, "mut_raw_ptr");
+        (RawPtr Const, "const_raw_ptr");
+      ]
+
+let assumed_struct_constructors () : (assumed_ty * string) list =
+  match !backend with
+  | Lean -> [ (Array, "Array.make") ]
+  | Coq -> [ (Array, "mk_array") ]
+  | FStar -> [ (Array, "mk_array") ]
+  | HOL4 -> [ (Array, "mk_array") ]
+
+let assumed_variants () : (assumed_ty * VariantId.id * string) list =
+  match !backend with
+  | FStar ->
+      [
+        (Result, result_return_id, "Return");
+        (Result, result_fail_id, "Fail");
+        (Error, error_failure_id, "Failure");
+        (Error, error_out_of_fuel_id, "OutOfFuel");
+        (* No Fuel::Zero on purpose *)
+        (* No Fuel::Succ on purpose *)
+      ]
+  | Coq ->
+      [
+        (Result, result_return_id, "Return");
+        (Result, result_fail_id, "Fail_");
+        (Error, error_failure_id, "Failure");
+        (Error, error_out_of_fuel_id, "OutOfFuel");
+        (Fuel, fuel_zero_id, "O");
+        (Fuel, fuel_succ_id, "S");
+      ]
+  | Lean ->
+      [
+        (Result, result_return_id, "ret");
+        (Result, result_fail_id, "fail");
+        (Error, error_failure_id, "panic");
+        (* No Fuel::Zero on purpose *)
+        (* No Fuel::Succ on purpose *)
+      ]
+  | HOL4 ->
+      [
+        (Result, result_return_id, "Return");
+        (Result, result_fail_id, "Fail");
+        (Error, error_failure_id, "Failure");
+        (* No Fuel::Zero on purpose *)
+        (* No Fuel::Succ on purpose *)
+      ]
+
+let assumed_llbc_functions () :
+    (A.assumed_fun_id * T.RegionGroupId.id option * string) list =
+  let rg0 = Some T.RegionGroupId.zero in
+  match !backend with
+  | FStar | Coq | HOL4 ->
+      [
+        (ArrayIndexShared, None, "array_index_shared");
+        (ArrayIndexMut, None, "array_index_mut_fwd");
+        (ArrayIndexMut, rg0, "array_index_mut_back");
+        (ArrayToSliceShared, None, "array_to_slice_shared");
+        (ArrayToSliceMut, None, "array_to_slice_mut_fwd");
+        (ArrayToSliceMut, rg0, "array_to_slice_mut_back");
+        (ArrayRepeat, None, "array_repeat");
+        (SliceIndexShared, None, "slice_index_shared");
+        (SliceIndexMut, None, "slice_index_mut_fwd");
+        (SliceIndexMut, rg0, "slice_index_mut_back");
+        (SliceLen, None, "slice_len");
+      ]
+  | Lean ->
+      [
+        (ArrayIndexShared, None, "Array.index_shared");
+        (ArrayIndexMut, None, "Array.index_mut");
+        (ArrayIndexMut, rg0, "Array.index_mut_back");
+        (ArrayToSliceShared, None, "Array.to_slice_shared");
+        (ArrayToSliceMut, None, "Array.to_slice_mut");
+        (ArrayToSliceMut, rg0, "Array.to_slice_mut_back");
+        (ArrayRepeat, None, "Array.repeat");
+        (SliceIndexShared, None, "Slice.index_shared");
+        (SliceIndexMut, None, "Slice.index_mut");
+        (SliceIndexMut, rg0, "Slice.index_mut_back");
+        (SliceLen, None, "Slice.len");
+      ]
+
+let assumed_pure_functions () : (pure_assumed_fun_id * string) list =
+  match !backend with
+  | FStar ->
+      [
+        (Return, "return");
+        (Fail, "fail");
+        (Assert, "massert");
+        (FuelDecrease, "decrease");
+        (FuelEqZero, "is_zero");
+      ]
+  | Coq ->
+      (* We don't provide [FuelDecrease] and [FuelEqZero] on purpose *)
+      [ (Return, "return_"); (Fail, "fail_"); (Assert, "massert") ]
+  | Lean ->
+      (* We don't provide [FuelDecrease] and [FuelEqZero] on purpose *)
+      [ (Return, "return"); (Fail, "fail_"); (Assert, "massert") ]
+  | HOL4 ->
+      (* We don't provide [FuelDecrease] and [FuelEqZero] on purpose *)
+      [ (Return, "return"); (Fail, "fail"); (Assert, "massert") ]
+
+let names_map_init () : names_map_init =
+  {
+    keywords = keywords ();
+    assumed_adts = assumed_adts ();
+    assumed_structs = assumed_struct_constructors ();
+    assumed_variants = assumed_variants ();
+    assumed_llbc_functions = assumed_llbc_functions ();
+    assumed_pure_functions = assumed_pure_functions ();
+  }
+
+let extract_unop (extract_expr : bool -> texpression -> unit)
+    (fmt : F.formatter) (inside : bool) (unop : unop) (arg : texpression) : unit
+    =
+  match unop with
+  | Not | Neg _ ->
+      let unop = unop_name unop in
+      if inside then F.pp_print_string fmt "(";
+      F.pp_print_string fmt unop;
+      F.pp_print_space fmt ();
+      extract_expr true arg;
+      if inside then F.pp_print_string fmt ")"
+  | Cast (src, tgt) -> (
+      (* HOL4 has a special treatment: because it doesn't support dependent
+         types, we don't have a specific operator for the cast *)
+      match !backend with
+      | HOL4 ->
+          (* Casting, say, an u32 to an i32 would be done as follows:
+             {[
+               mk_i32 (u32_to_int x)
+             ]}
+          *)
+          if inside then F.pp_print_string fmt "(";
+          F.pp_print_string fmt ("mk_" ^ int_name tgt);
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt "(";
+          F.pp_print_string fmt (int_name src ^ "_to_int");
+          F.pp_print_space fmt ();
+          extract_expr true arg;
+          F.pp_print_string fmt ")";
+          if inside then F.pp_print_string fmt ")"
+      | FStar | Coq | Lean ->
+          (* Rem.: the source type is an implicit parameter *)
+          if inside then F.pp_print_string fmt "(";
+          let cast_str =
+            match !backend with
+            | Coq | FStar -> "scalar_cast"
+            | Lean -> (* TODO: I8.cast, I16.cast, etc.*) "Scalar.cast"
+            | HOL4 -> raise (Failure "Unreachable")
+          in
+          F.pp_print_string fmt cast_str;
+          F.pp_print_space fmt ();
+          if !backend <> Lean then (
+            F.pp_print_string fmt
+              (StringUtils.capitalize_first_letter
+                 (PrintPure.integer_type_to_string src));
+            F.pp_print_space fmt ());
+          if !backend = Lean then F.pp_print_string fmt ("." ^ int_name tgt)
+          else
+            F.pp_print_string fmt
+              (StringUtils.capitalize_first_letter
+                 (PrintPure.integer_type_to_string tgt));
+          F.pp_print_space fmt ();
+          extract_expr true arg;
+          if inside then F.pp_print_string fmt ")")
+
+(** [extract_expr] : the boolean argument is [inside] *)
+let extract_binop (extract_expr : bool -> texpression -> unit)
+    (fmt : F.formatter) (inside : bool) (binop : E.binop)
+    (int_ty : integer_type) (arg0 : texpression) (arg1 : texpression) : unit =
+  if inside then F.pp_print_string fmt "(";
+  (* Some binary operations have a special notation depending on the backend *)
+  (match (!backend, binop) with
+  | HOL4, (Eq | Ne)
+  | (FStar | Coq | Lean), (Eq | Lt | Le | Ne | Ge | Gt)
+  | Lean, (Div | Rem | Add | Sub | Mul) ->
+      let binop =
+        match binop with
+        | Eq -> "="
+        | Lt -> "<"
+        | Le -> "<="
+        | Ne -> if !backend = Lean then "!=" else "<>"
+        | Ge -> ">="
+        | Gt -> ">"
+        | Div -> "/"
+        | Rem -> "%"
+        | Add -> "+"
+        | Sub -> "-"
+        | Mul -> "*"
+        | _ -> raise (Failure "Unreachable")
+      in
+      let binop =
+        match !backend with FStar | Lean | HOL4 -> binop | Coq -> "s" ^ binop
+      in
+      extract_expr false arg0;
+      F.pp_print_space fmt ();
+      F.pp_print_string fmt binop;
+      F.pp_print_space fmt ();
+      extract_expr false arg1
+  | _ ->
+      let binop = named_binop_name binop int_ty in
+      F.pp_print_string fmt binop;
+      F.pp_print_space fmt ();
+      extract_expr true arg0;
+      F.pp_print_space fmt ();
+      extract_expr true arg1);
+  if inside then F.pp_print_string fmt ")"
+
+let type_decl_kind_to_qualif (kind : decl_kind)
+    (type_kind : type_decl_kind option) : string option =
+  match !backend with
+  | FStar -> (
+      match kind with
+      | SingleNonRec -> Some "type"
+      | SingleRec -> Some "type"
+      | MutRecFirst -> Some "type"
+      | MutRecInner -> Some "and"
+      | MutRecLast -> Some "and"
+      | Assumed -> Some "assume type"
+      | Declared -> Some "val")
+  | Coq -> (
+      match (kind, type_kind) with
+      | SingleNonRec, Some Enum -> Some "Inductive"
+      | SingleNonRec, Some Struct -> Some "Record"
+      | (SingleRec | MutRecFirst), Some _ -> Some "Inductive"
+      | (MutRecInner | MutRecLast), Some _ ->
+          (* Coq doesn't support groups of mutually recursive definitions which mix
+           * records and inducties: we convert everything to records if this happens
+           *)
+          Some "with"
+      | (Assumed | Declared), None -> Some "Axiom"
+      | SingleNonRec, None ->
+          (* This is for traits *)
+          Some "Record"
+      | _ ->
+          raise
+            (Failure
+               ("Unexpected: (" ^ show_decl_kind kind ^ ", "
+               ^ Print.option_to_string show_type_decl_kind type_kind
+               ^ ")")))
+  | Lean -> (
+      match kind with
+      | SingleNonRec ->
+          if type_kind = Some Struct then Some "structure" else Some "inductive"
+      | SingleRec -> Some "inductive"
+      | MutRecFirst -> Some "inductive"
+      | MutRecInner -> Some "inductive"
+      | MutRecLast -> Some "inductive"
+      | Assumed -> Some "axiom"
+      | Declared -> Some "axiom")
+  | HOL4 -> None
+
+let fun_decl_kind_to_qualif (kind : decl_kind) : string option =
+  match !backend with
+  | FStar -> (
+      match kind with
+      | SingleNonRec -> Some "let"
+      | SingleRec -> Some "let rec"
+      | MutRecFirst -> Some "let rec"
+      | MutRecInner -> Some "and"
+      | MutRecLast -> Some "and"
+      | Assumed -> Some "assume val"
+      | Declared -> Some "val")
+  | Coq -> (
+      match kind with
+      | SingleNonRec -> Some "Definition"
+      | SingleRec -> Some "Fixpoint"
+      | MutRecFirst -> Some "Fixpoint"
+      | MutRecInner -> Some "with"
+      | MutRecLast -> Some "with"
+      | Assumed -> Some "Axiom"
+      | Declared -> Some "Axiom")
+  | Lean -> (
+      match kind with
+      | SingleNonRec -> Some "def"
+      | SingleRec -> Some "divergent def"
+      | MutRecFirst -> Some "mutual divergent def"
+      | MutRecInner -> Some "divergent def"
+      | MutRecLast -> Some "divergent def"
+      | Assumed -> Some "axiom"
+      | Declared -> Some "axiom")
+  | HOL4 -> None
+
+(** The type of types.
+
+    TODO: move inside the formatter?
+ *)
+let type_keyword () =
+  match !backend with
+  | FStar -> "Type0"
+  | Coq | Lean -> "Type"
+  | HOL4 -> raise (Failure "Unexpected")
+
+(**
+   [ctx]: we use the context to lookup type definitions, to retrieve type names.
+   This is used to compute variable names, when they have no basenames: in this
+   case we use the first letter of the type name.
+
+   [variant_concatenate_type_name]: if true, add the type name as a prefix
+   to the variant names.
+   Ex.:
+   In Rust:
+     {[
+       enum List = {
+         Cons(u32, Box<List>),x
+         Nil,
+       }
+     ]}
+
+   F*, if option activated:
+     {[
+       type list =
+       | ListCons : u32 -> list -> list
+       | ListNil : list
+     ]}
+
+   F*, if option not activated:
+     {[
+       type list =
+       | Cons : u32 -> list -> list
+       | Nil : list
+     ]}
+
+   Rk.: this should be true by default, because in Rust all the variant names
+   are actively uniquely identifier by the type name [List::Cons(...)], while
+   in other languages it is not necessarily the case, and thus clashes can mess
+   up type checking. Note that some languages actually forbids the name clashes
+   (it is the case of F* ).
+ *)
+let mk_formatter (ctx : trans_ctx) (crate_name : string)
+    (variant_concatenate_type_name : bool) : formatter =
+  let int_name = int_name in
+
+  (* Prepare a name.
+   * The first id elem is always the crate: if it is the local crate,
+   * we remove it.
+   * We also remove all the disambiguators, then convert everything to strings.
+   * **Rmk:** because we remove the disambiguators, there may be name collisions
+   * (which is ok, because we check for name collisions and fail if there is any).
+   *)
+  let get_name (name : name) : string list =
+    (* Rmk.: initially we only filtered the disambiguators equal to 0 *)
+    let name = Names.filter_disambiguators name in
+    match name with
+    | Ident crate :: name ->
+        let name = if crate = crate_name then name else Ident crate :: name in
+        let name =
+          List.map
+            (function
+              | Names.Ident s -> s
+              | Disambiguator d -> Names.Disambiguator.to_string d)
+            name
+        in
+        name
+    | _ ->
+        raise (Failure ("Unexpected name shape: " ^ Print.name_to_string name))
+  in
+  let flatten_name (name : string list) : string =
+    match !backend with
+    | FStar | Coq | HOL4 -> String.concat "_" name
+    | Lean -> String.concat "." name
+  in
+  let get_type_name = get_name in
+  let type_name_to_camel_case name =
+    let name = get_type_name name in
+    let name = List.map to_camel_case name in
+    String.concat "" name
+  in
+  let type_name_to_snake_case name =
+    let name = get_type_name name in
+    let name = List.map to_snake_case name in
+    let name = String.concat "_" name in
+    match !backend with
+    | FStar | Lean | HOL4 -> name
+    | Coq -> capitalize_first_letter name
+  in
+  let type_name name =
+    match !backend with
+    | FStar | Coq | HOL4 -> type_name_to_snake_case name ^ "_t"
+    | Lean -> String.concat "." (get_type_name name)
+  in
+  let field_name (def_name : name) (field_id : FieldId.id)
+      (field_name : string option) : string =
+    let field_name_s =
+      match field_name with
+      | Some field_name -> field_name
+      | None ->
+          (* TODO: extract structs with no field names to tuples *)
+          FieldId.to_string field_id
+    in
+    if !Config.record_fields_short_names then
+      if field_name = None then (* TODO: this is a bit ugly *)
+        "_" ^ field_name_s
+      else field_name_s
+    else
+      let def_name = type_name_to_snake_case def_name ^ "_" in
+      def_name ^ field_name_s
+  in
+  let variant_name (def_name : name) (variant : string) : string =
+    match !backend with
+    | FStar | Coq | HOL4 ->
+        let variant = to_camel_case variant in
+        if variant_concatenate_type_name then
+          type_name_to_camel_case def_name ^ variant
+        else variant
+    | Lean -> variant
+  in
+  let struct_constructor (basename : name) : string =
+    let tname = type_name basename in
+    let prefix =
+      match !backend with FStar -> "Mk" | Coq | HOL4 -> "mk" | Lean -> ""
+    in
+    let suffix =
+      match !backend with FStar | Coq | HOL4 -> "" | Lean -> ".mk"
+    in
+    prefix ^ tname ^ suffix
+  in
+  let get_fun_name fname =
+    let fname = get_name fname in
+    (* TODO: don't convert to snake case for Coq, HOL4, F* *)
+    flatten_name fname
+  in
+  let global_name (name : global_name) : string =
+    (* Converting to snake case also lowercases the letters (in Rust, global
+     * names are written in capital letters). *)
+    let parts = List.map to_snake_case (get_name name) in
+    String.concat "_" parts
+  in
+  let fun_name (fname : fun_name) (num_loops : int) (loop_id : LoopId.id option)
+      (num_rgs : int) (rg : region_group_info option) (filter_info : bool * int)
+      : string =
+    let fname = get_fun_name fname in
+    (* Compute the suffix *)
+    let suffix = default_fun_suffix num_loops loop_id num_rgs rg filter_info in
+    (* Concatenate *)
+    fname ^ suffix
+  in
+
+  let trait_decl_name (trait_decl : trait_decl) : string =
+    type_name trait_decl.name
+  in
+
+  let trait_impl_name (trait_decl : trait_decl) (trait_impl : trait_impl) :
+      string =
+    (* TODO: provisional: we concatenate the trait impl name (which is its type)
+       with the trait decl name *)
+    let trait_decl =
+      let name = trait_decl.name in
+      match !backend with
+      | FStar | Coq | HOL4 -> type_name_to_snake_case name ^ "_inst"
+      | Lean -> String.concat "" (get_type_name name) ^ "Inst"
+    in
+    flatten_name (get_type_name trait_impl.name @ [ trait_decl ])
+  in
+
+  let trait_parent_clause_name (trait_decl : trait_decl) (clause : trait_clause)
+      : string =
+    (* TODO: improve - it would be better to not use indices *)
+    let clause = "parent_clause_" ^ TraitClauseId.to_string clause.clause_id in
+    if !Config.record_fields_short_names then clause
+    else trait_decl_name trait_decl ^ "_" ^ clause
+  in
+  let trait_type_name (trait_decl : trait_decl) (item : string) : string =
+    if !Config.record_fields_short_names then item
+    else trait_decl_name trait_decl ^ "_" ^ item
+  in
+  let trait_const_name (trait_decl : trait_decl) (item : string) : string =
+    if !Config.record_fields_short_names then item
+    else trait_decl_name trait_decl ^ "_" ^ item
+  in
+  let trait_method_name (trait_decl : trait_decl) (item : string) : string =
+    if !Config.record_fields_short_names then item
+    else trait_decl_name trait_decl ^ "_" ^ item
+  in
+  let trait_type_clause_name (trait_decl : trait_decl) (item : string)
+      (clause : trait_clause) : string =
+    (* TODO: improve - it would be better to not use indices *)
+    trait_type_name trait_decl item
+    ^ "_clause_"
+    ^ TraitClauseId.to_string clause.clause_id
+  in
+
+  let termination_measure_name (_fid : A.FunDeclId.id) (fname : fun_name)
+      (num_loops : int) (loop_id : LoopId.id option) : string =
+    let fname = get_fun_name fname in
+    let lp_suffix = default_fun_loop_suffix num_loops loop_id in
+    (* Compute the suffix *)
+    let suffix =
+      match !Config.backend with
+      | FStar -> "_decreases"
+      | Lean -> "_terminates"
+      | Coq | HOL4 -> raise (Failure "Unexpected")
+    in
+    (* Concatenate *)
+    fname ^ lp_suffix ^ suffix
+  in
+
+  let decreases_proof_name (_fid : A.FunDeclId.id) (fname : fun_name)
+      (num_loops : int) (loop_id : LoopId.id option) : string =
+    let fname = get_fun_name fname in
+    let lp_suffix = default_fun_loop_suffix num_loops loop_id in
+    (* Compute the suffix *)
+    let suffix =
+      match !Config.backend with
+      | Lean -> "_decreases"
+      | FStar | Coq | HOL4 -> raise (Failure "Unexpected")
+    in
+    (* Concatenate *)
+    fname ^ lp_suffix ^ suffix
+  in
+
+  let var_basename (_varset : StringSet.t) (basename : string option) (ty : ty)
+      : string =
+    (* Small helper to derive var names from ADT type names.
+
+       We do the following:
+       - convert the type name to snake case
+       - take the first letter of every "letter group"
+       Ex.: "HashMap" -> "hash_map" -> "hm"
+    *)
+    let name_from_type_ident (name : string) : string =
+      let cl = to_snake_case name in
+      let cl = String.split_on_char '_' cl in
+      let cl = List.filter (fun s -> String.length s > 0) cl in
+      assert (List.length cl > 0);
+      let cl = List.map (fun s -> s.[0]) cl in
+      StringUtils.string_of_chars cl
+    in
+    (* If there is a basename, we use it *)
+    match basename with
+    | Some basename ->
+        (* This should be a no-op *)
+        to_snake_case basename
+    | None -> (
+        (* No basename: we use the first letter of the type *)
+        match ty with
+        | Adt (type_id, generics) -> (
+            match type_id with
+            | Tuple ->
+                (* The "pair" case is frequent enough to have its special treatment *)
+                if List.length generics.types = 2 then "p" else "t"
+            | Assumed Result -> "r"
+            | Assumed Error -> ConstStrings.error_basename
+            | Assumed Fuel -> ConstStrings.fuel_basename
+            | Assumed Array -> "a"
+            | Assumed Slice -> "s"
+            | Assumed Str -> "s"
+            | Assumed State -> ConstStrings.state_basename
+            | Assumed (RawPtr _) -> "p"
+            | AdtId adt_id ->
+                let def = TypeDeclId.Map.find adt_id ctx.type_ctx.type_decls in
+                (* Derive the var name from the last ident of the type name
+                 * Ex.: ["hashmap"; "HashMap"] ~~> "HashMap" -> "hash_map" -> "hm"
+                 *)
+                (* The name shouldn't be empty, and its last element should
+                 * be an ident *)
+                let cl = List.nth def.name (List.length def.name - 1) in
+                name_from_type_ident (Names.as_ident cl))
+        | TypeVar _ -> (
+            (* TODO: use "t" also for F* *)
+            match !backend with
+            | FStar -> "x" (* lacking inspiration here... *)
+            | Coq | Lean | HOL4 -> "t" (* lacking inspiration here... *))
+        | Literal lty -> (
+            match lty with Bool -> "b" | Char -> "c" | Integer _ -> "i")
+        | Arrow _ -> "f"
+        | TraitType (_, _, name) -> name_from_type_ident name)
+  in
+  let type_var_basename (_varset : StringSet.t) (basename : string) : string =
+    (* Rust type variables are snake-case and start with a capital letter *)
+    match !backend with
+    | FStar ->
+        (* This is *not* a no-op: this removes the capital letter *)
+        to_snake_case basename
+    | HOL4 ->
+        (* In HOL4, type variable names must start with "'" *)
+        "'" ^ to_snake_case basename
+    | Coq | Lean -> basename
+  in
+  let const_generic_var_basename (_varset : StringSet.t) (basename : string) :
+      string =
+    (* Rust type variables are snake-case and start with a capital letter *)
+    match !backend with
+    | FStar | HOL4 ->
+        (* This is *not* a no-op: this removes the capital letter *)
+        to_snake_case basename
+    | Coq | Lean -> basename
+  in
+  let trait_clause_basename (_varset : StringSet.t) (_clause : trait_clause) :
+      string =
+    (* TODO: actually use the clause to derive the name *)
+    "inst"
+  in
+  let trait_self_clause_basename = "self_clause" in
+  let append_index (basename : string) (i : int) : string =
+    basename ^ string_of_int i
+  in
+
+  let extract_literal (fmt : F.formatter) (inside : bool) (cv : literal) : unit
+      =
+    match cv with
+    | Scalar sv -> (
+        match !backend with
+        | FStar -> F.pp_print_string fmt (Z.to_string sv.PV.value)
+        | Coq | HOL4 | Lean ->
+            let print_brackets = inside && !backend = HOL4 in
+            if print_brackets then F.pp_print_string fmt "(";
+            (match !backend with
+            | Coq | Lean -> ()
+            | HOL4 ->
+                F.pp_print_string fmt ("int_to_" ^ int_name sv.PV.int_ty);
+                F.pp_print_space fmt ()
+            | _ -> raise (Failure "Unreachable"));
+            (* We need to add parentheses if the value is negative *)
+            if sv.PV.value >= Z.of_int 0 then
+              F.pp_print_string fmt (Z.to_string sv.PV.value)
+            else if !backend = Lean then
+              (* TODO: parsing issues with Lean because there are ambiguous
+                 interpretations between int values and nat values *)
+              F.pp_print_string fmt
+                ("(-(" ^ Z.to_string (Z.neg sv.PV.value) ^ ":Int))")
+            else F.pp_print_string fmt ("(" ^ Z.to_string sv.PV.value ^ ")");
+            (match !backend with
+            | Coq ->
+                let iname = int_name sv.PV.int_ty in
+                F.pp_print_string fmt ("%" ^ iname)
+            | Lean ->
+                let iname = String.lowercase_ascii (int_name sv.PV.int_ty) in
+                F.pp_print_string fmt ("#" ^ iname)
+            | HOL4 -> ()
+            | _ -> raise (Failure "Unreachable"));
+            if print_brackets then F.pp_print_string fmt ")")
+    | Bool b ->
+        let b =
+          match !backend with
+          | HOL4 -> if b then "T" else "F"
+          | Coq | FStar | Lean -> if b then "true" else "false"
+        in
+        F.pp_print_string fmt b
+    | Char c -> (
+        match !backend with
+        | HOL4 ->
+            (* [#"a"] is a notation for [CHR 97] (97 is the ASCII code for 'a') *)
+            F.pp_print_string fmt ("#\"" ^ String.make 1 c ^ "\"")
+        | FStar | Lean -> F.pp_print_string fmt ("'" ^ String.make 1 c ^ "'")
+        | Coq ->
+            if inside then F.pp_print_string fmt "(";
+            F.pp_print_string fmt "char_of_byte";
+            F.pp_print_space fmt ();
+            (* Convert the the char to ascii *)
+            let c =
+              let i = Char.code c in
+              let x0 = i / 16 in
+              let x1 = i mod 16 in
+              "Coq.Init.Byte.x" ^ string_of_int x0 ^ string_of_int x1
+            in
+            F.pp_print_string fmt c;
+            if inside then F.pp_print_string fmt ")")
+  in
+  let bool_name = if !backend = Lean then "Bool" else "bool" in
+  let char_name = if !backend = Lean then "Char" else "char" in
+  let str_name = if !backend = Lean then "String" else "string" in
+  {
+    bool_name;
+    char_name;
+    int_name;
+    str_name;
+    type_decl_kind_to_qualif;
+    fun_decl_kind_to_qualif;
+    field_name;
+    variant_name;
+    struct_constructor;
+    type_name;
+    global_name;
+    fun_name;
+    termination_measure_name;
+    decreases_proof_name;
+    trait_decl_name;
+    trait_impl_name;
+    trait_parent_clause_name;
+    trait_const_name;
+    trait_type_name;
+    trait_method_name;
+    trait_type_clause_name;
+    var_basename;
+    type_var_basename;
+    const_generic_var_basename;
+    trait_self_clause_basename;
+    trait_clause_basename;
+    append_index;
+    extract_literal;
+    extract_unop;
+    extract_binop;
+  }
+
+let mk_formatter_and_names_map (ctx : trans_ctx) (crate_name : string)
+    (variant_concatenate_type_name : bool) : formatter * names_map =
+  let fmt = mk_formatter ctx crate_name variant_concatenate_type_name in
+  let names_map = initialize_names_map fmt (names_map_init ()) in
+  (fmt, names_map)
+
+let is_single_opaque_fun_decl_group (dg : Pure.fun_decl list) : bool =
+  match dg with [ d ] -> d.body = None | _ -> false
+
+let is_single_opaque_type_decl_group (dg : Pure.type_decl list) : bool =
+  match dg with [ d ] -> d.kind = Opaque | _ -> false
+
+let is_empty_record_type_decl (d : Pure.type_decl) : bool = d.kind = Struct []
+
+let is_empty_record_type_decl_group (dg : Pure.type_decl list) : bool =
+  match dg with [ d ] -> is_empty_record_type_decl d | _ -> false
+
+(** In some provers, groups of definitions must be delimited.
+
+    - in Coq, *every* group (including singletons) must end with "."
+    - in Lean, groups of mutually recursive definitions must end with "end"
+    - in HOL4 (in most situations) the whole group must be within a `Define` command
+
+    Calls to {!extract_fun_decl} should be inserted between calls to
+    {!start_fun_decl_group} and {!end_fun_decl_group}.
+
+    TODO: maybe those [{start/end}_decl_group] functions are not that much a good
+    idea and we should merge them with the corresponding [extract_decl] functions.
+ *)
+let start_fun_decl_group (ctx : extraction_ctx) (fmt : F.formatter)
+    (is_rec : bool) (dg : Pure.fun_decl list) =
+  match !backend with
+  | FStar | Coq | Lean -> ()
+  | HOL4 ->
+      (* In HOL4, opaque functions have a special treatment *)
+      if is_single_opaque_fun_decl_group dg then ()
+      else
+        let compute_fun_def_name (def : Pure.fun_decl) : string =
+          ctx_get_local_function def.def_id def.loop_id def.back_id ctx ^ "_def"
+        in
+        let names = List.map compute_fun_def_name dg in
+        (* Add a break before *)
+        F.pp_print_break fmt 0 0;
+        (* Open the box for the delimiters *)
+        F.pp_open_vbox fmt 0;
+        (* Open the box for the definitions themselves *)
+        F.pp_open_vbox fmt ctx.indent_incr;
+        (* Print the delimiters *)
+        if is_rec then
+          F.pp_print_string fmt
+            ("val [" ^ String.concat ", " names ^ "] = DefineDiv ‘")
+        else (
+          assert (List.length names = 1);
+          let name = List.hd names in
+          F.pp_print_string fmt ("val " ^ name ^ " = Define ‘"));
+        F.pp_print_cut fmt ()
+
+(** See {!start_fun_decl_group}. *)
+let end_fun_decl_group (fmt : F.formatter) (is_rec : bool)
+    (dg : Pure.fun_decl list) =
+  match !backend with
+  | FStar -> ()
+  | Coq ->
+      (* For aesthetic reasons, we print the Coq end group delimiter directly
+         in {!extract_fun_decl}. *)
+      ()
+  | Lean ->
+      (* We must add the "end" keyword to groups of mutually recursive functions *)
+      if is_rec && List.length dg > 1 then (
+        F.pp_print_cut fmt ();
+        F.pp_print_string fmt "end";
+        (* Add breaks to insert new lines between definitions *)
+        F.pp_print_break fmt 0 0)
+      else ()
+  | HOL4 ->
+      (* In HOL4, opaque functions have a special treatment *)
+      if is_single_opaque_fun_decl_group dg then ()
+      else (
+        (* Close the box for the definitions *)
+        F.pp_close_box fmt ();
+        (* Print the end delimiter *)
+        F.pp_print_cut fmt ();
+        F.pp_print_string fmt "’";
+        (* Close the box for the delimiters *)
+        F.pp_close_box fmt ();
+        (* Add breaks to insert new lines between definitions *)
+        F.pp_print_break fmt 0 0)
+
+(** See {!start_fun_decl_group}: similar usage, but for the type declarations. *)
+let start_type_decl_group (ctx : extraction_ctx) (fmt : F.formatter)
+    (is_rec : bool) (dg : Pure.type_decl list) =
+  match !backend with
+  | FStar | Coq -> ()
+  | Lean ->
+      if is_rec && List.length dg > 1 then (
+        F.pp_print_space fmt ();
+        F.pp_print_string fmt "mutual";
+        F.pp_print_space fmt ())
+  | HOL4 ->
+      (* In HOL4, opaque types and empty records have a special treatment *)
+      if
+        is_single_opaque_type_decl_group dg
+        || is_empty_record_type_decl_group dg
+      then ()
+      else (
+        (* Add a break before *)
+        F.pp_print_break fmt 0 0;
+        (* Open the box for the delimiters *)
+        F.pp_open_vbox fmt 0;
+        (* Open the box for the definitions themselves *)
+        F.pp_open_vbox fmt ctx.indent_incr;
+        (* Print the delimiters *)
+        F.pp_print_string fmt "Datatype:";
+        F.pp_print_cut fmt ())
+
+(** See {!start_fun_decl_group}. *)
+let end_type_decl_group (fmt : F.formatter) (is_rec : bool)
+    (dg : Pure.type_decl list) =
+  match !backend with
+  | FStar -> ()
+  | Coq ->
+      (* For aesthetic reasons, we print the Coq end group delimiter directly
+         in {!extract_fun_decl}. *)
+      ()
+  | Lean ->
+      (* We must add the "end" keyword to groups of mutually recursive functions *)
+      if is_rec && List.length dg > 1 then (
+        F.pp_print_cut fmt ();
+        F.pp_print_string fmt "end";
+        (* Add breaks to insert new lines between definitions *)
+        F.pp_print_break fmt 0 0)
+      else ()
+  | HOL4 ->
+      (* In HOL4, opaque types and empty records have a special treatment *)
+      if
+        is_single_opaque_type_decl_group dg
+        || is_empty_record_type_decl_group dg
+      then ()
+      else (
+        (* Close the box for the definitions *)
+        F.pp_close_box fmt ();
+        (* Print the end delimiter *)
+        F.pp_print_cut fmt ();
+        F.pp_print_string fmt "End";
+        (* Close the box for the delimiters *)
+        F.pp_close_box fmt ();
+        (* Add breaks to insert new lines between definitions *)
+        F.pp_print_break fmt 0 0)
+
+let unit_name () =
+  match !backend with Lean -> "Unit" | Coq | FStar | HOL4 -> "unit"
+
+(** Small helper *)
+let extract_arrow (fmt : F.formatter) () : unit =
+  if !Config.backend = Lean then F.pp_print_string fmt "→"
+  else F.pp_print_string fmt "->"
+
+let extract_const_generic (ctx : extraction_ctx) (fmt : F.formatter)
+    (inside : bool) (cg : const_generic) : unit =
+  match cg with
+  | ConstGenericGlobal id ->
+      let s = ctx_get_global id ctx in
+      F.pp_print_string fmt s
+  | ConstGenericValue v -> ctx.fmt.extract_literal fmt inside v
+  | ConstGenericVar id ->
+      let s = ctx_get_const_generic_var id ctx in
+      F.pp_print_string fmt s
+
+let extract_literal_type (ctx : extraction_ctx) (fmt : F.formatter)
+    (ty : literal_type) : unit =
+  match ty with
+  | Bool -> F.pp_print_string fmt ctx.fmt.bool_name
+  | Char -> F.pp_print_string fmt ctx.fmt.char_name
+  | Integer int_ty -> F.pp_print_string fmt (ctx.fmt.int_name int_ty)
+
+(** [inside] constrols whether we should add parentheses or not around type
+    applications (if [true] we add parentheses).
+
+    [no_params_tys]: for all the types inside this set, do not print the type parameters.
+    This is used for HOL4. As polymorphism is uniform in HOL4, printing the
+    type parameters in the recursive definitions is useless (and actually
+    forbidden).
+
+    For instance, where in F* we would write:
+    {[
+      type list a = | Nil : list a | Cons : a -> list a -> list a
+    ]}
+
+    In HOL4 we would simply write:
+    {[
+      Datatype:
+        list = Nil 'a | Cons 'a list
+      End
+    ]}
+ *)
+let rec extract_ty (ctx : extraction_ctx) (fmt : F.formatter)
+    (no_params_tys : TypeDeclId.Set.t) (inside : bool) (ty : ty) : unit =
+  let extract_rec = extract_ty ctx fmt no_params_tys in
+  match ty with
+  | Adt (type_id, generics) -> (
+      let has_params = generics <> empty_generic_args in
+      match type_id with
+      | Tuple ->
+          (* This is a bit annoying, but in F*/Coq/HOL4 [()] is not the unit type:
+           * we have to write [unit]... *)
+          if generics.types = [] then F.pp_print_string fmt (unit_name ())
+          else (
+            F.pp_print_string fmt "(";
+            Collections.List.iter_link
+              (fun () ->
+                F.pp_print_space fmt ();
+                let product =
+                  match !backend with
+                  | FStar -> "&"
+                  | Coq -> "*"
+                  | Lean -> "×"
+                  | HOL4 -> "#"
+                in
+                F.pp_print_string fmt product;
+                F.pp_print_space fmt ())
+              (extract_rec true) generics.types;
+            F.pp_print_string fmt ")")
+      | AdtId _ | Assumed _ -> (
+          (* HOL4 behaves differently. Where in Coq/FStar/Lean we would write:
+             `tree a b`
+
+             In HOL4 we would write:
+             `('a, 'b) tree`
+          *)
+          match !backend with
+          | FStar | Coq | Lean ->
+              let print_paren = inside && has_params in
+              if print_paren then F.pp_print_string fmt "(";
+              (* TODO: for now, only the opaque *functions* are extracted in the
+                 opaque module. The opaque *types* are assumed. *)
+              F.pp_print_string fmt (ctx_get_type type_id ctx);
+              (* We might need to filter the type arguments, if the type
+                 is builtin (for instance, we filter the global allocator type
+                 argument for `Vec`). *)
+              let generics =
+                match type_id with
+                | AdtId id -> (
+                    match
+                      TypeDeclId.Map.find_opt id ctx.types_filter_type_args_map
+                    with
+                    | None -> generics
+                    | Some filter ->
+                        let types = List.combine filter generics.types in
+                        let types =
+                          List.filter_map
+                            (fun (b, ty) -> if b then Some ty else None)
+                            types
+                        in
+                        { generics with types })
+                | _ -> generics
+              in
+              extract_generic_args ctx fmt no_params_tys generics;
+              if print_paren then F.pp_print_string fmt ")"
+          | HOL4 ->
+              let { types; const_generics; trait_refs } = generics in
+              (* Const generics are not supported in HOL4 *)
+              assert (const_generics = []);
+              let print_tys =
+                match type_id with
+                | AdtId id -> not (TypeDeclId.Set.mem id no_params_tys)
+                | Assumed _ -> true
+                | _ -> raise (Failure "Unreachable")
+              in
+              if types <> [] && print_tys then (
+                let print_paren = List.length types > 1 in
+                if print_paren then F.pp_print_string fmt "(";
+                Collections.List.iter_link
+                  (fun () ->
+                    F.pp_print_string fmt ",";
+                    F.pp_print_space fmt ())
+                  (extract_rec true) types;
+                if print_paren then F.pp_print_string fmt ")";
+                F.pp_print_space fmt ());
+              F.pp_print_string fmt (ctx_get_type type_id ctx);
+              if trait_refs <> [] then (
+                F.pp_print_space fmt ();
+                Collections.List.iter_link (F.pp_print_space fmt)
+                  (extract_trait_ref ctx fmt no_params_tys true)
+                  trait_refs)))
+  | TypeVar vid -> F.pp_print_string fmt (ctx_get_type_var vid ctx)
+  | Literal lty -> extract_literal_type ctx fmt lty
+  | Arrow (arg_ty, ret_ty) ->
+      if inside then F.pp_print_string fmt "(";
+      extract_rec false arg_ty;
+      F.pp_print_space fmt ();
+      extract_arrow fmt ();
+      F.pp_print_space fmt ();
+      extract_rec false ret_ty;
+      if inside then F.pp_print_string fmt ")"
+  | TraitType (trait_ref, generics, type_name) ->
+      if !parameterize_trait_types then raise (Failure "Unimplemented")
+      else if trait_ref.trait_id <> Self then (
+        (* HOL4 doesn't have 1st class types *)
+        assert (!backend <> HOL4);
+        let use_brackets = generics <> empty_generic_args in
+        if use_brackets then F.pp_print_string fmt "(";
+        extract_trait_ref ctx fmt no_params_tys false trait_ref;
+        extract_generic_args ctx fmt no_params_tys generics;
+        let name =
+          ctx_get_trait_type trait_ref.trait_decl_ref.trait_decl_id type_name
+            ctx
+        in
+        if use_brackets then F.pp_print_string fmt ")";
+        F.pp_print_string fmt ("." ^ name))
+      else
+        (* There are two situations:
+           - we are extracting a declared item (typically a function signature)
+             for a trait declaration. We directly refer to the item (we extract
+             trait declarations as structures, so we can refer to their fields)
+           - we are extracting a provided method for a trait declaration. We
+             refer to the item in the self trait clause (see {!SelfTraitClauseId}).
+
+           Remark: we can't get there for trait *implementations* because then the
+           types should have been normalized.
+        *)
+        let trait_decl_id = Option.get ctx.trait_decl_id in
+        let item_name = ctx_get_trait_type trait_decl_id type_name ctx in
+        assert (generics = empty_generic_args);
+        if ctx.is_provided_method then
+          (* Provided method: use the trait self clause *)
+          let self_clause = ctx_get_trait_self_clause ctx in
+          F.pp_print_string fmt (self_clause ^ "." ^ item_name)
+        else
+          (* Declaration: directly refer to the item *)
+          F.pp_print_string fmt item_name
+
+and extract_trait_ref (ctx : extraction_ctx) (fmt : F.formatter)
+    (no_params_tys : TypeDeclId.Set.t) (inside : bool) (tr : trait_ref) : unit =
+  let use_brackets = tr.generics <> empty_generic_args && inside in
+  if use_brackets then F.pp_print_string fmt "(";
+  (* We may need to filter the parameters if the trait is builtin *)
+  let generics =
+    match tr.trait_id with
+    | TraitImpl id -> (
+        match
+          TraitImplId.Map.find_opt id ctx.trait_impls_filter_type_args_map
+        with
+        | None -> tr.generics
+        | Some filter ->
+            let types =
+              List.filter_map
+                (fun (b, x) -> if b then Some x else None)
+                (List.combine filter tr.generics.types)
+            in
+            { tr.generics with types })
+    | _ -> tr.generics
+  in
+  extract_trait_instance_id ctx fmt no_params_tys inside tr.trait_id;
+  extract_generic_args ctx fmt no_params_tys generics;
+  if use_brackets then F.pp_print_string fmt ")"
+
+and extract_trait_decl_ref (ctx : extraction_ctx) (fmt : F.formatter)
+    (no_params_tys : TypeDeclId.Set.t) (inside : bool) (tr : trait_decl_ref) :
+    unit =
+  let use_brackets = tr.decl_generics <> empty_generic_args && inside in
+  let name = ctx_get_trait_decl tr.trait_decl_id ctx in
+  if use_brackets then F.pp_print_string fmt "(";
+  F.pp_print_string fmt name;
+  (* There is something subtle here: the trait obligations for the implemented
+     trait are put inside the parent clauses, so we must ignore them here *)
+  let generics = { tr.decl_generics with trait_refs = [] } in
+  extract_generic_args ctx fmt no_params_tys generics;
+  if use_brackets then F.pp_print_string fmt ")"
+
+and extract_generic_args (ctx : extraction_ctx) (fmt : F.formatter)
+    (no_params_tys : TypeDeclId.Set.t) (generics : generic_args) : unit =
+  let { types; const_generics; trait_refs } = generics in
+  if !backend <> HOL4 then (
+    if types <> [] then (
+      F.pp_print_space fmt ();
+      Collections.List.iter_link (F.pp_print_space fmt)
+        (extract_ty ctx fmt no_params_tys true)
+        types);
+    if const_generics <> [] then (
+      assert (!backend <> HOL4);
+      F.pp_print_space fmt ();
+      Collections.List.iter_link (F.pp_print_space fmt)
+        (extract_const_generic ctx fmt true)
+        const_generics));
+  if trait_refs <> [] then (
+    F.pp_print_space fmt ();
+    Collections.List.iter_link (F.pp_print_space fmt)
+      (extract_trait_ref ctx fmt no_params_tys true)
+      trait_refs)
+
+and extract_trait_instance_id (ctx : extraction_ctx) (fmt : F.formatter)
+    (no_params_tys : TypeDeclId.Set.t) (inside : bool) (id : trait_instance_id)
+    : unit =
+  match id with
+  | Self ->
+      (* This has specific treatment depending on the item we're extracting
+         (associated type, etc.). We should have caught this elsewhere. *)
+      raise (Failure "Unexpected")
+  | TraitImpl id ->
+      let name = ctx_get_trait_impl id ctx in
+      F.pp_print_string fmt name
+  | Clause id ->
+      let name = ctx_get_local_trait_clause id ctx in
+      F.pp_print_string fmt name
+  | ParentClause (inst_id, decl_id, clause_id) ->
+      (* Use the trait decl id to lookup the name *)
+      let name = ctx_get_trait_parent_clause decl_id clause_id ctx in
+      extract_trait_instance_id ctx fmt no_params_tys true inst_id;
+      F.pp_print_string fmt ("." ^ name)
+  | ItemClause (inst_id, decl_id, item_name, clause_id) ->
+      (* Use the trait decl id to lookup the name *)
+      let name = ctx_get_trait_item_clause decl_id item_name clause_id ctx in
+      extract_trait_instance_id ctx fmt no_params_tys true inst_id;
+      F.pp_print_string fmt ("." ^ name)
+  | TraitRef trait_ref ->
+      extract_trait_ref ctx fmt no_params_tys inside trait_ref
+  | UnknownTrait _ ->
+      (* This is an error case *)
+      raise (Failure "Unexpected")
+
+(** Compute the names for all the top-level identifiers used in a type
+    definition (type name, variant names, field names, etc. but not type
+    parameters).
+
+    We need to do this preemptively, beforce extracting any definition,
+    because of recursive definitions.
+ *)
+let extract_type_decl_register_names (ctx : extraction_ctx) (def : type_decl) :
+    extraction_ctx =
+  (* Lookup the builtin information, if there is *)
+  let open ExtractBuiltin in
+  let sname = name_to_simple_name def.name in
+  let info = SimpleNameMap.find_opt sname (builtin_types_map ()) in
+  (* Register the filtering information, if there is *)
+  let ctx =
+    match info with
+    | Some { keep_params = Some keep; _ } ->
+        {
+          ctx with
+          types_filter_type_args_map =
+            TypeDeclId.Map.add def.def_id keep ctx.types_filter_type_args_map;
+        }
+    | _ -> ctx
+  in
+  (* Compute and register the type def name *)
+  let def_name =
+    match info with
+    | None -> ctx.fmt.type_name def.name
+    | Some info -> info.extract_name
+  in
+  let ctx = ctx_add (TypeId (AdtId def.def_id)) def_name ctx in
+  (* Compute and register:
+   * - the variant names, if this is an enumeration
+   * - the field names, if this is a structure
+   *)
+  let ctx =
+    match def.kind with
+    | Struct fields ->
+        (* Compute the names *)
+        let field_names, cons_name =
+          match info with
+          | None | Some { body_info = None; _ } ->
+              let field_names =
+                FieldId.mapi
+                  (fun fid (field : field) ->
+                    (fid, ctx.fmt.field_name def.name fid field.field_name))
+                  fields
+              in
+              let cons_name = ctx.fmt.struct_constructor def.name in
+              (field_names, cons_name)
+          | Some { body_info = Some (Struct (cons_name, field_names)); _ } ->
+              let field_names =
+                FieldId.mapi
+                  (fun fid (_, name) -> (fid, name))
+                  (List.combine fields field_names)
+              in
+              (field_names, cons_name)
+          | Some info ->
+              raise
+                (Failure
+                   ("Invalid builtin information: "
+                   ^ show_builtin_type_info info))
+        in
+        (* Add the fields *)
+        let ctx =
+          List.fold_left
+            (fun ctx (fid, name) ->
+              ctx_add (FieldId (AdtId def.def_id, fid)) name ctx)
+            ctx field_names
+        in
+        (* Add the constructor name *)
+        ctx_add (StructId (AdtId def.def_id)) cons_name ctx
+    | Enum variants ->
+        let variant_names =
+          match info with
+          | None ->
+              VariantId.mapi
+                (fun variant_id (variant : variant) ->
+                  let name =
+                    ctx.fmt.variant_name def.name variant.variant_name
+                  in
+                  (* Add the type name prefix for Lean *)
+                  let name =
+                    if !Config.backend = Lean then
+                      let type_name = ctx.fmt.type_name def.name in
+                      type_name ^ "." ^ name
+                    else name
+                  in
+                  (variant_id, name))
+                variants
+          | Some { body_info = Some (Enum variant_infos); _ } ->
+              (* We need to compute the map from variant to variant *)
+              let variant_map =
+                StringMap.of_list
+                  (List.map
+                     (fun (info : builtin_enum_variant_info) ->
+                       (info.rust_variant_name, info.extract_variant_name))
+                     variant_infos)
+              in
+              VariantId.mapi
+                (fun variant_id (variant : variant) ->
+                  (variant_id, StringMap.find variant.variant_name variant_map))
+                variants
+          | _ -> raise (Failure "Invalid builtin information")
+        in
+        List.fold_left
+          (fun ctx (vid, vname) ->
+            ctx_add (VariantId (AdtId def.def_id, vid)) vname ctx)
+          ctx variant_names
+    | Opaque ->
+        (* Nothing to do *)
+        ctx
+  in
+  (* Return *)
+  ctx
+
+(** Print the variants *)
+let extract_type_decl_variant (ctx : extraction_ctx) (fmt : F.formatter)
+    (type_decl_group : TypeDeclId.Set.t) (type_name : string)
+    (type_params : string list) (cg_params : string list) (cons_name : string)
+    (fields : field list) : unit =
+  F.pp_print_space fmt ();
+  (* variant box *)
+  F.pp_open_hvbox fmt ctx.indent_incr;
+  (* [| Cons :]
+   * Note that we really don't want any break above so we print everything
+   * at once. *)
+  let opt_colon = if !backend <> HOL4 then " :" else "" in
+  F.pp_print_string fmt ("| " ^ cons_name ^ opt_colon);
+  let print_field (fid : FieldId.id) (f : field) (ctx : extraction_ctx) :
+      extraction_ctx =
+    F.pp_print_space fmt ();
+    (* Open the field box *)
+    F.pp_open_box fmt ctx.indent_incr;
+    (* Print the field names, if the backend accepts it.
+     * [  x :]
+     * Note that when printing fields, we register the field names as
+     * *variables*: they don't need to be unique at the top level. *)
+    let ctx =
+      match !backend with
+      | FStar -> (
+          match f.field_name with
+          | None -> ctx
+          | Some field_name ->
+              let var_id = VarId.of_int (FieldId.to_int fid) in
+              let field_name =
+                ctx.fmt.var_basename ctx.names_map.names_set (Some field_name)
+                  f.field_ty
+              in
+              let ctx, field_name = ctx_add_var field_name var_id ctx in
+              F.pp_print_string fmt (field_name ^ " :");
+              F.pp_print_space fmt ();
+              ctx)
+      | Coq | Lean | HOL4 -> ctx
+    in
+    (* Print the field type *)
+    let inside = !backend = HOL4 in
+    extract_ty ctx fmt type_decl_group inside f.field_ty;
+    (* Print the arrow [->] *)
+    if !backend <> HOL4 then (
+      F.pp_print_space fmt ();
+      extract_arrow fmt ());
+    (* Close the field box *)
+    F.pp_close_box fmt ();
+    (* Return *)
+    ctx
+  in
+  (* Print the fields *)
+  let fields = FieldId.mapi (fun fid f -> (fid, f)) fields in
+  let _ =
+    List.fold_left (fun ctx (fid, f) -> print_field fid f ctx) ctx fields
+  in
+  (* Sanity check: HOL4 doesn't support const generics *)
+  assert (cg_params = [] || !backend <> HOL4);
+  (* Print the final type *)
+  if !backend <> HOL4 then (
+    F.pp_print_space fmt ();
+    F.pp_open_hovbox fmt 0;
+    F.pp_print_string fmt type_name;
+    List.iter
+      (fun p ->
+        F.pp_print_space fmt ();
+        F.pp_print_string fmt p)
+      (List.append type_params cg_params);
+    F.pp_close_box fmt ());
+  (* Close the variant box *)
+  F.pp_close_box fmt ()
+
+(* TODO: we don' need the [def_name] paramter: it can be retrieved from the context *)
+let extract_type_decl_enum_body (ctx : extraction_ctx) (fmt : F.formatter)
+    (type_decl_group : TypeDeclId.Set.t) (def : type_decl) (def_name : string)
+    (type_params : string list) (cg_params : string list)
+    (variants : variant list) : unit =
+  (* We want to generate a definition which looks like this (taking F* as example):
+     {[
+       type list a = | Cons : a -> list a -> list a | Nil : list a
+     ]}
+
+     If there isn't enough space on one line:
+     {[
+       type s =
+       | Cons : a -> list a -> list a
+       | Nil : list a
+     ]}
+
+     And if we need to write the type of a variant on several lines:
+     {[
+       type s =
+       | Cons :
+         a ->
+         list a ->
+         list a
+       | Nil : list a
+     ]}
+
+     Finally, it is possible to give names to the variant fields in Rust.
+     In this situation, we generate a definition like this:
+     {[
+       type s =
+       | Cons : hd:a -> tl:list a -> list a
+       | Nil : list a
+     ]}
+
+     Note that we already printed: [type s =]
+  *)
+  let print_variant _variant_id (v : variant) =
+    (* We don't lookup the name, because it may have a prefix for the type
+       id (in the case of Lean) *)
+    let cons_name = ctx.fmt.variant_name def.name v.variant_name in
+    let fields = v.fields in
+    extract_type_decl_variant ctx fmt type_decl_group def_name type_params
+      cg_params cons_name fields
+  in
+  (* Print the variants *)
+  let variants = VariantId.mapi (fun vid v -> (vid, v)) variants in
+  List.iter (fun (vid, v) -> print_variant vid v) variants
+
+let extract_type_decl_struct_body (ctx : extraction_ctx) (fmt : F.formatter)
+    (type_decl_group : TypeDeclId.Set.t) (kind : decl_kind) (def : type_decl)
+    (type_params : string list) (cg_params : string list) (fields : field list)
+    : unit =
+  (* We want to generate a definition which looks like this (taking F* as example):
+     {[
+       type t = { x : int; y : bool; }
+     ]}
+
+     If there isn't enough space on one line:
+     {[
+       type t =
+       {
+         x : int; y : bool;
+       }
+     ]}
+
+     And if there is even less space:
+     {[
+       type t =
+       {
+         x : int;
+         y : bool;
+       }
+     ]}
+
+     Also, in case there are no fields, we need to define the type as [unit]
+     ([type t = {}] doesn't work in F* ).
+
+     Coq:
+     ====
+     We need to define the constructor name upon defining the struct (record, in Coq).
+     The syntex is:
+     {[
+       Record Foo = mkFoo { x : int; y : bool; }.
+     }]
+
+     Also, Coq doesn't support groups of mutually recursive inductives and records.
+     This is fine, because we can then define records as inductives, and leverage
+     the fact that when record fields are accessed, the records are symbolically
+     expanded which introduces let bindings of the form: [let RecordCons ... = x in ...].
+     As a consequence, we never use the record projectors (unless we reconstruct
+     them in the micro passes of course).
+
+     HOL4:
+     =====
+     Type definitions are written as follows:
+     {[
+       Datatype:
+         tree =
+           TLeaf 'a
+         | TNode node ;
+
+         node =
+           Node (tree list)
+       End
+     ]}
+  *)
+  (* Note that we already printed: [type t =] *)
+  let is_rec = decl_is_from_rec_group kind in
+  let _ =
+    if !backend = FStar && fields = [] then (
+      F.pp_print_space fmt ();
+      F.pp_print_string fmt (unit_name ()))
+    else if !backend = Lean && fields = [] then ()
+      (* If the definition is recursive, we may need to extract it as an inductive
+         (instead of a record). We start with the "normal" case: we extract it
+         as a record. *)
+    else if (not is_rec) || (!backend <> Coq && !backend <> Lean) then (
+      if !backend <> Lean then F.pp_print_space fmt ();
+      (* If Coq: print the constructor name *)
+      (* TODO: remove superfluous test not is_rec below *)
+      if !backend = Coq && not is_rec then (
+        F.pp_print_string fmt (ctx_get_struct (AdtId def.def_id) ctx);
+        F.pp_print_string fmt " ");
+      (match !backend with
+      | Lean -> ()
+      | FStar | Coq -> F.pp_print_string fmt "{"
+      | HOL4 -> F.pp_print_string fmt "<|");
+      F.pp_print_break fmt 1 ctx.indent_incr;
+      (* The body itself *)
+      (* Open a box for the body *)
+      (match !backend with
+      | Coq | FStar | HOL4 -> F.pp_open_hvbox fmt 0
+      | Lean -> F.pp_open_vbox fmt 0);
+      (* Print the fields *)
+      let print_field (field_id : FieldId.id) (f : field) : unit =
+        let field_name = ctx_get_field (AdtId def.def_id) field_id ctx in
+        (* Open a box for the field *)
+        F.pp_open_box fmt ctx.indent_incr;
+        F.pp_print_string fmt field_name;
+        F.pp_print_space fmt ();
+        F.pp_print_string fmt ":";
+        F.pp_print_space fmt ();
+        extract_ty ctx fmt type_decl_group false f.field_ty;
+        if !backend <> Lean then F.pp_print_string fmt ";";
+        (* Close the box for the field *)
+        F.pp_close_box fmt ()
+      in
+      let fields = FieldId.mapi (fun fid f -> (fid, f)) fields in
+      Collections.List.iter_link (F.pp_print_space fmt)
+        (fun (fid, f) -> print_field fid f)
+        fields;
+      (* Close the box for the body *)
+      F.pp_close_box fmt ();
+      match !backend with
+      | Lean -> ()
+      | FStar | Coq ->
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt "}"
+      | HOL4 ->
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt "|>")
+    else (
+      (* We extract for Coq or Lean, and we have a recursive record, or a record in
+         a group of mutually recursive types: we extract it as an inductive type *)
+      assert (is_rec && (!backend = Coq || !backend = Lean));
+      (* Small trick: in Lean we use namespaces, meaning we don't need to prefix
+         the constructor name with the name of the type at definition site,
+         i.e., instead of generating `inductive Foo := | MkFoo ...` like in Coq
+         we generate `inductive Foo := | mk ... *)
+      let cons_name =
+        if !backend = Lean then "mk" else ctx_get_struct (AdtId def.def_id) ctx
+      in
+      let def_name = ctx_get_local_type def.def_id ctx in
+      extract_type_decl_variant ctx fmt type_decl_group def_name type_params
+        cg_params cons_name fields)
+  in
+  ()
+
+(** Extract a nestable, muti-line comment *)
+let extract_comment (fmt : F.formatter) (sl : string list) : unit =
+  (* Delimiters, space after we break a line *)
+  let ld, space, rd =
+    match !backend with
+    | Coq | FStar | HOL4 -> ("(** ", 4, " *)")
+    | Lean -> ("/- ", 3, " -/")
+  in
+  F.pp_open_vbox fmt space;
+  F.pp_print_string fmt ld;
+  (match sl with
+  | [] -> ()
+  | s :: sl ->
+      F.pp_print_string fmt s;
+      List.iter
+        (fun s ->
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt s)
+        sl);
+  F.pp_print_string fmt rd;
+  F.pp_close_box fmt ()
+
+let extract_trait_clause_type (ctx : extraction_ctx) (fmt : F.formatter)
+    (no_params_tys : TypeDeclId.Set.t) (clause : trait_clause) : unit =
+  let trait_name = ctx_get_trait_decl clause.trait_id ctx in
+  F.pp_print_string fmt trait_name;
+  extract_generic_args ctx fmt no_params_tys clause.generics
+
+(** Insert a space, if necessary *)
+let insert_req_space (fmt : F.formatter) (space : bool ref) : unit =
+  if !space then space := false else F.pp_print_space fmt ()
+
+(** Extract the trait self clause.
+
+    We add the trait self clause for provided methods (see {!TraitSelfClauseId}).
+ *)
+let extract_trait_self_clause (insert_req_space : unit -> unit)
+    (ctx : extraction_ctx) (fmt : F.formatter) (trait_decl : trait_decl)
+    (params : string list) : unit =
+  insert_req_space ();
+  F.pp_print_string fmt "(";
+  let self_clause = ctx_get_trait_self_clause ctx in
+  F.pp_print_string fmt self_clause;
+  F.pp_print_space fmt ();
+  F.pp_print_string fmt ":";
+  F.pp_print_space fmt ();
+  let trait_id = ctx_get_trait_decl trait_decl.def_id ctx in
+  F.pp_print_string fmt trait_id;
+  List.iter
+    (fun p ->
+      F.pp_print_space fmt ();
+      F.pp_print_string fmt p)
+    params;
+  F.pp_print_string fmt ")"
+
+(**
+ - [trait_decl]: if [Some], it means we are extracting the generics for a provided
+   method and need to insert a trait self clause (see {!TraitSelfClauseId}).
+ *)
+let extract_generic_params (ctx : extraction_ctx) (fmt : F.formatter)
+    (no_params_tys : TypeDeclId.Set.t) ?(use_forall = false)
+    ?(use_forall_use_sep = true) ?(as_implicits : bool = false)
+    ?(space : bool ref option = None) ?(trait_decl : trait_decl option = None)
+    (generics : generic_params) (type_params : string list)
+    (cg_params : string list) (trait_clauses : string list) : unit =
+  let all_params = List.concat [ type_params; cg_params; trait_clauses ] in
+  (* HOL4 doesn't support const generics *)
+  assert (cg_params = [] || !backend <> HOL4);
+  let left_bracket (implicit : bool) =
+    if implicit then F.pp_print_string fmt "{" else F.pp_print_string fmt "("
+  in
+  let right_bracket (implicit : bool) =
+    if implicit then F.pp_print_string fmt "}" else F.pp_print_string fmt ")"
+  in
+  let insert_req_space () =
+    match space with
+    | None -> F.pp_print_space fmt ()
+    | Some space -> insert_req_space fmt space
+  in
+  (* Print the type/const generic parameters *)
+  if all_params <> [] then (
+    if use_forall then (
+      if use_forall_use_sep then (
+        insert_req_space ();
+        F.pp_print_string fmt ":");
+      insert_req_space ();
+      F.pp_print_string fmt "forall");
+    (* Small helper - we may need to split the parameters *)
+    let print_generics (as_implicits : bool) (type_params : string list)
+        (const_generics : const_generic_var list)
+        (trait_clauses : trait_clause list) : unit =
+      (* Note that in HOL4 we don't print the type parameters. *)
+      if !backend <> HOL4 then (
+        (* Print the type parameters *)
+        if type_params <> [] then (
+          insert_req_space ();
+          (* ( *)
+          left_bracket as_implicits;
+          List.iter
+            (fun s ->
+              F.pp_print_string fmt s;
+              F.pp_print_space fmt ())
+            type_params;
+          F.pp_print_string fmt ":";
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt (type_keyword ());
+          (* ) *)
+          right_bracket as_implicits);
+        (* Print the const generic parameters *)
+        List.iter
+          (fun (var : const_generic_var) ->
+            insert_req_space ();
+            (* ( *)
+            left_bracket as_implicits;
+            let n = ctx_get_const_generic_var var.index ctx in
+            F.pp_print_string fmt n;
+            F.pp_print_space fmt ();
+            F.pp_print_string fmt ":";
+            F.pp_print_space fmt ();
+            extract_literal_type ctx fmt var.ty;
+            (* ) *)
+            right_bracket as_implicits)
+          const_generics);
+      (* Print the trait clauses *)
+      List.iter
+        (fun (clause : trait_clause) ->
+          insert_req_space ();
+          (* ( *)
+          left_bracket as_implicits;
+          let n = ctx_get_local_trait_clause clause.clause_id ctx in
+          F.pp_print_string fmt n;
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt ":";
+          F.pp_print_space fmt ();
+          extract_trait_clause_type ctx fmt no_params_tys clause;
+          (* ) *)
+          right_bracket as_implicits)
+        trait_clauses
+    in
+    (* If we extract the generics for a provided method for a trait declaration
+       (indicated by the trait decl given as input), we need to split the generics:
+       - we print the generics for the trait decl
+       - we print the trait self clause
+       - we print the generics for the trait method
+    *)
+    match trait_decl with
+    | None ->
+        print_generics as_implicits type_params generics.const_generics
+          generics.trait_clauses
+    | Some trait_decl ->
+        (* Split the generics between the generics specific to the trait decl
+           and those specific to the trait method *)
+        let open Collections.List in
+        let dtype_params, mtype_params =
+          split_at type_params (length trait_decl.generics.types)
+        in
+        let dcgs, mcgs =
+          split_at generics.const_generics
+            (length trait_decl.generics.const_generics)
+        in
+        let dtrait_clauses, mtrait_clauses =
+          split_at generics.trait_clauses
+            (length trait_decl.generics.trait_clauses)
+        in
+        (* Extract the trait decl generics - note that we can always deduce
+           those parameters from the trait self clause: for this reason
+           they are always implicit *)
+        print_generics true dtype_params dcgs dtrait_clauses;
+        (* Extract the trait self clause *)
+        let params =
+          concat
+            [
+              dtype_params;
+              map
+                (fun (cg : const_generic_var) ->
+                  ctx_get_const_generic_var cg.index ctx)
+                dcgs;
+              map
+                (fun c -> ctx_get_local_trait_clause c.clause_id ctx)
+                dtrait_clauses;
+            ]
+        in
+        extract_trait_self_clause insert_req_space ctx fmt trait_decl params;
+        (* Extract the method generics *)
+        print_generics as_implicits mtype_params mcgs mtrait_clauses)
+
+(** Extract a type declaration.
+
+    This function is for all type declarations and all backends **at the exception**
+    of opaque (assumed/declared) types format4 HOL4.
+
+    See {!extract_type_decl}.
+ *)
+let extract_type_decl_gen (ctx : extraction_ctx) (fmt : F.formatter)
+    (type_decl_group : TypeDeclId.Set.t) (kind : decl_kind) (def : type_decl)
+    (extract_body : bool) : unit =
+  (* Sanity check *)
+  assert (extract_body || !backend <> HOL4);
+  let type_kind =
+    if extract_body then
+      match def.kind with
+      | Struct _ -> Some Struct
+      | Enum _ -> Some Enum
+      | Opaque -> None
+    else None
+  in
+  (* If in Coq and the declaration is opaque, it must have the shape:
+     [Axiom Ident : forall (T0 ... Tn : Type) (N0 : ...) ... (Nn : ...), ... -> ... -> ...].
+
+     The boolean [is_opaque_coq] is used to detect this case.
+  *)
+  let is_opaque = type_kind = None in
+  let is_opaque_coq = !backend = Coq && is_opaque in
+  let use_forall = is_opaque_coq && def.generics <> empty_generic_params in
+  (* Retrieve the definition name *)
+  let def_name = ctx_get_local_type def.def_id ctx in
+  (* Add the type and const generic params - note that we need those bindings only for the
+   * body translation (they are not top-level) *)
+  let ctx_body, type_params, cg_params, trait_clauses =
+    ctx_add_generic_params def.generics ctx
+  in
+  (* Add a break before *)
+  if !backend <> HOL4 || not (decl_is_first_from_group kind) then
+    F.pp_print_break fmt 0 0;
+  (* Print a comment to link the extracted type to its original rust definition *)
+  extract_comment fmt [ "[" ^ Print.name_to_string def.name ^ "]" ];
+  F.pp_print_break fmt 0 0;
+  (* Open a box for the definition, so that whenever possible it gets printed on
+   * one line. Note however that in the case of Lean line breaks are important
+   * for parsing: we thus use a hovbox. *)
+  (match !backend with
+  | Coq | FStar | HOL4 -> F.pp_open_hvbox fmt 0
+  | Lean -> F.pp_open_vbox fmt 0);
+  (* Open a box for "type TYPE_NAME (TYPE_PARAMS CONST_GEN_PARAMS) =" *)
+  F.pp_open_hovbox fmt ctx.indent_incr;
+  (* > "type TYPE_NAME" *)
+  let qualif = ctx.fmt.type_decl_kind_to_qualif kind type_kind in
+  (match qualif with
+  | Some qualif -> F.pp_print_string fmt (qualif ^ " " ^ def_name)
+  | None -> F.pp_print_string fmt def_name);
+  (* HOL4 doesn't support const generics, and type definitions in HOL4 don't
+     support trait clauses *)
+  assert ((cg_params = [] && trait_clauses = []) || !backend <> HOL4);
+  (* Print the generic parameters *)
+  extract_generic_params ctx_body fmt type_decl_group ~use_forall def.generics
+    type_params cg_params trait_clauses;
+  (* Print the "=" if we extract the body*)
+  if extract_body then (
+    F.pp_print_space fmt ();
+    let eq =
+      match !backend with
+      | FStar -> "="
+      | Coq -> ":="
+      | Lean ->
+          if type_kind = Some Struct && kind = SingleNonRec then "where"
+          else ":="
+      | HOL4 -> "="
+    in
+    F.pp_print_string fmt eq)
+  else (
+    (* Otherwise print ": Type", unless it is the HOL4 backend (in
+       which case we declare the type with `new_type`) *)
+    if use_forall then F.pp_print_string fmt ","
+    else (
+      F.pp_print_space fmt ();
+      F.pp_print_string fmt ":");
+    F.pp_print_space fmt ();
+    F.pp_print_string fmt (type_keyword ()));
+  (* Close the box for "type TYPE_NAME (TYPE_PARAMS) =" *)
+  F.pp_close_box fmt ();
+  (if extract_body then
+     match def.kind with
+     | Struct fields ->
+         extract_type_decl_struct_body ctx_body fmt type_decl_group kind def
+           type_params cg_params fields
+     | Enum variants ->
+         extract_type_decl_enum_body ctx_body fmt type_decl_group def def_name
+           type_params cg_params variants
+     | Opaque -> raise (Failure "Unreachable"));
+  (* Add the definition end delimiter *)
+  if !backend = HOL4 && decl_is_not_last_from_group kind then (
+    F.pp_print_space fmt ();
+    F.pp_print_string fmt ";")
+  else if !backend = Coq && decl_is_last_from_group kind then (
+    (* This is actually an end of group delimiter. For aesthetic reasons
+       we print it here instead of in {!end_type_decl_group}. *)
+    F.pp_print_cut fmt ();
+    F.pp_print_string fmt ".");
+  (* Close the box for the definition *)
+  F.pp_close_box fmt ();
+  (* Add breaks to insert new lines between definitions *)
+  if !backend <> HOL4 || decl_is_not_last_from_group kind then
+    F.pp_print_break fmt 0 0
+
+(** Extract an opaque type declaration to HOL4.
+
+    Remark (SH): having to treat this specific case separately is very annoying,
+    but I could not find a better way.
+ *)
+let extract_type_decl_hol4_opaque (ctx : extraction_ctx) (fmt : F.formatter)
+    (def : type_decl) : unit =
+  (* Retrieve the definition name *)
+  let def_name = ctx_get_local_type def.def_id ctx in
+  (* Generic parameters are unsupported *)
+  assert (def.generics.const_generics = []);
+  (* Trait clauses on type definitions are unsupported *)
+  assert (def.generics.trait_clauses = []);
+  (* Types  *)
+  (* Count the number of parameters *)
+  let num_params = List.length def.generics.types in
+  (* Generate the declaration *)
+  F.pp_print_space fmt ();
+  F.pp_print_string fmt
+    ("val _ = new_type (\"" ^ def_name ^ "\", " ^ string_of_int num_params ^ ")");
+  F.pp_print_space fmt ()
+
+(** Extract an empty record type declaration to HOL4.
+
+    Empty records are not supported in HOL4, so we extract them as type
+    abbreviations to the unit type.
+
+    Remark (SH): having to treat this specific case separately is very annoying,
+    but I could not find a better way.
+ *)
+let extract_type_decl_hol4_empty_record (ctx : extraction_ctx)
+    (fmt : F.formatter) (def : type_decl) : unit =
+  (* Retrieve the definition name *)
+  let def_name = ctx_get_local_type def.def_id ctx in
+  (* Sanity check *)
+  assert (def.generics = empty_generic_params);
+  (* Generate the declaration *)
+  F.pp_print_space fmt ();
+  F.pp_print_string fmt ("Type " ^ def_name ^ " = “: unit”");
+  F.pp_print_space fmt ()
+
+(** Extract a type declaration.
+
+    Note that all the names used for extraction should already have been
+    registered.
+
+    This function should be inserted between calls to {!start_type_decl_group}
+    and {!end_type_decl_group}.
+ *)
+let extract_type_decl (ctx : extraction_ctx) (fmt : F.formatter)
+    (type_decl_group : TypeDeclId.Set.t) (kind : decl_kind) (def : type_decl) :
+    unit =
+  let extract_body =
+    match kind with
+    | SingleNonRec | SingleRec | MutRecFirst | MutRecInner | MutRecLast -> true
+    | Assumed | Declared -> false
+  in
+  if extract_body then
+    if !backend = HOL4 && is_empty_record_type_decl def then
+      extract_type_decl_hol4_empty_record ctx fmt def
+    else extract_type_decl_gen ctx fmt type_decl_group kind def extract_body
+  else
+    match !backend with
+    | FStar | Coq | Lean ->
+        extract_type_decl_gen ctx fmt type_decl_group kind def extract_body
+    | HOL4 -> extract_type_decl_hol4_opaque ctx fmt def
+
+(** Auxiliary function.
+
+    Generate [Arguments] instructions in Coq.
+ *)
+let extract_type_decl_coq_arguments (ctx : extraction_ctx) (fmt : F.formatter)
+    (kind : decl_kind) (decl : type_decl) : unit =
+  assert (!backend = Coq);
+  (* Generating the [Arguments] instructions is useful only if there are type parameters *)
+  if decl.generics.types = [] && decl.generics.const_generics = [] then ()
+  else
+    (* Add the type params - note that we need those bindings only for the
+     * body translation (they are not top-level) *)
+    let _ctx_body, type_params, cg_params, trait_clauses =
+      ctx_add_generic_params decl.generics ctx
+    in
+    (* Auxiliary function to extract an [Arguments Cons {T} _ _.] instruction *)
+    let extract_arguments_info (cons_name : string) (fields : 'a list) : unit =
+      (* Add a break before *)
+      F.pp_print_break fmt 0 0;
+      (* Open a box *)
+      F.pp_open_hovbox fmt ctx.indent_incr;
+      F.pp_print_break fmt 0 0;
+      F.pp_print_string fmt "Arguments";
+      F.pp_print_space fmt ();
+      F.pp_print_string fmt cons_name;
+      (* Print the type/const params and the trait clauses (`{T}`) *)
+      List.iter
+        (fun (var : string) ->
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt ("{" ^ var ^ "}"))
+        (List.concat [ type_params; cg_params; trait_clauses ]);
+      (* Print the fields (`_`) *)
+      List.iter
+        (fun _ ->
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt "_")
+        fields;
+      F.pp_print_string fmt ".";
+
+      (* Close the box *)
+      F.pp_close_box fmt ()
+    in
+
+    (* Generate the [Arguments] instruction *)
+    match decl.kind with
+    | Opaque -> ()
+    | Struct fields ->
+        let adt_id = AdtId decl.def_id in
+        (* Generate the instruction for the record constructor *)
+        let cons_name = ctx_get_struct adt_id ctx in
+        extract_arguments_info cons_name fields;
+        (* Generate the instruction for the record projectors, if there are *)
+        let is_rec = decl_is_from_rec_group kind in
+        if not is_rec then
+          FieldId.iteri
+            (fun fid _ ->
+              let cons_name = ctx_get_field adt_id fid ctx in
+              extract_arguments_info cons_name [])
+            fields;
+        (* Add breaks to insert new lines between definitions *)
+        F.pp_print_break fmt 0 0
+    | Enum variants ->
+        (* Generate the instructions *)
+        VariantId.iteri
+          (fun vid (v : variant) ->
+            let cons_name = ctx_get_variant (AdtId decl.def_id) vid ctx in
+            extract_arguments_info cons_name v.fields)
+          variants;
+        (* Add breaks to insert new lines between definitions *)
+        F.pp_print_break fmt 0 0
+
+(** Auxiliary function.
+
+    Generate field projectors in Coq.
+
+    Sometimes we extract records as inductives in Coq: when this happens we
+    have to define the field projectors afterwards.
+ *)
+let extract_type_decl_record_field_projectors (ctx : extraction_ctx)
+    (fmt : F.formatter) (kind : decl_kind) (decl : type_decl) : unit =
+  assert (!backend = Coq);
+  match decl.kind with
+  | Opaque | Enum _ -> ()
+  | Struct fields ->
+      (* Records are extracted as inductives only if they are recursive *)
+      let is_rec = decl_is_from_rec_group kind in
+      if is_rec then
+        (* Add the type params *)
+        let ctx, type_params, cg_params, trait_clauses =
+          ctx_add_generic_params decl.generics ctx
+        in
+        let ctx, record_var = ctx_add_var "x" (VarId.of_int 0) ctx in
+        let ctx, field_var = ctx_add_var "x" (VarId.of_int 1) ctx in
+        let def_name = ctx_get_local_type decl.def_id ctx in
+        let cons_name = ctx_get_struct (AdtId decl.def_id) ctx in
+        let extract_field_proj (field_id : FieldId.id) (_ : field) : unit =
+          F.pp_print_space fmt ();
+          (* Outer box for the projector definition *)
+          F.pp_open_hvbox fmt 0;
+          (* Inner box for the projector definition *)
+          F.pp_open_hvbox fmt ctx.indent_incr;
+          (* Open a box for the [Definition PROJ ... :=] *)
+          F.pp_open_hovbox fmt ctx.indent_incr;
+          F.pp_print_string fmt "Definition";
+          F.pp_print_space fmt ();
+          let field_name = ctx_get_field (AdtId decl.def_id) field_id ctx in
+          F.pp_print_string fmt field_name;
+          (* Print the generics *)
+          let as_implicits = true in
+          extract_generic_params ctx fmt TypeDeclId.Set.empty ~as_implicits
+            decl.generics type_params cg_params trait_clauses;
+          (* Print the record parameter *)
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt "(";
+          F.pp_print_string fmt record_var;
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt ":";
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt def_name;
+          List.iter
+            (fun p ->
+              F.pp_print_space fmt ();
+              F.pp_print_string fmt p)
+            type_params;
+          F.pp_print_string fmt ")";
+          (* *)
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt ":=";
+          (* Close the box for the [Definition PROJ ... :=] *)
+          F.pp_close_box fmt ();
+          F.pp_print_space fmt ();
+          (* Open a box for the whole match *)
+          F.pp_open_hvbox fmt 0;
+          (* Open a box for the [match ... with] *)
+          F.pp_open_hovbox fmt ctx.indent_incr;
+          F.pp_print_string fmt "match";
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt record_var;
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt "with";
+          (* Close the box for the [match ... with] *)
+          F.pp_close_box fmt ();
+
+          (* Open a box for the branch *)
+          F.pp_open_hovbox fmt ctx.indent_incr;
+          (* Print the match branch *)
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt "|";
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt cons_name;
+          FieldId.iteri
+            (fun id _ ->
+              F.pp_print_space fmt ();
+              if field_id = id then F.pp_print_string fmt field_var
+              else F.pp_print_string fmt "_")
+            fields;
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt "=>";
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt field_var;
+          (* Close the box for the branch *)
+          F.pp_close_box fmt ();
+          (* Print the [end] *)
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt "end";
+          (* Close the box for the whole match *)
+          F.pp_close_box fmt ();
+          (* Close the inner box projector *)
+          F.pp_close_box fmt ();
+          (* If Coq: end the definition with a "." *)
+          if !backend = Coq then (
+            F.pp_print_cut fmt ();
+            F.pp_print_string fmt ".");
+          (* Close the outer box projector  *)
+          F.pp_close_box fmt ();
+          (* Add breaks to insert new lines between definitions *)
+          F.pp_print_break fmt 0 0
+        in
+
+        let extract_proj_notation (field_id : FieldId.id) (_ : field) : unit =
+          F.pp_print_space fmt ();
+          (* Outer box for the projector definition *)
+          F.pp_open_hvbox fmt 0;
+          (* Inner box for the projector definition *)
+          F.pp_open_hovbox fmt ctx.indent_incr;
+          let ctx, record_var = ctx_add_var "x" (VarId.of_int 0) ctx in
+          F.pp_print_string fmt "Notation";
+          F.pp_print_space fmt ();
+          let field_name = ctx_get_field (AdtId decl.def_id) field_id ctx in
+          F.pp_print_string fmt ("\"" ^ record_var ^ " .(" ^ field_name ^ ")\"");
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt ":=";
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt "(";
+          F.pp_print_string fmt field_name;
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt record_var;
+          F.pp_print_string fmt ")";
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt "(at level 9)";
+          (* Close the inner box projector *)
+          F.pp_close_box fmt ();
+          (* If Coq: end the definition with a "." *)
+          if !backend = Coq then (
+            F.pp_print_cut fmt ();
+            F.pp_print_string fmt ".");
+          (* Close the outer box projector  *)
+          F.pp_close_box fmt ();
+          (* Add breaks to insert new lines between definitions *)
+          F.pp_print_break fmt 0 0
+        in
+
+        let extract_field_proj_and_notation (field_id : FieldId.id)
+            (field : field) : unit =
+          extract_field_proj field_id field;
+          extract_proj_notation field_id field
+        in
+
+        FieldId.iteri extract_field_proj_and_notation fields
+
+(** Extract extra information for a type (e.g., [Arguments] instructions in Coq).
+
+    Note that all the names used for extraction should already have been
+    registered.
+ *)
+let extract_type_decl_extra_info (ctx : extraction_ctx) (fmt : F.formatter)
+    (kind : decl_kind) (decl : type_decl) : unit =
+  match !backend with
+  | FStar | Lean | HOL4 -> ()
+  | Coq ->
+      extract_type_decl_coq_arguments ctx fmt kind decl;
+      extract_type_decl_record_field_projectors ctx fmt kind decl
+
+(** Extract the state type declaration. *)
+let extract_state_type (fmt : F.formatter) (ctx : extraction_ctx)
+    (kind : decl_kind) : unit =
+  (* Add a break before *)
+  F.pp_print_break fmt 0 0;
+  (* Print a comment  *)
+  extract_comment fmt [ "The state type used in the state-error monad" ];
+  F.pp_print_break fmt 0 0;
+  (* Open a box for the definition, so that whenever possible it gets printed on
+   * one line *)
+  F.pp_open_hvbox fmt 0;
+  (* Retrieve the name *)
+  let state_name = ctx_get_assumed_type State ctx in
+  (* The syntax for Lean and Coq is almost identical. *)
+  let print_axiom () =
+    let axiom =
+      match !backend with
+      | Coq -> "Axiom"
+      | Lean -> "axiom"
+      | FStar | HOL4 -> raise (Failure "Unexpected")
+    in
+    F.pp_print_string fmt axiom;
+    F.pp_print_space fmt ();
+    F.pp_print_string fmt state_name;
+    F.pp_print_space fmt ();
+    F.pp_print_string fmt ":";
+    F.pp_print_space fmt ();
+    F.pp_print_string fmt "Type";
+    if !backend = Coq then F.pp_print_string fmt "."
+  in
+  (* The kind should be [Assumed] or [Declared] *)
+  (match kind with
+  | SingleNonRec | SingleRec | MutRecFirst | MutRecInner | MutRecLast ->
+      raise (Failure "Unexpected")
+  | Assumed -> (
+      match !backend with
+      | FStar ->
+          F.pp_print_string fmt "assume";
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt "type";
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt state_name;
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt ":";
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt "Type0"
+      | HOL4 ->
+          F.pp_print_string fmt ("val _ = new_type (\"" ^ state_name ^ "\", 0)")
+      | Coq | Lean -> print_axiom ())
+  | Declared -> (
+      match !backend with
+      | FStar ->
+          F.pp_print_string fmt "val";
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt state_name;
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt ":";
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt "Type0"
+      | HOL4 ->
+          F.pp_print_string fmt ("val _ = new_type (\"" ^ state_name ^ "\", 0)")
+      | Coq | Lean -> print_axiom ()));
+  (* Close the box for the definition *)
+  F.pp_close_box fmt ();
+  (* Add breaks to insert new lines between definitions *)
+  F.pp_print_break fmt 0 0
diff --git a/compiler/Pure.ml b/compiler/Pure.ml
index 9a3654b8..a5aa0edd 100644
--- a/compiler/Pure.ml
+++ b/compiler/Pure.ml
@@ -24,8 +24,6 @@ module TraitClauseId = T.TraitClauseId
 module LoopId =
 IdGen ()
 
-type loop_id = LoopId.id [@@deriving show, ord]
-
 (** We give an identifier to every phase of the synthesis (forward, backward
     for group of regions 0, etc.) *)
 module SynthPhaseId =
@@ -47,6 +45,8 @@ type trait_clause_id = T.trait_clause_id [@@deriving show, ord]
 type trait_item_name = T.trait_item_name [@@deriving show, ord]
 type global_decl_id = T.global_decl_id [@@deriving show, ord]
 type fun_decl_id = A.fun_decl_id [@@deriving show, ord]
+type loop_id = LoopId.id [@@deriving show, ord]
+type region_group_id = T.region_group_id [@@deriving show, ord]
 type mutability = Mut | Const [@@deriving show, ord]
 
 (** The assumed types for the pure AST.
diff --git a/compiler/Translate.ml b/compiler/Translate.ml
index 019a5c35..c5ac4e96 100644
--- a/compiler/Translate.ml
+++ b/compiler/Translate.ml
@@ -1076,6 +1076,7 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
       functions_with_decreases_clause = rec_functions;
       types_filter_type_args_map = Pure.TypeDeclId.Map.empty;
       funs_filter_type_args_map = Pure.FunDeclId.Map.empty;
+      trait_impls_filter_type_args_map = Pure.TraitImplId.Map.empty;
     }
   in
 
diff --git a/compiler/dune b/compiler/dune
index a4b09df4..648c7325 100644
--- a/compiler/dune
+++ b/compiler/dune
@@ -24,6 +24,7 @@
   Extract
   ExtractBase
   ExtractBuiltin
+  ExtractTypes
   FunsAnalysis
   Identifiers
   InterpreterBorrowsCore
-- 
cgit v1.3.1


From ca24c351f97a3f8989a6866de0868ef54241b194 Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Thu, 26 Oct 2023 12:07:50 +0200
Subject: Make progress on fixing the extraction for Lean

---
 backends/lean/Base/Primitives/ArraySlice.lean | 164 ++++++++-----------------
 compiler/Extract.ml                           |   2 +-
 compiler/ExtractBase.ml                       | 165 ++++++++++++++++----------
 compiler/ExtractTypes.ml                      |  48 ++++----
 compiler/Translate.ml                         |  21 +---
 5 files changed, 180 insertions(+), 220 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/backends/lean/Base/Primitives/ArraySlice.lean b/backends/lean/Base/Primitives/ArraySlice.lean
index 615e0783..2a080ca6 100644
--- a/backends/lean/Base/Primitives/ArraySlice.lean
+++ b/backends/lean/Base/Primitives/ArraySlice.lean
@@ -40,14 +40,14 @@ def Array.make (α : Type u) (n : Usize) (init : List α) (hl : init.len = n.val
 example : Array Int (Usize.ofInt 2) := Array.make Int (Usize.ofInt 2) [0, 1]
 
 @[simp]
-abbrev Array.index {α : Type u} {n : Usize} [Inhabited α] (v : Array α n) (i : Int) : α :=
+abbrev Array.index_s {α : Type u} {n : Usize} [Inhabited α] (v : Array α n) (i : Int) : α :=
   v.val.index i
 
 @[simp]
 abbrev Array.slice {α : Type u} {n : Usize} [Inhabited α] (v : Array α n) (i j : Int) : List α :=
   v.val.slice i j
 
-def Array.index_shared (α : Type u) (n : Usize) (v: Array α n) (i: Usize) : Result α :=
+def Array.index_usize (α : Type u) (n : Usize) (v: Array α n) (i: Usize) : Result α :=
   match v.val.indexOpt i.val with
   | none => fail .arrayOutOfBounds
   | some x => ret x
@@ -67,48 +67,27 @@ theorem Array.repeat_spec {α : Type u} (n : Usize) (x : α) :
  -/
 
 @[pspec]
-theorem Array.index_shared_spec {α : Type u} {n : Usize} [Inhabited α] (v: Array α n) (i: Usize)
+theorem Array.index_usize_spec {α : Type u} {n : Usize} [Inhabited α] (v: Array α n) (i: Usize)
   (hbound : i.val < v.length) :
-  ∃ x, v.index_shared α n i = ret x ∧ x = v.val.index i.val := by
-  simp only [index_shared]
+  ∃ x, v.index_usize α n i = ret x ∧ x = v.val.index i.val := by
+  simp only [index_usize]
   -- TODO: dependent rewrite
   have h := List.indexOpt_eq_index v.val i.val (by scalar_tac) (by simp [*])
   simp [*]
 
--- This shouldn't be used
-def Array.index_shared_back (α : Type u) (n : Usize) (v: Array α n) (i: Usize) (_: α) : Result Unit :=
-  if i.val < List.length v.val then
-    .ret ()
-  else
-    .fail arrayOutOfBounds
-
-def Array.index_mut (α : Type u) (n : Usize) (v: Array α n) (i: Usize) : Result α :=
-  match v.val.indexOpt i.val with
-  | none => fail .arrayOutOfBounds
-  | some x => ret x
-
-@[pspec]
-theorem Array.index_mut_spec {α : Type u} {n : Usize} [Inhabited α] (v: Array α n) (i: Usize)
-  (hbound : i.val < v.length) :
-  ∃ x, v.index_mut α n i = ret x ∧ x = v.val.index i.val := by
-  simp only [index_mut]
-  -- TODO: dependent rewrite
-  have h := List.indexOpt_eq_index v.val i.val (by scalar_tac) (by simp [*])
-  simp [*]
-
-def Array.index_mut_back (α : Type u) (n : Usize) (v: Array α n) (i: Usize) (x: α) : Result (Array α n) :=
+def Array.update_usize (α : Type u) (n : Usize) (v: Array α n) (i: Usize) (x: α) : Result (Array α n) :=
   match v.val.indexOpt i.val with
   | none => fail .arrayOutOfBounds
   | some _ =>
     .ret ⟨ v.val.update i.val x, by have := v.property; simp [*] ⟩
 
 @[pspec]
-theorem Array.index_mut_back_spec {α : Type u} {n : Usize} (v: Array α n) (i: Usize) (x : α)
+theorem Array.update_usize_spec {α : Type u} {n : Usize} (v: Array α n) (i: Usize) (x : α)
   (hbound : i.val < v.length) :
-  ∃ nv, v.index_mut_back α n i x = ret nv ∧
+  ∃ nv, v.update_usize α n i x = ret nv ∧
   nv.val = v.val.update i.val x
   := by
-  simp only [index_mut_back]
+  simp only [update_usize]
   have h := List.indexOpt_bounds v.val i.val
   split
   . simp_all [length]; cases h <;> scalar_tac
@@ -144,14 +123,14 @@ theorem Slice.len_val {α : Type u} (v : Slice α) : (Slice.len α v).val = v.le
   by rfl
 
 @[simp]
-abbrev Slice.index {α : Type u} [Inhabited α] (v: Slice α) (i: Int) : α :=
+abbrev Slice.index_s {α : Type u} [Inhabited α] (v: Slice α) (i: Int) : α :=
   v.val.index i
 
 @[simp]
 abbrev Slice.slice {α : Type u} [Inhabited α] (s : Slice α) (i j : Int) : List α :=
   s.val.slice i j
 
-def Slice.index_shared (α : Type u) (v: Slice α) (i: Usize) : Result α :=
+def Slice.index_usize (α : Type u) (v: Slice α) (i: Usize) : Result α :=
   match v.val.indexOpt i.val with
   | none => fail .arrayOutOfBounds
   | some x => ret x
@@ -162,10 +141,10 @@ def Slice.index_shared (α : Type u) (v: Slice α) (i: Usize) : Result α :=
  -/
 
 @[pspec]
-theorem Slice.index_shared_spec {α : Type u} [Inhabited α] (v: Slice α) (i: Usize)
+theorem Slice.index_usize_spec {α : Type u} [Inhabited α] (v: Slice α) (i: Usize)
   (hbound : i.val < v.length) :
-  ∃ x, v.index_shared α i = ret x ∧ x = v.val.index i.val := by
-  simp only [index_shared]
+  ∃ x, v.index_usize α i = ret x ∧ x = v.val.index i.val := by
+  simp only [index_usize]
   -- TODO: dependent rewrite
   have h := List.indexOpt_eq_index v.val i.val (by scalar_tac) (by simp [*])
   simp [*]
@@ -177,33 +156,19 @@ def Slice.index_shared_back (α : Type u) (v: Slice α) (i: Usize) (_: α) : Res
   else
     .fail arrayOutOfBounds
 
-def Slice.index_mut (α : Type u) (v: Slice α) (i: Usize) : Result α :=
-  match v.val.indexOpt i.val with
-  | none => fail .arrayOutOfBounds
-  | some x => ret x
-
-@[pspec]
-theorem Slice.index_mut_spec {α : Type u} [Inhabited α] (v: Slice α) (i: Usize)
-  (hbound : i.val < v.length) :
-  ∃ x, v.index_mut α i = ret x ∧ x = v.val.index i.val := by
-  simp only [index_mut]
-  -- TODO: dependent rewrite
-  have h := List.indexOpt_eq_index v.val i.val (by scalar_tac) (by simp [*])
-  simp [*]
-
-def Slice.index_mut_back (α : Type u) (v: Slice α) (i: Usize) (x: α) : Result (Slice α) :=
+def Slice.update_usize (α : Type u) (v: Slice α) (i: Usize) (x: α) : Result (Slice α) :=
   match v.val.indexOpt i.val with
   | none => fail .arrayOutOfBounds
   | some _ =>
     .ret ⟨ v.val.update i.val x, by have := v.property; simp [*] ⟩
 
 @[pspec]
-theorem Slice.index_mut_back_spec {α : Type u} (v: Slice α) (i: Usize) (x : α)
+theorem Slice.update_usize_spec {α : Type u} (v: Slice α) (i: Usize) (x : α)
   (hbound : i.val < v.length) :
-  ∃ nv, v.index_mut_back α i x = ret nv ∧
+  ∃ nv, v.update_usize α i x = ret nv ∧
   nv.val = v.val.update i.val x
   := by
-  simp only [index_mut_back]
+  simp only [update_usize]
   have h := List.indexOpt_bounds v.val i.val
   split
   . simp_all [length]; cases h <;> scalar_tac
@@ -212,34 +177,27 @@ theorem Slice.index_mut_back_spec {α : Type u} (v: Slice α) (i: Usize) (x : α
 /- Array to slice/subslices -/
 
 /- We could make this function not use the `Result` type. By making it monadic, we
-   push the user to use the `Array.to_slice_shared_spec` spec theorem below (through the
-   `progress` tactic), meaning `Array.to_slice_shared` should be considered as opaque.
+   push the user to use the `Array.to_slice_spec` spec theorem below (through the
+   `progress` tactic), meaning `Array.to_slice` should be considered as opaque.
    All what the spec theorem reveals is that the "representative" lists are the same. -/
-def Array.to_slice_shared (α : Type u) (n : Usize) (v : Array α n) : Result (Slice α) :=
+def Array.to_slice (α : Type u) (n : Usize) (v : Array α n) : Result (Slice α) :=
   ret ⟨ v.val, by simp [← List.len_eq_length]; scalar_tac ⟩
 
 @[pspec]
-theorem Array.to_slice_shared_spec {α : Type u} {n : Usize} (v : Array α n) :
-  ∃ s, to_slice_shared α n v = ret s ∧ v.val = s.val := by simp [to_slice_shared]
-
-def Array.to_slice_mut (α : Type u) (n : Usize) (v : Array α n) : Result (Slice α) :=
-  to_slice_shared α n v
+theorem Array.to_slice_spec {α : Type u} {n : Usize} (v : Array α n) :
+  ∃ s, to_slice α n v = ret s ∧ v.val = s.val := by simp [to_slice]
 
-@[pspec]
-theorem Array.to_slice_mut_spec {α : Type u} {n : Usize} (v : Array α n) :
-  ∃ s, Array.to_slice_shared α n v = ret s ∧ v.val = s.val := to_slice_shared_spec v
-
-def Array.to_slice_mut_back (α : Type u) (n : Usize) (_ : Array α n) (s : Slice α) : Result (Array α n) :=
+def Array.from_slice (α : Type u) (n : Usize) (_ : Array α n) (s : Slice α) : Result (Array α n) :=
   if h: s.val.len = n.val then
     ret ⟨ s.val, by simp [← List.len_eq_length, *] ⟩
   else fail panic
 
 @[pspec]
-theorem Array.to_slice_mut_back_spec {α : Type u} {n : Usize} (a : Array α n) (ns : Slice α) (h : ns.val.len = n.val) :
-  ∃ na, to_slice_mut_back α n a ns = ret na ∧ na.val = ns.val
-  := by simp [to_slice_mut_back, *]
+theorem Array.from_slice_spec {α : Type u} {n : Usize} (a : Array α n) (ns : Slice α) (h : ns.val.len = n.val) :
+  ∃ na, from_slice α n a ns = ret na ∧ na.val = ns.val
+  := by simp [from_slice, *]
 
-def Array.subslice_shared (α : Type u) (n : Usize) (a : Array α n) (r : Range Usize) : Result (Slice α) :=
+def Array.subslice (α : Type u) (n : Usize) (a : Array α n) (r : Range Usize) : Result (Slice α) :=
   -- TODO: not completely sure here
   if r.start.val < r.end_.val ∧ r.end_.val ≤ a.val.len then
     ret ⟨ a.val.slice r.start.val r.end_.val,
@@ -251,29 +209,18 @@ def Array.subslice_shared (α : Type u) (n : Usize) (a : Array α n) (r : Range
     fail panic
 
 @[pspec]
-theorem Array.subslice_shared_spec {α : Type u} {n : Usize} [Inhabited α] (a : Array α n) (r : Range Usize)
+theorem Array.subslice_spec {α : Type u} {n : Usize} [Inhabited α] (a : Array α n) (r : Range Usize)
   (h0 : r.start.val < r.end_.val) (h1 : r.end_.val ≤ a.val.len) :
-  ∃ s, subslice_shared α n a r = ret s ∧
+  ∃ s, subslice α n a r = ret s ∧
   s.val = a.val.slice r.start.val r.end_.val ∧
   (∀ i, 0 ≤ i → i + r.start.val < r.end_.val → s.val.index i = a.val.index (r.start.val + i))
   := by
-  simp [subslice_shared, *]
+  simp [subslice, *]
   intro i _ _
   have := List.index_slice r.start.val r.end_.val i a.val (by scalar_tac) (by scalar_tac) (by trivial) (by scalar_tac)
   simp [*]
 
-def Array.subslice_mut (α : Type u) (n : Usize) (a : Array α n) (r : Range Usize) : Result (Slice α) :=
-  Array.subslice_shared α n a r
-
-@[pspec]
-theorem Array.subslice_mut_spec {α : Type u} {n : Usize} [Inhabited α] (a : Array α n) (r : Range Usize)
-  (h0 : r.start.val < r.end_.val) (h1 : r.end_.val ≤ a.val.len) :
-  ∃ s, subslice_mut α n a r = ret s ∧
-  s.val = a.slice r.start.val r.end_.val ∧
-  (∀ i, 0 ≤ i → i + r.start.val < r.end_.val → s.val.index i = a.val.index (r.start.val + i))
-  := subslice_shared_spec a r h0 h1
-
-def Array.subslice_mut_back (α : Type u) (n : Usize) (a : Array α n) (r : Range Usize) (s : Slice α) : Result (Array α n) :=
+def Array.update_subslice (α : Type u) (n : Usize) (a : Array α n) (r : Range Usize) (s : Slice α) : Result (Array α n) :=
   -- TODO: not completely sure here
   if h: r.start.val < r.end_.val ∧ r.end_.val ≤ a.length ∧ s.val.len = r.end_.val - r.start.val then
     let s_beg := a.val.itake r.start.val
@@ -298,13 +245,13 @@ def Array.subslice_mut_back (α : Type u) (n : Usize) (a : Array α n) (r : Rang
 -- We should introduce special symbols for the monadic arithmetic operations
 -- (the use will never write those symbols directly).
 @[pspec]
-theorem Array.subslice_mut_back_spec {α : Type u} {n : Usize} [Inhabited α] (a : Array α n) (r : Range Usize) (s : Slice α)
+theorem Array.update_subslice_spec {α : Type u} {n : Usize} [Inhabited α] (a : Array α n) (r : Range Usize) (s : Slice α)
   (_ : r.start.val < r.end_.val) (_ : r.end_.val ≤ a.length) (_ : s.length = r.end_.val - r.start.val) :
-  ∃ na, subslice_mut_back α n a r s = ret na ∧
-  (∀ i, 0 ≤ i → i < r.start.val → na.index i = a.index i) ∧
-  (∀ i, r.start.val ≤ i → i < r.end_.val → na.index i = s.index (i - r.start.val)) ∧
-  (∀ i, r.end_.val ≤ i → i < n.val → na.index i = a.index i) := by
-  simp [subslice_mut_back, *]
+  ∃ na, update_subslice α n a r s = ret na ∧
+  (∀ i, 0 ≤ i → i < r.start.val → na.index_s i = a.index_s i) ∧
+  (∀ i, r.start.val ≤ i → i < r.end_.val → na.index_s i = s.index_s (i - r.start.val)) ∧
+  (∀ i, r.end_.val ≤ i → i < n.val → na.index_s i = a.index_s i) := by
+  simp [update_subslice, *]
   have h := List.replace_slice_index r.start.val r.end_.val a.val s.val
     (by scalar_tac) (by scalar_tac) (by scalar_tac) (by scalar_tac)
   simp [List.replace_slice] at h
@@ -321,7 +268,7 @@ theorem Array.subslice_mut_back_spec {α : Type u} {n : Usize} [Inhabited α] (a
     have := h2 i (by int_tac) (by int_tac)
     simp [*]
 
-def Slice.subslice_shared (α : Type u) (s : Slice α) (r : Range Usize) : Result (Slice α) :=
+def Slice.subslice (α : Type u) (s : Slice α) (r : Range Usize) : Result (Slice α) :=
   -- TODO: not completely sure here
   if r.start.val < r.end_.val ∧ r.end_.val ≤ s.length then
     ret ⟨ s.val.slice r.start.val r.end_.val,
@@ -333,32 +280,21 @@ def Slice.subslice_shared (α : Type u) (s : Slice α) (r : Range Usize) : Resul
     fail panic
 
 @[pspec]
-theorem Slice.subslice_shared_spec {α : Type u} [Inhabited α] (s : Slice α) (r : Range Usize)
+theorem Slice.subslice_spec {α : Type u} [Inhabited α] (s : Slice α) (r : Range Usize)
   (h0 : r.start.val < r.end_.val) (h1 : r.end_.val ≤ s.val.len) :
-  ∃ ns, subslice_shared α s r = ret ns ∧
+  ∃ ns, subslice α s r = ret ns ∧
   ns.val = s.slice r.start.val r.end_.val ∧
-  (∀ i, 0 ≤ i → i + r.start.val < r.end_.val → ns.index i = s.index (r.start.val + i))
+  (∀ i, 0 ≤ i → i + r.start.val < r.end_.val → ns.index_s i = s.index_s (r.start.val + i))
   := by
-  simp [subslice_shared, *]
+  simp [subslice, *]
   intro i _ _
   have := List.index_slice r.start.val r.end_.val i s.val (by scalar_tac) (by scalar_tac) (by trivial) (by scalar_tac)
   simp [*]
 
-def Slice.subslice_mut (α : Type u) (s : Slice α) (r : Range Usize) : Result (Slice α) :=
-  Slice.subslice_shared α s r
-
-@[pspec]
-theorem Slice.subslice_mut_spec {α : Type u} [Inhabited α] (s : Slice α) (r : Range Usize)
-  (h0 : r.start.val < r.end_.val) (h1 : r.end_.val ≤ s.val.len) :
-  ∃ ns, subslice_mut α s r = ret ns ∧
-  ns.val = s.slice r.start.val r.end_.val ∧
-  (∀ i, 0 ≤ i → i + r.start.val < r.end_.val → ns.index i = s.index (r.start.val + i))
-  := subslice_shared_spec s r h0 h1
-
 attribute [pp_dot] List.len List.length List.index -- use the dot notation when printing
 set_option pp.coercions false -- do not print coercions with ↑ (this doesn't parse)
 
-def Slice.subslice_mut_back (α : Type u) (s : Slice α) (r : Range Usize) (ss : Slice α) : Result (Slice α) :=
+def Slice.update_subslice (α : Type u) (s : Slice α) (r : Range Usize) (ss : Slice α) : Result (Slice α) :=
   -- TODO: not completely sure here
   if h: r.start.val < r.end_.val ∧ r.end_.val ≤ s.length ∧ ss.val.len = r.end_.val - r.start.val then
     let s_beg := s.val.itake r.start.val
@@ -378,13 +314,13 @@ def Slice.subslice_mut_back (α : Type u) (s : Slice α) (r : Range Usize) (ss :
     fail panic
 
 @[pspec]
-theorem Slice.subslice_mut_back_spec {α : Type u} [Inhabited α] (a : Slice α) (r : Range Usize) (ss : Slice α)
+theorem Slice.update_subslice_spec {α : Type u} [Inhabited α] (a : Slice α) (r : Range Usize) (ss : Slice α)
   (_ : r.start.val < r.end_.val) (_ : r.end_.val ≤ a.length) (_ : ss.length = r.end_.val - r.start.val) :
-  ∃ na, subslice_mut_back α a r ss = ret na ∧
-  (∀ i, 0 ≤ i → i < r.start.val → na.index i = a.index i) ∧
-  (∀ i, r.start.val ≤ i → i < r.end_.val → na.index i = ss.index (i - r.start.val)) ∧
-  (∀ i, r.end_.val ≤ i → i < a.length → na.index i = a.index i) := by
-  simp [subslice_mut_back, *]
+  ∃ na, update_subslice α a r ss = ret na ∧
+  (∀ i, 0 ≤ i → i < r.start.val → na.index_s i = a.index_s i) ∧
+  (∀ i, r.start.val ≤ i → i < r.end_.val → na.index_s i = ss.index_s (i - r.start.val)) ∧
+  (∀ i, r.end_.val ≤ i → i < a.length → na.index_s i = a.index_s i) := by
+  simp [update_subslice, *]
   have h := List.replace_slice_index r.start.val r.end_.val a.val ss.val
     (by scalar_tac) (by scalar_tac) (by scalar_tac) (by scalar_tac)
   simp [List.replace_slice, *] at h
diff --git a/compiler/Extract.ml b/compiler/Extract.ml
index fdcd82d9..574602c7 100644
--- a/compiler/Extract.ml
+++ b/compiler/Extract.ml
@@ -241,7 +241,7 @@ let rec extract_typed_pattern (ctx : extraction_ctx) (fmt : F.formatter)
       ctx
   | PatVar (v, _) ->
       let vname =
-        ctx.fmt.var_basename ctx.names_map.names_set v.basename v.ty
+        ctx.fmt.var_basename ctx.names_maps.names_map.names_set v.basename v.ty
       in
       let ctx, vname = ctx_add_var vname v.id ctx in
       F.pp_print_string fmt vname;
diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index 7e8e4ffc..8f71116c 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -520,23 +520,6 @@ let names_map_add (id_to_string : id -> string) (id : id) (name : string)
   let names_set = StringSet.add name nm.names_set in
   { id_to_name; name_to_id; names_set }
 
-let names_map_add_assumed_type (id_to_string : id -> string) (id : assumed_ty)
-    (name : string) (nm : names_map) : names_map =
-  names_map_add id_to_string (TypeId (Assumed id)) name nm
-
-let names_map_add_assumed_struct (id_to_string : id -> string) (id : assumed_ty)
-    (name : string) (nm : names_map) : names_map =
-  names_map_add id_to_string (StructId (Assumed id)) name nm
-
-let names_map_add_assumed_variant (id_to_string : id -> string)
-    (id : assumed_ty) (variant_id : VariantId.id) (name : string)
-    (nm : names_map) : names_map =
-  names_map_add id_to_string (VariantId (Assumed id, variant_id)) name nm
-
-let names_map_add_function (id_to_string : id -> string) (fid : fun_id)
-    (name : string) (nm : names_map) : names_map =
-  names_map_add id_to_string (FunId fid) name nm
-
 (** The unsafe names map stores mappings from identifiers to names which might
     collide. For some backends and some names, it might be acceptable to have
     collisions. For instance, in Lean, different records can have fields with
@@ -547,6 +530,8 @@ let names_map_add_function (id_to_string : id -> string) (fid : fun_id)
   *)
 type unsafe_names_map = { id_to_name : string IdMap.t }
 
+let empty_unsafe_names_map = { id_to_name = IdMap.empty }
+
 let unsafe_names_map_add (id : id) (name : string) (nm : unsafe_names_map) :
     unsafe_names_map =
   { id_to_name = IdMap.add id name nm.id_to_name }
@@ -585,16 +570,7 @@ let basename_to_unique (names_set : StringSet.t)
 
 type fun_name_info = { keep_fwd : bool; num_backs : int }
 
-(** Extraction context.
-
-    Note that the extraction context contains information coming from the
-    LLBC AST (not only the pure AST). This is useful for naming, for instance:
-    we use the region information to generate the names of the backward
-    functions, etc.
- *)
-type extraction_ctx = {
-  crate : A.crate;
-  trans_ctx : trans_ctx;
+type names_maps = {
   names_map : names_map;
       (** The map for id to names, where we forbid name collisions
           (ex.: we always forbid function name collisions). *)
@@ -610,6 +586,19 @@ type extraction_ctx = {
           the name "u32", and another field of the same record refers to "u32"
           (for instance in its type).
        *)
+}
+
+(** Extraction context.
+
+    Note that the extraction context contains information coming from the
+    LLBC AST (not only the pure AST). This is useful for naming, for instance:
+    we use the region information to generate the names of the backward
+    functions, etc.
+ *)
+type extraction_ctx = {
+  crate : A.crate;
+  trans_ctx : trans_ctx;
+  names_maps : names_maps;
   fmt : formatter;
   indent_incr : int;
       (** The indent increment we insert whenever we need to indent more *)
@@ -836,12 +825,15 @@ let allow_collisions (id : id) : bool =
   | FieldId _ | TraitItemClauseId _ | TraitParentClauseId _ | TraitItemId _
   | TraitMethodId _ ->
       !Config.record_fields_short_names
+  | FunId (Pure _ | FromLlbc (FunId (Assumed _), _, _)) ->
+      (* We map several assumed functions to the same id *)
+      true
   | _ -> false
 
-let ctx_add (id : id) (name : string) (ctx : extraction_ctx) : extraction_ctx =
-  (* The id_to_string function to print nice debugging messages if there are
-   * collisions *)
-  let id_to_string (id : id) : string = id_to_string id ctx in
+(** The [id_to_string] function to print nice debugging messages if there are
+    collisions *)
+let names_maps_add (id_to_string : id -> string) (id : id) (name : string)
+    (nm : names_maps) : names_maps =
   (* We do not use the same name map if we allow/disallow collisions.
      We notably use it for field names: some backends like Lean can use the
      type information to disambiguate field projections.
@@ -856,59 +848,90 @@ let ctx_add (id : id) (name : string) (ctx : extraction_ctx) : extraction_ctx =
   *)
   if allow_collisions id then (
     (* Check with the ids which are considered to be strict on collisions *)
-    names_map_check_collision id_to_string id name ctx.strict_names_map;
+    names_map_check_collision id_to_string id name nm.strict_names_map;
     {
-      ctx with
-      unsafe_names_map = unsafe_names_map_add id name ctx.unsafe_names_map;
+      nm with
+      unsafe_names_map = unsafe_names_map_add id name nm.unsafe_names_map;
     })
   else
     (* Remark: if we are strict on collisions:
        - we add the id to the strict collisions map
        - we check that the id doesn't collide with the unsafe map
+       TODO: we might not check that:
+       - a user defined function doesn't collide with an assumed function
+       - two trait decl items don't collide with each other
     *)
     let strict_names_map =
       if strict_collisions id then
-        names_map_add id_to_string id name ctx.strict_names_map
-      else ctx.strict_names_map
+        names_map_add id_to_string id name nm.strict_names_map
+      else nm.strict_names_map
     in
-    let names_map = names_map_add id_to_string id name ctx.names_map in
-    { ctx with strict_names_map; names_map }
+    let names_map = names_map_add id_to_string id name nm.names_map in
+    { nm with strict_names_map; names_map }
 
-let ctx_get (id : id) (ctx : extraction_ctx) : string =
+let ctx_add (id : id) (name : string) (ctx : extraction_ctx) : extraction_ctx =
+  let id_to_string (id : id) : string = id_to_string id ctx in
+  let names_maps = names_maps_add id_to_string id name ctx.names_maps in
+  { ctx with names_maps }
+
+(** The [id_to_string] function to print nice debugging messages if there are
+    collisions *)
+let names_maps_get (id_to_string : id -> string) (id : id) (nm : names_maps) :
+    string =
   (* We do not use the same name map if we allow/disallow collisions *)
   let map_to_string (m : string IdMap.t) : string =
     "[\n"
     ^ String.concat ","
         (List.map
-           (fun (id, n) -> "\n  " ^ id_to_string id ctx ^ " -> " ^ n)
+           (fun (id, n) -> "\n  " ^ id_to_string id ^ " -> " ^ n)
            (IdMap.bindings m))
     ^ "\n]"
   in
   if allow_collisions id then (
-    let m = ctx.unsafe_names_map.id_to_name in
+    let m = nm.unsafe_names_map.id_to_name in
     match IdMap.find_opt id m with
     | Some s -> s
     | None ->
         let err =
-          "Could not find: " ^ id_to_string id ctx ^ "\nNames map:\n"
+          "Could not find: " ^ id_to_string id ^ "\nNames map:\n"
           ^ map_to_string m
         in
         log#serror err;
         if !Config.extract_fail_hard then raise (Failure err)
-        else
-          "(%%%ERROR: unknown identifier\": " ^ id_to_string id ctx ^ "\"%%%)")
+        else "(%%%ERROR: unknown identifier\": " ^ id_to_string id ^ "\"%%%)")
   else
-    let m = ctx.names_map.id_to_name in
+    let m = nm.names_map.id_to_name in
     match IdMap.find_opt id m with
     | Some s -> s
     | None ->
         let err =
-          "Could not find: " ^ id_to_string id ctx ^ "\nNames map:\n"
+          "Could not find: " ^ id_to_string id ^ "\nNames map:\n"
           ^ map_to_string m
         in
         log#serror err;
         if !Config.extract_fail_hard then raise (Failure err)
-        else "(ERROR: \"" ^ id_to_string id ctx ^ "\")"
+        else "(ERROR: \"" ^ id_to_string id ^ "\")"
+
+let ctx_get (id : id) (ctx : extraction_ctx) : string =
+  let id_to_string (id : id) : string = id_to_string id ctx in
+  names_maps_get id_to_string id ctx.names_maps
+
+let names_maps_add_assumed_type (id_to_string : id -> string) (id : assumed_ty)
+    (name : string) (nm : names_maps) : names_maps =
+  names_maps_add id_to_string (TypeId (Assumed id)) name nm
+
+let names_maps_add_assumed_struct (id_to_string : id -> string)
+    (id : assumed_ty) (name : string) (nm : names_maps) : names_maps =
+  names_maps_add id_to_string (StructId (Assumed id)) name nm
+
+let names_maps_add_assumed_variant (id_to_string : id -> string)
+    (id : assumed_ty) (variant_id : VariantId.id) (name : string)
+    (nm : names_maps) : names_maps =
+  names_maps_add id_to_string (VariantId (Assumed id, variant_id)) name nm
+
+let names_maps_add_function (id_to_string : id -> string) (fid : fun_id)
+    (name : string) (nm : names_maps) : names_maps =
+  names_maps_add id_to_string (FunId fid) name nm
 
 let ctx_get_global (id : A.GlobalDeclId.id) (ctx : extraction_ctx) : string =
   ctx_get (GlobalId id) ctx
@@ -999,9 +1022,12 @@ let ctx_get_termination_measure (def_id : A.FunDeclId.id)
 (** Generate a unique type variable name and add it to the context *)
 let ctx_add_type_var (basename : string) (id : TypeVarId.id)
     (ctx : extraction_ctx) : extraction_ctx * string =
-  let name = ctx.fmt.type_var_basename ctx.names_map.names_set basename in
   let name =
-    basename_to_unique ctx.names_map.names_set ctx.fmt.append_index name
+    ctx.fmt.type_var_basename ctx.names_maps.names_map.names_set basename
+  in
+  let name =
+    basename_to_unique ctx.names_maps.names_map.names_set ctx.fmt.append_index
+      name
   in
   let ctx = ctx_add (TypeVarId id) name ctx in
   (ctx, name)
@@ -1010,10 +1036,12 @@ let ctx_add_type_var (basename : string) (id : TypeVarId.id)
 let ctx_add_const_generic_var (basename : string) (id : ConstGenericVarId.id)
     (ctx : extraction_ctx) : extraction_ctx * string =
   let name =
-    ctx.fmt.const_generic_var_basename ctx.names_map.names_set basename
+    ctx.fmt.const_generic_var_basename ctx.names_maps.names_map.names_set
+      basename
   in
   let name =
-    basename_to_unique ctx.names_map.names_set ctx.fmt.append_index name
+    basename_to_unique ctx.names_maps.names_map.names_set ctx.fmt.append_index
+      name
   in
   let ctx = ctx_add (ConstGenericVarId id) name ctx in
   (ctx, name)
@@ -1029,7 +1057,8 @@ let ctx_add_type_vars (vars : (string * TypeVarId.id) list)
 let ctx_add_var (basename : string) (id : VarId.id) (ctx : extraction_ctx) :
     extraction_ctx * string =
   let name =
-    basename_to_unique ctx.names_map.names_set ctx.fmt.append_index basename
+    basename_to_unique ctx.names_maps.names_map.names_set ctx.fmt.append_index
+      basename
   in
   let ctx = ctx_add (VarId id) name ctx in
   (ctx, name)
@@ -1038,7 +1067,8 @@ let ctx_add_var (basename : string) (id : VarId.id) (ctx : extraction_ctx) :
 let ctx_add_trait_self_clause (ctx : extraction_ctx) : extraction_ctx * string =
   let basename = ctx.fmt.trait_self_clause_basename in
   let name =
-    basename_to_unique ctx.names_map.names_set ctx.fmt.append_index basename
+    basename_to_unique ctx.names_maps.names_map.names_set ctx.fmt.append_index
+      basename
   in
   let ctx = ctx_add TraitSelfClauseId name ctx in
   (ctx, name)
@@ -1047,7 +1077,8 @@ let ctx_add_trait_self_clause (ctx : extraction_ctx) : extraction_ctx * string =
 let ctx_add_local_trait_clause (basename : string) (id : TraitClauseId.id)
     (ctx : extraction_ctx) : extraction_ctx * string =
   let name =
-    basename_to_unique ctx.names_map.names_set ctx.fmt.append_index basename
+    basename_to_unique ctx.names_maps.names_map.names_set ctx.fmt.append_index
+      basename
   in
   let ctx = ctx_add (LocalTraitClauseId id) name ctx in
   (ctx, name)
@@ -1057,7 +1088,9 @@ let ctx_add_vars (vars : var list) (ctx : extraction_ctx) :
     extraction_ctx * string list =
   List.fold_left_map
     (fun ctx (v : var) ->
-      let name = ctx.fmt.var_basename ctx.names_map.names_set v.basename v.ty in
+      let name =
+        ctx.fmt.var_basename ctx.names_maps.names_map.names_set v.basename v.ty
+      in
       ctx_add_var name v.id ctx)
     ctx vars
 
@@ -1078,7 +1111,9 @@ let ctx_add_local_trait_clauses (clauses : trait_clause list)
     (ctx : extraction_ctx) : extraction_ctx * string list =
   List.fold_left_map
     (fun ctx (c : trait_clause) ->
-      let basename = ctx.fmt.trait_clause_basename ctx.names_map.names_set c in
+      let basename =
+        ctx.fmt.trait_clause_basename ctx.names_maps.names_map.names_set c
+      in
       ctx_add_local_trait_clause basename c.clause_id ctx)
     ctx clauses
 
@@ -1189,9 +1224,10 @@ type names_map_init = {
   assumed_pure_functions : (pure_assumed_fun_id * string) list;
 }
 
-(** Initialize a names map with a proper set of keywords/names coming from the
+(** Initialize names maps with a proper set of keywords/names coming from the
     target language/prover. *)
-let initialize_names_map (fmt : formatter) (init : names_map_init) : names_map =
+let initialize_names_maps (fmt : formatter) (init : names_map_init) : names_maps
+    =
   let int_names = List.map fmt.int_name T.all_int_types in
   let keywords =
     List.concat
@@ -1207,7 +1243,10 @@ let initialize_names_map (fmt : formatter) (init : names_map_init) : names_map =
    * Also note that we don't need this mapping for keywords: we insert keywords only
    * to check collisions. *)
   let id_to_name = IdMap.empty in
-  let nm = { id_to_name; name_to_id; names_set } in
+  let names_map = { id_to_name; name_to_id; names_set } in
+  let unsafe_names_map = empty_unsafe_names_map in
+  let strict_names_map = empty_names_map in
+  let nm = { names_map; unsafe_names_map; strict_names_map } in
   (* For debugging - we are creating bindings for assumed types and functions, so
    * it is ok if we simply use the "show" function (those aren't simply identified
    * by numbers) *)
@@ -1221,19 +1260,19 @@ let initialize_names_map (fmt : formatter) (init : names_map_init) : names_map =
   let nm =
     List.fold_left
       (fun nm (type_id, name) ->
-        names_map_add_assumed_type id_to_string type_id name nm)
+        names_maps_add_assumed_type id_to_string type_id name nm)
       nm init.assumed_adts
   in
   let nm =
     List.fold_left
       (fun nm (type_id, name) ->
-        names_map_add_assumed_struct id_to_string type_id name nm)
+        names_maps_add_assumed_struct id_to_string type_id name nm)
       nm init.assumed_structs
   in
   let nm =
     List.fold_left
       (fun nm (type_id, variant_id, name) ->
-        names_map_add_assumed_variant id_to_string type_id variant_id name nm)
+        names_maps_add_assumed_variant id_to_string type_id variant_id name nm)
       nm init.assumed_variants
   in
   let assumed_functions =
@@ -1245,7 +1284,7 @@ let initialize_names_map (fmt : formatter) (init : names_map_init) : names_map =
   in
   let nm =
     List.fold_left
-      (fun nm (fid, name) -> names_map_add_function id_to_string fid name nm)
+      (fun nm (fid, name) -> names_maps_add_function id_to_string fid name nm)
       nm assumed_functions
   in
   (* Return *)
diff --git a/compiler/ExtractTypes.ml b/compiler/ExtractTypes.ml
index 219f273f..fd3baf0d 100644
--- a/compiler/ExtractTypes.ml
+++ b/compiler/ExtractTypes.ml
@@ -300,30 +300,30 @@ let assumed_llbc_functions () :
   match !backend with
   | FStar | Coq | HOL4 ->
       [
-        (ArrayIndexShared, None, "array_index_shared");
-        (ArrayIndexMut, None, "array_index_mut_fwd");
-        (ArrayIndexMut, rg0, "array_index_mut_back");
-        (ArrayToSliceShared, None, "array_to_slice_shared");
-        (ArrayToSliceMut, None, "array_to_slice_mut_fwd");
-        (ArrayToSliceMut, rg0, "array_to_slice_mut_back");
+        (ArrayIndexShared, None, "array_index_usize");
+        (ArrayIndexMut, None, "array_index_usize");
+        (ArrayIndexMut, rg0, "array_update_usize");
+        (ArrayToSliceShared, None, "array_to_slice");
+        (ArrayToSliceMut, None, "array_to_slice");
+        (ArrayToSliceMut, rg0, "array_from_slice");
         (ArrayRepeat, None, "array_repeat");
-        (SliceIndexShared, None, "slice_index_shared");
-        (SliceIndexMut, None, "slice_index_mut_fwd");
-        (SliceIndexMut, rg0, "slice_index_mut_back");
+        (SliceIndexShared, None, "slice_index_usize");
+        (SliceIndexMut, None, "slice_index_usize");
+        (SliceIndexMut, rg0, "slice_update_usize");
         (SliceLen, None, "slice_len");
       ]
   | Lean ->
       [
-        (ArrayIndexShared, None, "Array.index_shared");
-        (ArrayIndexMut, None, "Array.index_mut");
-        (ArrayIndexMut, rg0, "Array.index_mut_back");
-        (ArrayToSliceShared, None, "Array.to_slice_shared");
-        (ArrayToSliceMut, None, "Array.to_slice_mut");
-        (ArrayToSliceMut, rg0, "Array.to_slice_mut_back");
+        (ArrayIndexShared, None, "Array.index_usize");
+        (ArrayIndexMut, None, "Array.index_usize");
+        (ArrayIndexMut, rg0, "Array.update_usize");
+        (ArrayToSliceShared, None, "Array.to_slice");
+        (ArrayToSliceMut, None, "Array.to_slice");
+        (ArrayToSliceMut, rg0, "Array.from_slice");
         (ArrayRepeat, None, "Array.repeat");
-        (SliceIndexShared, None, "Slice.index_shared");
-        (SliceIndexMut, None, "Slice.index_mut");
-        (SliceIndexMut, rg0, "Slice.index_mut_back");
+        (SliceIndexShared, None, "Slice.index_usize");
+        (SliceIndexMut, None, "Slice.index_usize");
+        (SliceIndexMut, rg0, "Slice.update_usize");
         (SliceLen, None, "Slice.len");
       ]
 
@@ -941,11 +941,11 @@ let mk_formatter (ctx : trans_ctx) (crate_name : string)
     extract_binop;
   }
 
-let mk_formatter_and_names_map (ctx : trans_ctx) (crate_name : string)
-    (variant_concatenate_type_name : bool) : formatter * names_map =
+let mk_formatter_and_names_maps (ctx : trans_ctx) (crate_name : string)
+    (variant_concatenate_type_name : bool) : formatter * names_maps =
   let fmt = mk_formatter ctx crate_name variant_concatenate_type_name in
-  let names_map = initialize_names_map fmt (names_map_init ()) in
-  (fmt, names_map)
+  let names_maps = initialize_names_maps fmt (names_map_init ()) in
+  (fmt, names_maps)
 
 let is_single_opaque_fun_decl_group (dg : Pure.fun_decl list) : bool =
   match dg with [ d ] -> d.body = None | _ -> false
@@ -1507,8 +1507,8 @@ let extract_type_decl_variant (ctx : extraction_ctx) (fmt : F.formatter)
           | Some field_name ->
               let var_id = VarId.of_int (FieldId.to_int fid) in
               let field_name =
-                ctx.fmt.var_basename ctx.names_map.names_set (Some field_name)
-                  f.field_ty
+                ctx.fmt.var_basename ctx.names_maps.names_map.names_set
+                  (Some field_name) f.field_ty
               in
               let ctx, field_name = ctx_add_var field_name var_id ctx in
               F.pp_print_string fmt (field_name ^ " :");
diff --git a/compiler/Translate.ml b/compiler/Translate.ml
index c5ac4e96..cb23198a 100644
--- a/compiler/Translate.ml
+++ b/compiler/Translate.ml
@@ -990,23 +990,10 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
   in
   (* Initialize the names map (we insert the names of the "primitives"
      declarations, and insert the names of the local declarations later) *)
-  let mk_formatter_and_names_map = Extract.mk_formatter_and_names_map in
-  let fmt, names_map =
-    mk_formatter_and_names_map trans_ctx crate.name
+  let fmt, names_maps =
+    Extract.mk_formatter_and_names_maps trans_ctx crate.name
       variant_concatenate_type_name
   in
-  let strict_names_map =
-    let open ExtractBase in
-    let ids =
-      List.filter
-        (fun (id, _) -> strict_collisions id)
-        (IdMap.bindings names_map.id_to_name)
-    in
-    List.fold_left
-      (* id_to_string: we shouldn't need to use it *)
-        (fun m (id, n) -> names_map_add show_id id n m)
-      empty_names_map ids
-  in
 
   (* We need to compute which functions are recursive, in order to know
    * whether we should generate a decrease clause or not. *)
@@ -1060,9 +1047,7 @@ let translate_crate (filename : string) (dest_dir : string) (crate : A.crate) :
     {
       ExtractBase.crate;
       trans_ctx;
-      names_map;
-      unsafe_names_map = { id_to_name = ExtractBase.IdMap.empty };
-      strict_names_map;
+      names_maps;
       fmt;
       indent_incr = 2;
       use_dep_ite = !Config.backend = Lean && !Config.extract_decreases_clauses;
-- 
cgit v1.3.1


From 1110b3da85e93ba0755a665edd5b8c986c54cef0 Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Thu, 26 Oct 2023 16:15:35 +0200
Subject: Make minor modifications and update the array test for F*

---
 compiler/Driver.ml                           |   4 +-
 compiler/ExtractBase.ml                      |  22 +-
 compiler/ExtractBuiltin.ml                   |   5 +-
 tests/fstar/array/Array.Clauses.Template.fst |   5 +-
 tests/fstar/array/Array.Funs.fst             | 348 ++++++++++++++-------------
 tests/fstar/array/Array.Types.fst            |   4 +-
 6 files changed, 200 insertions(+), 188 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/compiler/Driver.ml b/compiler/Driver.ml
index 3b9ea4d1..b660b5a5 100644
--- a/compiler/Driver.ml
+++ b/compiler/Driver.ml
@@ -162,7 +162,9 @@ let () =
     | FStar ->
         (* Some patterns are not supported *)
         decompose_monadic_let_bindings := false;
-        decompose_nested_let_patterns := false
+        decompose_nested_let_patterns := false;
+        (* F* can disambiguate the field names *)
+        record_fields_short_names := true
     | Coq ->
         (* Some patterns are not supported *)
         decompose_monadic_let_bindings := true;
diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index 8f71116c..6faa40b2 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -1332,22 +1332,20 @@ let default_fun_suffix (num_loops : int) (loop_id : LoopId.id option)
   let rg_suff =
     (* TODO: make all the backends match what is done for Lean *)
     match rg with
-    | None -> (
-        match !Config.backend with
-        | FStar | Coq | HOL4 -> "_fwd"
-        | Lean ->
-            (* In order to avoid name conflicts:
-             * - if the forward is eliminated, we add the suffix "_fwd" (it won't be used)
-             * - otherwise, no suffix (because the backward functions will have a suffix)
-             *)
-            if num_backs = 1 && not keep_fwd then "_fwd" else "")
+    | None ->
+        if
+          (* In order to avoid name conflicts:
+           * - if the forward is eliminated, we add the suffix "_fwd" (it won't be used)
+           * - otherwise, no suffix (because the backward functions will have a suffix)
+           *)
+          num_backs = 1 && not keep_fwd
+        then "_fwd"
+        else ""
     | Some rg ->
         assert (num_region_groups > 0 && num_backs > 0);
         if num_backs = 1 then
           (* Exactly one backward function *)
-          match !Config.backend with
-          | FStar | Coq | HOL4 -> if not keep_fwd then "_fwd_back" else "_back"
-          | Lean -> if not keep_fwd then "" else "_back"
+          if not keep_fwd then "" else "_back"
         else if
           (* Several region groups/backward functions:
              - if all the regions in the group have names, we use those names
diff --git a/compiler/ExtractBuiltin.ml b/compiler/ExtractBuiltin.ml
index 2dbacce3..c6bde9c2 100644
--- a/compiler/ExtractBuiltin.ml
+++ b/compiler/ExtractBuiltin.ml
@@ -149,7 +149,10 @@ let builtin_types () : builtin_type_info list =
           let fields =
             List.map
               (fun (rname, name) ->
-                (rname, backend_choice (extract_name ^ name) name))
+                ( rname,
+                  match !backend with
+                  | FStar | Lean -> name
+                  | Coq | HOL4 -> extract_name ^ "_" ^ name ))
               fields
           in
           let constructor = mk_struct_constructor extract_name in
diff --git a/tests/fstar/array/Array.Clauses.Template.fst b/tests/fstar/array/Array.Clauses.Template.fst
index 8a15e230..06056d61 100644
--- a/tests/fstar/array/Array.Clauses.Template.fst
+++ b/tests/fstar/array/Array.Clauses.Template.fst
@@ -8,11 +8,12 @@ open Array.Types
 
 (** [array::sum]: decreases clause *)
 unfold
-let sum_loop_decreases (s : slice u32) (sum : u32) (i : usize) : nat = admit ()
+let sum_loop_decreases (s : slice u32) (sum0 : u32) (i : usize) : nat =
+  admit ()
 
 (** [array::sum2]: decreases clause *)
 unfold
-let sum2_loop_decreases (s : slice u32) (s2 : slice u32) (sum : u32)
+let sum2_loop_decreases (s : slice u32) (s2 : slice u32) (sum0 : u32)
   (i : usize) : nat =
   admit ()
 
diff --git a/tests/fstar/array/Array.Funs.fst b/tests/fstar/array/Array.Funs.fst
index 83256398..a6808c98 100644
--- a/tests/fstar/array/Array.Funs.fst
+++ b/tests/fstar/array/Array.Funs.fst
@@ -7,361 +7,369 @@ include Array.Clauses
 
 #set-options "--z3rlimit 50 --fuel 1 --ifuel 1"
 
+(** [array::incr]: merged forward/backward function
+    (there is a single backward function, and the forward function returns ()) *)
+let incr (x : u32) : result u32 =
+  u32_add x 1
+
 (** [array::array_to_shared_slice_]: forward function *)
-let array_to_shared_slice__fwd
-  (t : Type0) (s : array t 32) : result (slice t) =
-  array_to_slice_shared t 32 s
+let array_to_shared_slice_ (t : Type0) (s : array t 32) : result (slice t) =
+  array_to_slice t 32 s
 
 (** [array::array_to_mut_slice_]: forward function *)
-let array_to_mut_slice__fwd (t : Type0) (s : array t 32) : result (slice t) =
-  array_to_slice_mut_fwd t 32 s
+let array_to_mut_slice_ (t : Type0) (s : array t 32) : result (slice t) =
+  array_to_slice t 32 s
 
 (** [array::array_to_mut_slice_]: backward function 0 *)
 let array_to_mut_slice__back
   (t : Type0) (s : array t 32) (ret : slice t) : result (array t 32) =
-  array_to_slice_mut_back t 32 s ret
+  array_from_slice t 32 s ret
 
 (** [array::array_len]: forward function *)
-let array_len_fwd (t : Type0) (s : array t 32) : result usize =
-  let* s0 = array_to_slice_shared t 32 s in let i = slice_len t s0 in Return i
+let array_len (t : Type0) (s : array t 32) : result usize =
+  let* s0 = array_to_slice t 32 s in let i = slice_len t s0 in Return i
 
 (** [array::shared_array_len]: forward function *)
-let shared_array_len_fwd (t : Type0) (s : array t 32) : result usize =
-  let* s0 = array_to_slice_shared t 32 s in let i = slice_len t s0 in Return i
+let shared_array_len (t : Type0) (s : array t 32) : result usize =
+  let* s0 = array_to_slice t 32 s in let i = slice_len t s0 in Return i
 
 (** [array::shared_slice_len]: forward function *)
-let shared_slice_len_fwd (t : Type0) (s : slice t) : result usize =
+let shared_slice_len (t : Type0) (s : slice t) : result usize =
   let i = slice_len t s in Return i
 
 (** [array::index_array_shared]: forward function *)
-let index_array_shared_fwd
-  (t : Type0) (s : array t 32) (i : usize) : result t =
-  array_index_shared t 32 s i
+let index_array_shared (t : Type0) (s : array t 32) (i : usize) : result t =
+  array_index_usize t 32 s i
 
 (** [array::index_array_u32]: forward function *)
-let index_array_u32_fwd (s : array u32 32) (i : usize) : result u32 =
-  array_index_shared u32 32 s i
-
-(** [array::index_array_generic]: forward function *)
-let index_array_generic_fwd
-  (n : usize) (s : array u32 n) (i : usize) : result u32 =
-  array_index_shared u32 n s i
-
-(** [array::index_array_generic_call]: forward function *)
-let index_array_generic_call_fwd
-  (n : usize) (s : array u32 n) (i : usize) : result u32 =
-  index_array_generic_fwd n s i
+let index_array_u32 (s : array u32 32) (i : usize) : result u32 =
+  array_index_usize u32 32 s i
 
 (** [array::index_array_copy]: forward function *)
-let index_array_copy_fwd (x : array u32 32) : result u32 =
-  array_index_shared u32 32 x 0
+let index_array_copy (x : array u32 32) : result u32 =
+  array_index_usize u32 32 x 0
 
 (** [array::index_mut_array]: forward function *)
-let index_mut_array_fwd (t : Type0) (s : array t 32) (i : usize) : result t =
-  array_index_mut_fwd t 32 s i
+let index_mut_array (t : Type0) (s : array t 32) (i : usize) : result t =
+  array_index_usize t 32 s i
 
 (** [array::index_mut_array]: backward function 0 *)
 let index_mut_array_back
   (t : Type0) (s : array t 32) (i : usize) (ret : t) : result (array t 32) =
-  array_index_mut_back t 32 s i ret
+  array_update_usize t 32 s i ret
 
 (** [array::index_slice]: forward function *)
-let index_slice_fwd (t : Type0) (s : slice t) (i : usize) : result t =
-  slice_index_shared t s i
+let index_slice (t : Type0) (s : slice t) (i : usize) : result t =
+  slice_index_usize t s i
 
 (** [array::index_mut_slice]: forward function *)
-let index_mut_slice_fwd (t : Type0) (s : slice t) (i : usize) : result t =
-  slice_index_mut_fwd t s i
+let index_mut_slice (t : Type0) (s : slice t) (i : usize) : result t =
+  slice_index_usize t s i
 
 (** [array::index_mut_slice]: backward function 0 *)
 let index_mut_slice_back
   (t : Type0) (s : slice t) (i : usize) (ret : t) : result (slice t) =
-  slice_index_mut_back t s i ret
+  slice_update_usize t s i ret
 
 (** [array::slice_subslice_shared_]: forward function *)
-let slice_subslice_shared__fwd
+let slice_subslice_shared_
   (x : slice u32) (y : usize) (z : usize) : result (slice u32) =
-  slice_subslice_shared u32 x (Mkrange y z)
+  core_slice_index_Slice_index u32 (core_ops_range_Range usize)
+    (core_slice_index_Range_coresliceindexSliceIndexInst u32) x
+    { start = y; end_ = z }
 
 (** [array::slice_subslice_mut_]: forward function *)
-let slice_subslice_mut__fwd
+let slice_subslice_mut_
   (x : slice u32) (y : usize) (z : usize) : result (slice u32) =
-  slice_subslice_mut_fwd u32 x (Mkrange y z)
+  core_slice_index_Slice_index_mut u32 (core_ops_range_Range usize)
+    (core_slice_index_Range_coresliceindexSliceIndexInst u32) x
+    { start = y; end_ = z }
 
 (** [array::slice_subslice_mut_]: backward function 0 *)
 let slice_subslice_mut__back
   (x : slice u32) (y : usize) (z : usize) (ret : slice u32) :
   result (slice u32)
   =
-  slice_subslice_mut_back u32 x (Mkrange y z) ret
+  core_slice_index_Slice_index_mut_back u32 (core_ops_range_Range usize)
+    (core_slice_index_Range_coresliceindexSliceIndexInst u32) x
+    { start = y; end_ = z } ret
 
 (** [array::array_to_slice_shared_]: forward function *)
-let array_to_slice_shared__fwd (x : array u32 32) : result (slice u32) =
-  array_to_slice_shared u32 32 x
+let array_to_slice_shared_ (x : array u32 32) : result (slice u32) =
+  array_to_slice u32 32 x
 
 (** [array::array_to_slice_mut_]: forward function *)
-let array_to_slice_mut__fwd (x : array u32 32) : result (slice u32) =
-  array_to_slice_mut_fwd u32 32 x
+let array_to_slice_mut_ (x : array u32 32) : result (slice u32) =
+  array_to_slice u32 32 x
 
 (** [array::array_to_slice_mut_]: backward function 0 *)
 let array_to_slice_mut__back
   (x : array u32 32) (ret : slice u32) : result (array u32 32) =
-  array_to_slice_mut_back u32 32 x ret
+  array_from_slice u32 32 x ret
 
 (** [array::array_subslice_shared_]: forward function *)
-let array_subslice_shared__fwd
+let array_subslice_shared_
   (x : array u32 32) (y : usize) (z : usize) : result (slice u32) =
-  array_subslice_shared u32 32 x (Mkrange y z)
+  core_array_Array_index u32 (core_ops_range_Range usize) 32
+    (core_slice_index_Slice_coreopsindexIndexInst u32 (core_ops_range_Range
+    usize) (core_slice_index_Range_coresliceindexSliceIndexInst u32)) x
+    { start = y; end_ = z }
 
 (** [array::array_subslice_mut_]: forward function *)
-let array_subslice_mut__fwd
+let array_subslice_mut_
   (x : array u32 32) (y : usize) (z : usize) : result (slice u32) =
-  array_subslice_mut_fwd u32 32 x (Mkrange y z)
+  core_array_Array_index_mut u32 (core_ops_range_Range usize) 32
+    (core_slice_index_Slice_coreopsindexIndexMutInst u32 (core_ops_range_Range
+    usize) (core_slice_index_Range_coresliceindexSliceIndexInst u32)) x
+    { start = y; end_ = z }
 
 (** [array::array_subslice_mut_]: backward function 0 *)
 let array_subslice_mut__back
   (x : array u32 32) (y : usize) (z : usize) (ret : slice u32) :
   result (array u32 32)
   =
-  array_subslice_mut_back u32 32 x (Mkrange y z) ret
+  core_array_Array_index_mut_back u32 (core_ops_range_Range usize) 32
+    (core_slice_index_Slice_coreopsindexIndexMutInst u32 (core_ops_range_Range
+    usize) (core_slice_index_Range_coresliceindexSliceIndexInst u32)) x
+    { start = y; end_ = z } ret
 
 (** [array::index_slice_0]: forward function *)
-let index_slice_0_fwd (t : Type0) (s : slice t) : result t =
-  slice_index_shared t s 0
+let index_slice_0 (t : Type0) (s : slice t) : result t =
+  slice_index_usize t s 0
 
 (** [array::index_array_0]: forward function *)
-let index_array_0_fwd (t : Type0) (s : array t 32) : result t =
-  array_index_shared t 32 s 0
+let index_array_0 (t : Type0) (s : array t 32) : result t =
+  array_index_usize t 32 s 0
 
 (** [array::index_index_array]: forward function *)
-let index_index_array_fwd
+let index_index_array
   (s : array (array u32 32) 32) (i : usize) (j : usize) : result u32 =
-  let* a = array_index_shared (array u32 32) 32 s i in
-  array_index_shared u32 32 a j
-
-(** [array::const_gen_ret]: forward function *)
-let const_gen_ret_fwd (n : usize) : result usize =
-  Return n
+  let* a = array_index_usize (array u32 32) 32 s i in
+  array_index_usize u32 32 a j
 
 (** [array::update_update_array]: forward function *)
-let update_update_array_fwd
+let update_update_array
   (s : array (array u32 32) 32) (i : usize) (j : usize) : result unit =
-  let* a = array_index_mut_fwd (array u32 32) 32 s i in
-  let* a0 = array_index_mut_back u32 32 a j 0 in
-  let* _ = array_index_mut_back (array u32 32) 32 s i a0 in
+  let* a = array_index_usize (array u32 32) 32 s i in
+  let* a0 = array_update_usize u32 32 a j 0 in
+  let* _ = array_update_usize (array u32 32) 32 s i a0 in
   Return ()
 
 (** [array::array_local_deep_copy]: forward function *)
-let array_local_deep_copy_fwd (x : array u32 32) : result unit =
+let array_local_deep_copy (x : array u32 32) : result unit =
   Return ()
 
 (** [array::take_array]: forward function *)
-let take_array_fwd (a : array u32 2) : result unit =
+let take_array (a : array u32 2) : result unit =
   Return ()
 
 (** [array::take_array_borrow]: forward function *)
-let take_array_borrow_fwd (a : array u32 2) : result unit =
+let take_array_borrow (a : array u32 2) : result unit =
   Return ()
 
 (** [array::take_slice]: forward function *)
-let take_slice_fwd (s : slice u32) : result unit =
+let take_slice (s : slice u32) : result unit =
   Return ()
 
 (** [array::take_mut_slice]: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-let take_mut_slice_fwd_back (s : slice u32) : result (slice u32) =
+let take_mut_slice (s : slice u32) : result (slice u32) =
   Return s
 
 (** [array::take_all]: forward function *)
-let take_all_fwd : result unit =
-  let* _ = take_array_fwd (mk_array u32 2 [ 0; 0 ]) in
-  let* _ = take_array_borrow_fwd (mk_array u32 2 [ 0; 0 ]) in
-  let* s = array_to_slice_shared u32 2 (mk_array u32 2 [ 0; 0 ]) in
-  let* _ = take_slice_fwd s in
-  let* s0 = array_to_slice_mut_fwd u32 2 (mk_array u32 2 [ 0; 0 ]) in
-  let* s1 = take_mut_slice_fwd_back s0 in
-  let* _ = array_to_slice_mut_back u32 2 (mk_array u32 2 [ 0; 0 ]) s1 in
+let take_all : result unit =
+  let* _ = take_array (mk_array u32 2 [ 0; 0 ]) in
+  let* _ = take_array_borrow (mk_array u32 2 [ 0; 0 ]) in
+  let* s = array_to_slice u32 2 (mk_array u32 2 [ 0; 0 ]) in
+  let* _ = take_slice s in
+  let* s0 = array_to_slice u32 2 (mk_array u32 2 [ 0; 0 ]) in
+  let* s1 = take_mut_slice s0 in
+  let* _ = array_from_slice u32 2 (mk_array u32 2 [ 0; 0 ]) s1 in
   Return ()
 
 (** [array::index_array]: forward function *)
-let index_array_fwd (x : array u32 2) : result u32 =
-  array_index_shared u32 2 x 0
+let index_array (x : array u32 2) : result u32 =
+  array_index_usize u32 2 x 0
 
 (** [array::index_array_borrow]: forward function *)
-let index_array_borrow_fwd (x : array u32 2) : result u32 =
-  array_index_shared u32 2 x 0
+let index_array_borrow (x : array u32 2) : result u32 =
+  array_index_usize u32 2 x 0
 
 (** [array::index_slice_u32_0]: forward function *)
-let index_slice_u32_0_fwd (x : slice u32) : result u32 =
-  slice_index_shared u32 x 0
+let index_slice_u32_0 (x : slice u32) : result u32 =
+  slice_index_usize u32 x 0
 
 (** [array::index_mut_slice_u32_0]: forward function *)
-let index_mut_slice_u32_0_fwd (x : slice u32) : result u32 =
-  slice_index_shared u32 x 0
+let index_mut_slice_u32_0 (x : slice u32) : result u32 =
+  slice_index_usize u32 x 0
 
 (** [array::index_mut_slice_u32_0]: backward function 0 *)
 let index_mut_slice_u32_0_back (x : slice u32) : result (slice u32) =
-  let* _ = slice_index_shared u32 x 0 in Return x
+  let* _ = slice_index_usize u32 x 0 in Return x
 
 (** [array::index_all]: forward function *)
-let index_all_fwd : result u32 =
-  let* i = index_array_fwd (mk_array u32 2 [ 0; 0 ]) in
-  let* i0 = index_array_fwd (mk_array u32 2 [ 0; 0 ]) in
+let index_all : result u32 =
+  let* i = index_array (mk_array u32 2 [ 0; 0 ]) in
+  let* i0 = index_array (mk_array u32 2 [ 0; 0 ]) in
   let* i1 = u32_add i i0 in
-  let* i2 = index_array_borrow_fwd (mk_array u32 2 [ 0; 0 ]) in
+  let* i2 = index_array_borrow (mk_array u32 2 [ 0; 0 ]) in
   let* i3 = u32_add i1 i2 in
-  let* s = array_to_slice_shared u32 2 (mk_array u32 2 [ 0; 0 ]) in
-  let* i4 = index_slice_u32_0_fwd s in
+  let* s = array_to_slice u32 2 (mk_array u32 2 [ 0; 0 ]) in
+  let* i4 = index_slice_u32_0 s in
   let* i5 = u32_add i3 i4 in
-  let* s0 = array_to_slice_mut_fwd u32 2 (mk_array u32 2 [ 0; 0 ]) in
-  let* i6 = index_mut_slice_u32_0_fwd s0 in
+  let* s0 = array_to_slice u32 2 (mk_array u32 2 [ 0; 0 ]) in
+  let* i6 = index_mut_slice_u32_0 s0 in
   let* i7 = u32_add i5 i6 in
   let* s1 = index_mut_slice_u32_0_back s0 in
-  let* _ = array_to_slice_mut_back u32 2 (mk_array u32 2 [ 0; 0 ]) s1 in
+  let* _ = array_from_slice u32 2 (mk_array u32 2 [ 0; 0 ]) s1 in
   Return i7
 
 (** [array::update_array]: forward function *)
-let update_array_fwd (x : array u32 2) : result unit =
-  let* _ = array_index_mut_back u32 2 x 0 1 in Return ()
+let update_array (x : array u32 2) : result unit =
+  let* _ = array_update_usize u32 2 x 0 1 in Return ()
 
 (** [array::update_array_mut_borrow]: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-let update_array_mut_borrow_fwd_back (x : array u32 2) : result (array u32 2) =
-  array_index_mut_back u32 2 x 0 1
+let update_array_mut_borrow (x : array u32 2) : result (array u32 2) =
+  array_update_usize u32 2 x 0 1
 
 (** [array::update_mut_slice]: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-let update_mut_slice_fwd_back (x : slice u32) : result (slice u32) =
-  slice_index_mut_back u32 x 0 1
+let update_mut_slice (x : slice u32) : result (slice u32) =
+  slice_update_usize u32 x 0 1
 
 (** [array::update_all]: forward function *)
-let update_all_fwd : result unit =
-  let* _ = update_array_fwd (mk_array u32 2 [ 0; 0 ]) in
-  let* x = update_array_mut_borrow_fwd_back (mk_array u32 2 [ 0; 0 ]) in
-  let* s = array_to_slice_mut_fwd u32 2 x in
-  let* s0 = update_mut_slice_fwd_back s in
-  let* _ = array_to_slice_mut_back u32 2 x s0 in
+let update_all : result unit =
+  let* _ = update_array (mk_array u32 2 [ 0; 0 ]) in
+  let* x = update_array_mut_borrow (mk_array u32 2 [ 0; 0 ]) in
+  let* s = array_to_slice u32 2 x in
+  let* s0 = update_mut_slice s in
+  let* _ = array_from_slice u32 2 x s0 in
   Return ()
 
 (** [array::range_all]: forward function *)
-let range_all_fwd : result unit =
+let range_all : result unit =
   let* s =
-    array_subslice_mut_fwd u32 4 (mk_array u32 4 [ 0; 0; 0; 0 ]) (Mkrange 1 3)
-    in
-  let* s0 = update_mut_slice_fwd_back s in
+    core_array_Array_index_mut u32 (core_ops_range_Range usize) 4
+      (core_slice_index_Slice_coreopsindexIndexMutInst u32
+      (core_ops_range_Range usize)
+      (core_slice_index_Range_coresliceindexSliceIndexInst u32))
+      (mk_array u32 4 [ 0; 0; 0; 0 ]) { start = 1; end_ = 3 } in
+  let* s0 = update_mut_slice s in
   let* _ =
-    array_subslice_mut_back u32 4 (mk_array u32 4 [ 0; 0; 0; 0 ]) (Mkrange 1 3)
-      s0 in
+    core_array_Array_index_mut_back u32 (core_ops_range_Range usize) 4
+      (core_slice_index_Slice_coreopsindexIndexMutInst u32
+      (core_ops_range_Range usize)
+      (core_slice_index_Range_coresliceindexSliceIndexInst u32))
+      (mk_array u32 4 [ 0; 0; 0; 0 ]) { start = 1; end_ = 3 } s0 in
   Return ()
 
 (** [array::deref_array_borrow]: forward function *)
-let deref_array_borrow_fwd (x : array u32 2) : result u32 =
-  array_index_shared u32 2 x 0
+let deref_array_borrow (x : array u32 2) : result u32 =
+  array_index_usize u32 2 x 0
 
 (** [array::deref_array_mut_borrow]: forward function *)
-let deref_array_mut_borrow_fwd (x : array u32 2) : result u32 =
-  array_index_shared u32 2 x 0
+let deref_array_mut_borrow (x : array u32 2) : result u32 =
+  array_index_usize u32 2 x 0
 
 (** [array::deref_array_mut_borrow]: backward function 0 *)
 let deref_array_mut_borrow_back (x : array u32 2) : result (array u32 2) =
-  let* _ = array_index_shared u32 2 x 0 in Return x
+  let* _ = array_index_usize u32 2 x 0 in Return x
 
 (** [array::take_array_t]: forward function *)
-let take_array_t_fwd (a : array t_t 2) : result unit =
+let take_array_t (a : array ab_t 2) : result unit =
   Return ()
 
 (** [array::non_copyable_array]: forward function *)
-let non_copyable_array_fwd : result unit =
-  let* _ = take_array_t_fwd (mk_array t_t 2 [ TA; TB ]) in Return ()
+let non_copyable_array : result unit =
+  let* _ = take_array_t (mk_array ab_t 2 [ ABA; ABB ]) in Return ()
 
 (** [array::sum]: loop 0: forward function *)
-let rec sum_loop_fwd
-  (s : slice u32) (sum : u32) (i : usize) :
-  Tot (result u32) (decreases (sum_loop_decreases s sum i))
+let rec sum_loop
+  (s : slice u32) (sum0 : u32) (i : usize) :
+  Tot (result u32) (decreases (sum_loop_decreases s sum0 i))
   =
   let i0 = slice_len u32 s in
   if i < i0
   then
-    let* i1 = slice_index_shared u32 s i in
-    let* sum0 = u32_add sum i1 in
+    let* i1 = slice_index_usize u32 s i in
+    let* sum1 = u32_add sum0 i1 in
     let* i2 = usize_add i 1 in
-    sum_loop_fwd s sum0 i2
-  else Return sum
+    sum_loop s sum1 i2
+  else Return sum0
 
 (** [array::sum]: forward function *)
-let sum_fwd (s : slice u32) : result u32 =
-  sum_loop_fwd s 0 0
+let sum (s : slice u32) : result u32 =
+  sum_loop s 0 0
 
 (** [array::sum2]: loop 0: forward function *)
-let rec sum2_loop_fwd
-  (s : slice u32) (s2 : slice u32) (sum : u32) (i : usize) :
-  Tot (result u32) (decreases (sum2_loop_decreases s s2 sum i))
+let rec sum2_loop
+  (s : slice u32) (s2 : slice u32) (sum0 : u32) (i : usize) :
+  Tot (result u32) (decreases (sum2_loop_decreases s s2 sum0 i))
   =
   let i0 = slice_len u32 s in
   if i < i0
   then
-    let* i1 = slice_index_shared u32 s i in
-    let* i2 = slice_index_shared u32 s2 i in
+    let* i1 = slice_index_usize u32 s i in
+    let* i2 = slice_index_usize u32 s2 i in
     let* i3 = u32_add i1 i2 in
-    let* sum0 = u32_add sum i3 in
+    let* sum1 = u32_add sum0 i3 in
     let* i4 = usize_add i 1 in
-    sum2_loop_fwd s s2 sum0 i4
-  else Return sum
+    sum2_loop s s2 sum1 i4
+  else Return sum0
 
 (** [array::sum2]: forward function *)
-let sum2_fwd (s : slice u32) (s2 : slice u32) : result u32 =
+let sum2 (s : slice u32) (s2 : slice u32) : result u32 =
   let i = slice_len u32 s in
   let i0 = slice_len u32 s2 in
-  if not (i = i0) then Fail Failure else sum2_loop_fwd s s2 0 0
+  if not (i = i0) then Fail Failure else sum2_loop s s2 0 0
 
 (** [array::f0]: forward function *)
-let f0_fwd : result unit =
-  let* s = array_to_slice_mut_fwd u32 2 (mk_array u32 2 [ 1; 2 ]) in
-  let* s0 = slice_index_mut_back u32 s 0 1 in
-  let* _ = array_to_slice_mut_back u32 2 (mk_array u32 2 [ 1; 2 ]) s0 in
+let f0 : result unit =
+  let* s = array_to_slice u32 2 (mk_array u32 2 [ 1; 2 ]) in
+  let* s0 = slice_update_usize u32 s 0 1 in
+  let* _ = array_from_slice u32 2 (mk_array u32 2 [ 1; 2 ]) s0 in
   Return ()
 
 (** [array::f1]: forward function *)
-let f1_fwd : result unit =
-  let* _ = array_index_mut_back u32 2 (mk_array u32 2 [ 1; 2 ]) 0 1 in
-  Return ()
+let f1 : result unit =
+  let* _ = array_update_usize u32 2 (mk_array u32 2 [ 1; 2 ]) 0 1 in Return ()
 
 (** [array::f2]: forward function *)
-let f2_fwd (i : u32) : result unit =
+let f2 (i : u32) : result unit =
   Return ()
 
 (** [array::f4]: forward function *)
-let f4_fwd (x : array u32 32) (y : usize) (z : usize) : result (slice u32) =
-  array_subslice_shared u32 32 x (Mkrange y z)
+let f4 (x : array u32 32) (y : usize) (z : usize) : result (slice u32) =
+  core_array_Array_index u32 (core_ops_range_Range usize) 32
+    (core_slice_index_Slice_coreopsindexIndexInst u32 (core_ops_range_Range
+    usize) (core_slice_index_Range_coresliceindexSliceIndexInst u32)) x
+    { start = y; end_ = z }
 
 (** [array::f3]: forward function *)
-let f3_fwd : result u32 =
-  let* i = array_index_shared u32 2 (mk_array u32 2 [ 1; 2 ]) 0 in
-  let* _ = f2_fwd i in
-  let* s = array_to_slice_shared u32 2 (mk_array u32 2 [ 1; 2 ]) in
-  let* s0 =
-    f4_fwd
-      (mk_array u32 32 [
-        0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0;
-        0; 0; 0; 0; 0; 0; 0; 0
-        ]) 16 18 in
-  sum2_fwd s s0
+let f3 : result u32 =
+  let* i = array_index_usize u32 2 (mk_array u32 2 [ 1; 2 ]) 0 in
+  let* _ = f2 i in
+  let b = array_repeat u32 32 0 in
+  let* s = array_to_slice u32 2 (mk_array u32 2 [ 1; 2 ]) in
+  let* s0 = f4 b 16 18 in
+  sum2 s s0
 
 (** [array::SZ] *)
 let sz_body : result usize = Return 32
 let sz_c : usize = eval_global sz_body
 
 (** [array::f5]: forward function *)
-let f5_fwd (x : array u32 32) : result u32 =
-  array_index_shared u32 32 x 0
+let f5 (x : array u32 32) : result u32 =
+  array_index_usize u32 32 x 0
 
 (** [array::ite]: forward function *)
-let ite_fwd : result unit =
-  let* s = array_to_slice_mut_fwd u32 2 (mk_array u32 2 [ 0; 0 ]) in
-  let* s0 = array_to_slice_mut_fwd u32 2 (mk_array u32 2 [ 0; 0 ]) in
+let ite : result unit =
+  let* s = array_to_slice u32 2 (mk_array u32 2 [ 0; 0 ]) in
+  let* s0 = array_to_slice u32 2 (mk_array u32 2 [ 0; 0 ]) in
   let* s1 = index_mut_slice_u32_0_back s0 in
-  let* _ = array_to_slice_mut_back u32 2 (mk_array u32 2 [ 0; 0 ]) s1 in
+  let* _ = array_from_slice u32 2 (mk_array u32 2 [ 0; 0 ]) s1 in
   let* s2 = index_mut_slice_u32_0_back s in
-  let* _ = array_to_slice_mut_back u32 2 (mk_array u32 2 [ 0; 0 ]) s2 in
+  let* _ = array_from_slice u32 2 (mk_array u32 2 [ 0; 0 ]) s2 in
   Return ()
 
diff --git a/tests/fstar/array/Array.Types.fst b/tests/fstar/array/Array.Types.fst
index 5e8e81d8..0ec9c12f 100644
--- a/tests/fstar/array/Array.Types.fst
+++ b/tests/fstar/array/Array.Types.fst
@@ -5,6 +5,6 @@ open Primitives
 
 #set-options "--z3rlimit 50 --fuel 1 --ifuel 1"
 
-(** [array::T] *)
-type t_t = | TA : t_t | TB : t_t
+(** [array::AB] *)
+type ab_t = | ABA : ab_t | ABB : ab_t
 
-- 
cgit v1.3.1


From b50498d74f8e0b4a5f53468200510edec9d9674a Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Fri, 27 Oct 2023 15:16:20 +0200
Subject: Fix minor issues in the name collision detection

---
 compiler/ExtractBase.ml  | 32 +++++++++++++++++++++++---------
 compiler/ExtractTypes.ml |  1 -
 2 files changed, 23 insertions(+), 10 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index 6faa40b2..8ddb2ec6 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -501,6 +501,15 @@ let names_map_check_collision (id_to_string : id -> string) (id : id)
       (* There is a clash: print a nice debugging message for the user *)
       report_name_collision id_to_string clash id name
 
+(** Insert bindings in a names map without checking for collisions *)
+let names_map_add_unchecked (id : id) (name : string) (nm : names_map) :
+    names_map =
+  (* Insert *)
+  let id_to_name = IdMap.add id name nm.id_to_name in
+  let name_to_id = StringMap.add name id nm.name_to_id in
+  let names_set = StringSet.add name nm.names_set in
+  { id_to_name; name_to_id; names_set }
+
 let names_map_add (id_to_string : id -> string) (id : id) (name : string)
     (nm : names_map) : names_map =
   (* Check if there is a clash *)
@@ -515,10 +524,7 @@ let names_map_add (id_to_string : id -> string) (id : id) (name : string)
     (* If we fail hard on errors, raise an exception *)
     if !Config.extract_fail_hard then raise (Failure err));
   (* Insert *)
-  let id_to_name = IdMap.add id name nm.id_to_name in
-  let name_to_id = StringMap.add name id nm.name_to_id in
-  let names_set = StringSet.add name nm.names_set in
-  { id_to_name; name_to_id; names_set }
+  names_map_add_unchecked id name nm
 
 (** The unsafe names map stores mappings from identifiers to names which might
     collide. For some backends and some names, it might be acceptable to have
@@ -1235,10 +1241,8 @@ let initialize_names_maps (fmt : formatter) (init : names_map_init) : names_maps
         [ fmt.bool_name; fmt.char_name; fmt.str_name ]; int_names; init.keywords;
       ]
   in
-  let names_set = StringSet.of_list keywords in
-  let name_to_id =
-    StringMap.of_list (List.map (fun x -> (x, UnknownId)) keywords)
-  in
+  let names_set = StringSet.empty in
+  let name_to_id = StringMap.empty in
   (* We fist initialize [id_to_name] as empty, because the id of a keyword is [UnknownId].
    * Also note that we don't need this mapping for keywords: we insert keywords only
    * to check collisions. *)
@@ -1246,11 +1250,21 @@ let initialize_names_maps (fmt : formatter) (init : names_map_init) : names_maps
   let names_map = { id_to_name; name_to_id; names_set } in
   let unsafe_names_map = empty_unsafe_names_map in
   let strict_names_map = empty_names_map in
-  let nm = { names_map; unsafe_names_map; strict_names_map } in
   (* For debugging - we are creating bindings for assumed types and functions, so
    * it is ok if we simply use the "show" function (those aren't simply identified
    * by numbers) *)
   let id_to_string = show_id in
+  (* Add the keywords as strict collisions *)
+  let strict_names_map =
+    List.fold_left
+      (fun nm name ->
+        (* There is duplication in the keywords so we don't check the collisions
+           while registering them (what is important is that there are no collisions
+           between keywords and user-defined identifiers) *)
+        names_map_add_unchecked UnknownId name nm)
+      strict_names_map keywords
+  in
+  let nm = { names_map; unsafe_names_map; strict_names_map } in
   (* Then we add:
    * - the assumed types
    * - the assumed struct constructors
diff --git a/compiler/ExtractTypes.ml b/compiler/ExtractTypes.ml
index dcd69f2b..688ed352 100644
--- a/compiler/ExtractTypes.ml
+++ b/compiler/ExtractTypes.ml
@@ -110,7 +110,6 @@ let keywords () =
           "let";
           "list";
           "match";
-          "not";
           "open";
           "rec";
           "scalar_cast";
-- 
cgit v1.3.1


From 9df1d191cfaf929b755e9d26d55811531acd939d Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Thu, 9 Nov 2023 11:21:53 +0100
Subject: Fix a small issue in AssociatedTypes

---
 compiler/AssociatedTypes.ml |  2 +-
 compiler/Config.ml          |  6 +++---
 compiler/Driver.ml          |  8 +++++++-
 compiler/Extract.ml         |  4 ++--
 compiler/ExtractBase.ml     | 12 ++++++------
 compiler/ExtractTypes.ml    |  2 +-
 compiler/Logging.ml         |  2 +-
 7 files changed, 21 insertions(+), 15 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/compiler/AssociatedTypes.ml b/compiler/AssociatedTypes.ml
index e4015903..581e218c 100644
--- a/compiler/AssociatedTypes.ml
+++ b/compiler/AssociatedTypes.ml
@@ -451,7 +451,7 @@ and ctx_normalize_trait_instance_id :
       | None ->
           (* This is actually a local clause *)
           assert (trait_instance_id_is_local_clause inst_id);
-          (ParentClause (inst_id, decl_id, clause_id), None)
+          (ItemClause (inst_id, decl_id, item_name, clause_id), None)
       | Some impl ->
           (* We figure out the item clause by doing the following:
              {[
diff --git a/compiler/Config.ml b/compiler/Config.ml
index cd0903b6..8483c879 100644
--- a/compiler/Config.ml
+++ b/compiler/Config.ml
@@ -333,6 +333,6 @@ let parameterize_trait_types = ref false
  *)
 let type_check_pure_code = ref false
 
-(** Shall we fail hard if there is an issue at code-generation time?
-    We may not want in case outputting a code with holes helps debugging *)
-let extract_fail_hard = ref false
+(** Shall we fail hard if we encounter an issue, or should we attempt to go
+    as far as possible while leaving "holes" in the generated code? *)
+let fail_hard = ref true
diff --git a/compiler/Driver.ml b/compiler/Driver.ml
index b660b5a5..14668632 100644
--- a/compiler/Driver.ml
+++ b/compiler/Driver.ml
@@ -41,7 +41,7 @@ let _ =
   pure_utils_log#set_level EL.Info;
   symbolic_to_pure_log#set_level EL.Info;
   pure_micro_passes_log#set_level EL.Info;
-  pure_to_extract_log#set_level EL.Info;
+  extract_log#set_level EL.Info;
   translate_log#set_level EL.Info;
   scc_log#set_level EL.Info;
   reorder_decls_log#set_level EL.Info
@@ -66,6 +66,9 @@ let () =
   (* Read the command line arguments *)
   let dest_dir = ref "" in
 
+  (* Print the imported llbc *)
+  let print_llbc = ref false in
+
   let spec =
     [
       ( "-backend",
@@ -118,6 +121,8 @@ let () =
       ( "-lean-default-lakefile",
         Arg.Clear lean_gen_lakefile,
         " Generate a default lakefile.lean (Lean only)" );
+      ("-print-llbc", Arg.Set print_llbc, " Print the imported LLBC");
+      ("-k", Arg.Clear fail_hard, " Do not fail hard in case of error");
     ]
   in
 
@@ -131,6 +136,7 @@ let () =
   in
 
   if !extract_template_decreases_clauses then extract_decreases_clauses := true;
+  if !print_llbc then main_log#set_level EL.Debug;
 
   (* Sanity check (now that the arguments are parsed!): -template-clauses ==> decrease-clauses *)
   assert (!extract_decreases_clauses || not !extract_template_decreases_clauses);
diff --git a/compiler/Extract.ml b/compiler/Extract.ml
index 8ad8a18d..b8cb38bb 100644
--- a/compiler/Extract.ml
+++ b/compiler/Extract.ml
@@ -472,7 +472,7 @@ and extract_function_call (ctx : extraction_ctx) (fmt : F.formatter)
       | Error (types, err) ->
           extract_generic_args ctx fmt TypeDeclId.Set.empty
             { generics with types };
-          if !Config.extract_fail_hard then raise (Failure err)
+          if !Config.fail_hard then raise (Failure err)
           else
             F.pp_print_string fmt
               "(\"ERROR: ill-formed builtin: invalid number of filtering \
@@ -1992,7 +1992,7 @@ let extract_trait_decl_method_names (ctx : extraction_ctx)
                         trans_fun.back_id
                   in
                   log#serror err;
-                  if !Config.extract_fail_hard then raise (Failure err)
+                  if !Config.fail_hard then raise (Failure err)
                   else (trans_fun.back_id, "%ERROR_BUILTIN_NAME_NOT_FOUND%")
             in
             let rg_with_name_list = List.map find trans_funs in
diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index 8ddb2ec6..55b1bca3 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -8,7 +8,7 @@ module F = Format
 open ExtractBuiltin
 
 (** The local logger *)
-let log = L.pure_to_extract_log
+let log = L.extract_log
 
 type region_group_info = {
   id : RegionGroupId.id;
@@ -488,7 +488,7 @@ let report_name_collision (id_to_string : id -> string) (id1 : id) (id2 : id)
   in
   log#serror err;
   (* If we fail hard on errors, raise an exception *)
-  if !Config.extract_fail_hard then raise (Failure err)
+  if !Config.fail_hard then raise (Failure err)
 
 let names_map_get_id_from_name (name : string) (nm : names_map) : id option =
   StringMap.find_opt name nm.name_to_id
@@ -522,7 +522,7 @@ let names_map_add (id_to_string : id -> string) (id : id) (name : string)
     in
     log#serror err;
     (* If we fail hard on errors, raise an exception *)
-    if !Config.extract_fail_hard then raise (Failure err));
+    if !Config.fail_hard then raise (Failure err));
   (* Insert *)
   names_map_add_unchecked id name nm
 
@@ -691,7 +691,7 @@ let id_to_string (id : id) (ctx : extraction_ctx) : string =
             | FunId (Assumed aid) -> A.show_assumed_fun_id aid
             | TraitMethod (trait_ref, method_name, _) ->
                 (* Shouldn't happen *)
-                if !Config.extract_fail_hard then raise (Failure "Unexpected")
+                if !Config.fail_hard then raise (Failure "Unexpected")
                 else
                   "Trait method: decl: "
                   ^ TraitDeclId.to_string trait_ref.trait_decl_ref.trait_decl_id
@@ -903,7 +903,7 @@ let names_maps_get (id_to_string : id -> string) (id : id) (nm : names_maps) :
           ^ map_to_string m
         in
         log#serror err;
-        if !Config.extract_fail_hard then raise (Failure err)
+        if !Config.fail_hard then raise (Failure err)
         else "(%%%ERROR: unknown identifier\": " ^ id_to_string id ^ "\"%%%)")
   else
     let m = nm.names_map.id_to_name in
@@ -915,7 +915,7 @@ let names_maps_get (id_to_string : id -> string) (id : id) (nm : names_maps) :
           ^ map_to_string m
         in
         log#serror err;
-        if !Config.extract_fail_hard then raise (Failure err)
+        if !Config.fail_hard then raise (Failure err)
         else "(ERROR: \"" ^ id_to_string id ^ "\")"
 
 let ctx_get (id : id) (ctx : extraction_ctx) : string =
diff --git a/compiler/ExtractTypes.ml b/compiler/ExtractTypes.ml
index 7bd02381..699a0e96 100644
--- a/compiler/ExtractTypes.ml
+++ b/compiler/ExtractTypes.ml
@@ -1374,7 +1374,7 @@ and extract_trait_instance_id (ctx : extraction_ctx) (fmt : F.formatter)
   | Self ->
       (* This has a specific treatment depending on the item we're extracting
          (associated type, etc.). We should have caught this elsewhere. *)
-      if !Config.extract_fail_hard then
+      if !Config.fail_hard then
         raise (Failure "Unexpected occurrence of `Self`")
       else F.pp_print_string fmt "ERROR(\"Unexpected Self\")"
   | TraitImpl id ->
diff --git a/compiler/Logging.ml b/compiler/Logging.ml
index 59abbfc7..721655b8 100644
--- a/compiler/Logging.ml
+++ b/compiler/Logging.ml
@@ -22,7 +22,7 @@ let symbolic_to_pure_log = L.get_logger "MainLogger.SymbolicToPure"
 let pure_micro_passes_log = L.get_logger "MainLogger.PureMicroPasses"
 
 (** Logger for ExtractBase *)
-let pure_to_extract_log = L.get_logger "MainLogger.ExtractBase"
+let extract_log = L.get_logger "MainLogger.ExtractBase"
 
 (** Logger for Interpreter *)
 let interpreter_log = L.get_logger "MainLogger.Interpreter"
-- 
cgit v1.3.1


From 3a22c56e026ee4488bc5e2d16d2066853ae7ccb9 Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Thu, 9 Nov 2023 16:22:09 +0100
Subject: Make the traits work for Coq

---
 Makefile                   |   2 +-
 compiler/Extract.ml        | 391 +++++++++++++++++++++++++++++----------------
 compiler/ExtractBase.ml    |   8 +
 compiler/ExtractBuiltin.ml |  12 +-
 compiler/ExtractTypes.ml   | 106 +++++++-----
 compiler/FunsAnalysis.ml   |   7 +-
 compiler/Translate.ml      |  22 ++-
 7 files changed, 354 insertions(+), 194 deletions(-)

(limited to 'compiler/ExtractBase.ml')

diff --git a/Makefile b/Makefile
index b67bd08b..427a5751 100644
--- a/Makefile
+++ b/Makefile
@@ -134,7 +134,7 @@ thol4-array: OPTIONS +=
 test-traits: OPTIONS +=
 test-traits: SUBDIR := traits
 tfstar-traits: OPTIONS += -decreases-clauses -template-clauses
-tcoq-traits: OPTIONS += -use-fuel
+tcoq-traits: OPTIONS +=
 tlean-traits: SUBDIR :=
 tlean-traits: OPTIONS +=
 thol4-traits: OPTIONS +=
diff --git a/compiler/Extract.ml b/compiler/Extract.ml
index e22f1385..d04f5c1d 100644
--- a/compiler/Extract.ml
+++ b/compiler/Extract.ml
@@ -320,8 +320,11 @@ and extract_App (ctx : extraction_ctx) (fmt : F.formatter) (inside : bool)
             ctx_get_trait_const trait_ref.trait_decl_ref.trait_decl_id
               const_name ctx
           in
+          let add_brackets (s : string) =
+            if !backend = Coq then "(" ^ s ^ ")" else s
+          in
           if use_brackets then F.pp_print_string fmt ")";
-          F.pp_print_string fmt ("." ^ name))
+          F.pp_print_string fmt ("." ^ add_brackets name))
   | _ ->
       (* "Regular" expression *)
       (* Open parentheses *)
@@ -430,7 +433,10 @@ and extract_function_call (ctx : extraction_ctx) (fmt : F.formatter)
               ctx_get_trait_method trait_ref.trait_decl_ref.trait_decl_id
                 method_name rg_id ctx
             in
-            F.pp_print_string fmt ("." ^ fun_name))
+            let add_brackets (s : string) =
+              if !backend = Coq then "(" ^ s ^ ")" else s
+            in
+            F.pp_print_string fmt ("." ^ add_brackets fun_name))
           else
             (* Provided method: we see it as a regular function call, and use
                the function name *)
@@ -2021,12 +2027,15 @@ let extract_trait_decl_register_names (ctx : extraction_ctx)
     SimpleNameMap.find_opt sname (builtin_trait_decls_map ())
   in
   let ctx =
-    let trait_name =
+    let trait_name, trait_constructor =
       match builtin_info with
-      | None -> ctx.fmt.trait_decl_name trait_decl
-      | Some info -> info.extract_name
+      | None ->
+          ( ctx.fmt.trait_decl_name trait_decl,
+            ctx.fmt.trait_decl_constructor trait_decl )
+      | Some info -> (info.extract_name, info.constructor)
     in
-    ctx_add (TraitDeclId trait_decl.def_id) trait_name ctx
+    let ctx = ctx_add (TraitDeclId trait_decl.def_id) trait_name ctx in
+    ctx_add (TraitDeclConstructorId trait_decl.def_id) trait_constructor ctx
   in
   (* Parent clauses *)
   let ctx =
@@ -2108,7 +2117,7 @@ let extract_trait_decl_item (ctx : extraction_ctx) (fmt : F.formatter)
 
 let extract_trait_impl_item (ctx : extraction_ctx) (fmt : F.formatter)
     (item_name : string) (ty : unit -> unit) : unit =
-  let assign = match !Config.backend with Lean -> ":=" | _ -> "=" in
+  let assign = match !Config.backend with Lean | Coq -> ":=" | _ -> "=" in
   extract_trait_item ctx fmt item_name assign ty
 
 (** Small helper - TODO: move *)
@@ -2215,87 +2224,173 @@ let extract_trait_decl (ctx : extraction_ctx) (fmt : F.formatter)
     cg_params trait_clauses;
 
   F.pp_print_space fmt ();
-  (match !backend with
-  | Lean -> F.pp_print_string fmt "where"
-  | FStar -> if not is_empty then F.pp_print_string fmt "= {"
-  | _ -> F.pp_print_string fmt "{");
-  if !backend = FStar && is_empty then F.pp_print_string fmt "= unit";
+  if is_empty && !backend = FStar then (
+    F.pp_print_string fmt "= unit";
+    (* Outer box *)
+    F.pp_close_box fmt ())
+  else if is_empty && !backend = Coq then (
+    (* Coq is not very good at infering constructors *)
+    let cons = ctx_get_trait_constructor decl.def_id ctx in
+    F.pp_print_string fmt (":= " ^ cons ^ "{}.");
+    (* Outer box *)
+    F.pp_close_box fmt ())
+  else (
+    (match !backend with
+    | Lean -> F.pp_print_string fmt "where"
+    | FStar -> F.pp_print_string fmt "= {"
+    | Coq ->
+        let cons = ctx_get_trait_constructor decl.def_id ctx in
+        F.pp_print_string fmt (":= " ^ cons ^ " {")
+    | _ -> F.pp_print_string fmt "{");
 
-  (* Close the box for the name + generics *)
-  F.pp_close_box fmt ();
+    (* Close the box for the name + generics *)
+    F.pp_close_box fmt ();
 
-  (*
-   * Extract the items
-   *)
+    (*
+     * Extract the items
+     *)
 
-  (* The constants *)
-  List.iter
-    (fun (name, (ty, _)) ->
-      let item_name = ctx_get_trait_const decl.def_id name ctx in
-      let ty () =
-        let inside = false in
-        F.pp_print_space fmt ();
-        extract_ty ctx fmt TypeDeclId.Set.empty inside ty
-      in
-      extract_trait_decl_item ctx fmt item_name ty)
-    decl.consts;
+    (* The constants *)
+    List.iter
+      (fun (name, (ty, _)) ->
+        let item_name = ctx_get_trait_const decl.def_id name ctx in
+        let ty () =
+          let inside = false in
+          F.pp_print_space fmt ();
+          extract_ty ctx fmt TypeDeclId.Set.empty inside ty
+        in
+        extract_trait_decl_item ctx fmt item_name ty)
+      decl.consts;
 
-  (* The types *)
-  List.iter
-    (fun (name, (clauses, _)) ->
-      (* Extract the type *)
-      let item_name = ctx_get_trait_type decl.def_id name ctx in
-      let ty () =
-        F.pp_print_space fmt ();
-        F.pp_print_string fmt (type_keyword ())
-      in
-      extract_trait_decl_item ctx fmt item_name ty;
-      (* Extract the clauses *)
-      List.iter
-        (fun clause ->
-          let item_name =
-            ctx_get_trait_item_clause decl.def_id name clause.clause_id ctx
-          in
-          let ty () =
-            F.pp_print_space fmt ();
-            extract_trait_clause_type ctx fmt TypeDeclId.Set.empty clause
-          in
-          extract_trait_decl_item ctx fmt item_name ty)
-        clauses)
-    decl.types;
+    (* The types *)
+    List.iter
+      (fun (name, (clauses, _)) ->
+        (* Extract the type *)
+        let item_name = ctx_get_trait_type decl.def_id name ctx in
+        let ty () =
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt (type_keyword ())
+        in
+        extract_trait_decl_item ctx fmt item_name ty;
+        (* Extract the clauses *)
+        List.iter
+          (fun clause ->
+            let item_name =
+              ctx_get_trait_item_clause decl.def_id name clause.clause_id ctx
+            in
+            let ty () =
+              F.pp_print_space fmt ();
+              extract_trait_clause_type ctx fmt TypeDeclId.Set.empty clause
+            in
+            extract_trait_decl_item ctx fmt item_name ty)
+          clauses)
+      decl.types;
 
-  (* The parent clauses - note that the parent clauses may refer to the types
-     and const generics: for this reason we extract them *after* *)
-  List.iter
-    (fun clause ->
-      let item_name =
-        ctx_get_trait_parent_clause decl.def_id clause.clause_id ctx
-      in
-      let ty () =
-        F.pp_print_space fmt ();
-        extract_trait_clause_type ctx fmt TypeDeclId.Set.empty clause
-      in
-      extract_trait_decl_item ctx fmt item_name ty)
-    decl.parent_clauses;
+    (* The parent clauses - note that the parent clauses may refer to the types
+       and const generics: for this reason we extract them *after* *)
+    List.iter
+      (fun clause ->
+        let item_name =
+          ctx_get_trait_parent_clause decl.def_id clause.clause_id ctx
+        in
+        let ty () =
+          F.pp_print_space fmt ();
+          extract_trait_clause_type ctx fmt TypeDeclId.Set.empty clause
+        in
+        extract_trait_decl_item ctx fmt item_name ty)
+      decl.parent_clauses;
 
-  (* The required methods *)
-  List.iter
-    (fun (name, id) -> extract_trait_decl_method_items ctx fmt decl name id)
-    decl.required_methods;
-
-  (* Close the outer boxes for the definition *)
-  if !Config.backend <> Lean then F.pp_close_box fmt ();
-  (* Close the brackets *)
-  (match !Config.backend with
-  | Lean -> ()
-  | _ ->
-      if (not (!backend = FStar)) || not is_empty then (
+    (* The required methods *)
+    List.iter
+      (fun (name, id) -> extract_trait_decl_method_items ctx fmt decl name id)
+      decl.required_methods;
+
+    (* Close the outer boxes for the definition *)
+    if !Config.backend <> Lean then F.pp_close_box fmt ();
+    (* Close the brackets *)
+    match !Config.backend with
+    | Lean -> ()
+    | Coq ->
+        F.pp_print_space fmt ();
+        F.pp_print_string fmt "}."
+    | _ ->
         F.pp_print_space fmt ();
-        F.pp_print_string fmt "}"));
+        F.pp_print_string fmt "}");
   F.pp_close_box fmt ();
   (* Add breaks to insert new lines between definitions *)
   F.pp_print_break fmt 0 0
 
+(** Generate the [Arguments] instructions for the trait declarationsin Coq, so
+    that we don't have to provide the implicit arguments when projecting the fields. *)
+let extract_trait_decl_coq_arguments (ctx : extraction_ctx) (fmt : F.formatter)
+    (decl : trait_decl) : unit =
+  (* Generating the [Arguments] instructions is useful only if there are parameters *)
+  let num_params =
+    List.length decl.generics.types
+    + List.length decl.generics.const_generics
+    + List.length decl.generics.trait_clauses
+  in
+  if num_params > 0 then (
+    (* The constructor *)
+    let cons_name = ctx_get_trait_constructor decl.def_id ctx in
+    extract_coq_arguments_instruction ctx fmt cons_name num_params;
+    (* The constants *)
+    List.iter
+      (fun (name, _) ->
+        let item_name = ctx_get_trait_const decl.def_id name ctx in
+        extract_coq_arguments_instruction ctx fmt item_name num_params)
+      decl.consts;
+    (* The types *)
+    List.iter
+      (fun (name, (clauses, _)) ->
+        (* The type *)
+        let item_name = ctx_get_trait_type decl.def_id name ctx in
+        extract_coq_arguments_instruction ctx fmt item_name num_params;
+        (* The type clauses *)
+        List.iter
+          (fun clause ->
+            let item_name =
+              ctx_get_trait_item_clause decl.def_id name clause.clause_id ctx
+            in
+            extract_coq_arguments_instruction ctx fmt item_name num_params)
+          clauses)
+      decl.types;
+    (* The parent clauses *)
+    List.iter
+      (fun clause ->
+        let item_name =
+          ctx_get_trait_parent_clause decl.def_id clause.clause_id ctx
+        in
+        extract_coq_arguments_instruction ctx fmt item_name num_params)
+      decl.parent_clauses;
+    (* The required methods *)
+    List.iter
+      (fun (item_name, id) ->
+        (* Lookup the definition *)
+        let trans = A.FunDeclId.Map.find id ctx.trans_funs in
+        (* Extract the items *)
+        let funs =
+          if trans.keep_fwd then trans.fwd :: trans.backs else trans.backs
+        in
+        let extract_for_method (f : fun_and_loops) =
+          let f = f.f in
+          let item_name =
+            ctx_get_trait_method decl.def_id item_name f.back_id ctx
+          in
+          extract_coq_arguments_instruction ctx fmt item_name num_params
+        in
+        List.iter extract_for_method funs)
+      decl.required_methods;
+    (* Add a space *)
+    F.pp_print_space fmt ())
+
+(** See {!extract_trait_decl_coq_arguments} *)
+let extract_trait_decl_extra_info (ctx : extraction_ctx) (fmt : F.formatter)
+    (trait_decl : trait_decl) : unit =
+  match !backend with
+  | Coq -> extract_trait_decl_coq_arguments ctx fmt trait_decl
+  | _ -> ()
+
 (** Small helper.
 
     Extract the items for a method in a trait impl.
@@ -2425,76 +2520,92 @@ let extract_trait_impl (ctx : extraction_ctx) (fmt : F.formatter)
   let is_empty = trait_impl_is_empty { impl with provided_methods = [] } in
 
   F.pp_print_space fmt ();
-  if !Config.backend = Lean then F.pp_print_string fmt ":= {"
-  else if !Config.backend = FStar && is_empty then F.pp_print_string fmt "= ()"
-  else F.pp_print_string fmt "= {";
+  if is_empty && !Config.backend = FStar then (
+    F.pp_print_string fmt "= ()";
+    (* Outer box *)
+    F.pp_close_box fmt ())
+  else if is_empty && !Config.backend = Coq then (
+    (* Coq is not very good at infering constructors *)
+    let cons = ctx_get_trait_constructor impl.impl_trait.trait_decl_id ctx in
+    F.pp_print_string fmt (":= " ^ cons ^ ".");
+    (* Outer box *)
+    F.pp_close_box fmt ())
+  else (
+    if !Config.backend = Lean then F.pp_print_string fmt ":= {"
+    else if !Config.backend = Coq then F.pp_print_string fmt ":= {|"
+    else F.pp_print_string fmt "= {";
 
-  (* Close the box for the name + generics *)
-  F.pp_close_box fmt ();
+    (* Close the box for the name + generics *)
+    F.pp_close_box fmt ();
 
-  (*
-   * Extract the items
-   *)
-  let trait_decl_id = impl.impl_trait.trait_decl_id in
+    (*
+     * Extract the items
+     *)
+    let trait_decl_id = impl.impl_trait.trait_decl_id in
 
-  (* The constants *)
-  List.iter
-    (fun (name, (_, id)) ->
-      let item_name = ctx_get_trait_const trait_decl_id name ctx in
-      let ty () =
-        F.pp_print_space fmt ();
-        F.pp_print_string fmt (ctx_get_global id ctx)
-      in
+    (* The constants *)
+    List.iter
+      (fun (name, (_, id)) ->
+        let item_name = ctx_get_trait_const trait_decl_id name ctx in
+        let ty () =
+          F.pp_print_space fmt ();
+          F.pp_print_string fmt (ctx_get_global id ctx)
+        in
 
-      extract_trait_impl_item ctx fmt item_name ty)
-    impl.consts;
+        extract_trait_impl_item ctx fmt item_name ty)
+      impl.consts;
 
-  (* The types *)
-  List.iter
-    (fun (name, (trait_refs, ty)) ->
-      (* Extract the type *)
-      let item_name = ctx_get_trait_type trait_decl_id name ctx in
-      let ty () =
-        F.pp_print_space fmt ();
-        extract_ty ctx fmt TypeDeclId.Set.empty false ty
-      in
-      extract_trait_impl_item ctx fmt item_name ty;
-      (* Extract the clauses *)
-      TraitClauseId.iteri
-        (fun clause_id trait_ref ->
-          let item_name =
-            ctx_get_trait_item_clause trait_decl_id name clause_id ctx
-          in
-          let ty () =
-            F.pp_print_space fmt ();
-            extract_trait_ref ctx fmt TypeDeclId.Set.empty false trait_ref
-          in
-          extract_trait_impl_item ctx fmt item_name ty)
-        trait_refs)
-    impl.types;
-
-  (* The parent clauses *)
-  TraitClauseId.iteri
-    (fun clause_id trait_ref ->
-      let item_name = ctx_get_trait_parent_clause trait_decl_id clause_id ctx in
-      let ty () =
-        F.pp_print_space fmt ();
-        extract_trait_ref ctx fmt TypeDeclId.Set.empty false trait_ref
-      in
-      extract_trait_impl_item ctx fmt item_name ty)
-    impl.parent_trait_refs;
+    (* The types *)
+    List.iter
+      (fun (name, (trait_refs, ty)) ->
+        (* Extract the type *)
+        let item_name = ctx_get_trait_type trait_decl_id name ctx in
+        let ty () =
+          F.pp_print_space fmt ();
+          extract_ty ctx fmt TypeDeclId.Set.empty false ty
+        in
+        extract_trait_impl_item ctx fmt item_name ty;
+        (* Extract the clauses *)
+        TraitClauseId.iteri
+          (fun clause_id trait_ref ->
+            let item_name =
+              ctx_get_trait_item_clause trait_decl_id name clause_id ctx
+            in
+            let ty () =
+              F.pp_print_space fmt ();
+              extract_trait_ref ctx fmt TypeDeclId.Set.empty false trait_ref
+            in
+            extract_trait_impl_item ctx fmt item_name ty)
+          trait_refs)
+      impl.types;
+
+    (* The parent clauses *)
+    TraitClauseId.iteri
+      (fun clause_id trait_ref ->
+        let item_name =
+          ctx_get_trait_parent_clause trait_decl_id clause_id ctx
+        in
+        let ty () =
+          F.pp_print_space fmt ();
+          extract_trait_ref ctx fmt TypeDeclId.Set.empty false trait_ref
+        in
+        extract_trait_impl_item ctx fmt item_name ty)
+      impl.parent_trait_refs;
 
-  (* The required methods *)
-  List.iter
-    (fun (name, id) ->
-      extract_trait_impl_method_items ctx fmt impl name id all_generics)
-    impl.required_methods;
+    (* The required methods *)
+    List.iter
+      (fun (name, id) ->
+        extract_trait_impl_method_items ctx fmt impl name id all_generics)
+      impl.required_methods;
 
-  (* Close the outer boxes for the definition, as well as the brackets *)
-  F.pp_close_box fmt ();
-  if (not (!backend = FStar)) || not is_empty then (
-    F.pp_print_space fmt ();
-    F.pp_print_string fmt "}");
+    (* Close the outer boxes for the definition, as well as the brackets *)
+    F.pp_close_box fmt ();
+    if !backend = Coq then (
+      F.pp_print_space fmt ();
+      F.pp_print_string fmt "|}.")
+    else if (not (!backend = FStar)) || not is_empty then (
+      F.pp_print_space fmt ();
+      F.pp_print_string fmt "}"));
   F.pp_close_box fmt ();
   (* Add breaks to insert new lines between definitions *)
   F.pp_print_break fmt 0 0
diff --git a/compiler/ExtractBase.ml b/compiler/ExtractBase.ml
index 55b1bca3..31b1a447 100644
--- a/compiler/ExtractBase.ml
+++ b/compiler/ExtractBase.ml
@@ -246,6 +246,7 @@ type formatter = {
        *)
   trait_decl_name : trait_decl -> string;
   trait_impl_name : trait_decl -> trait_impl -> string;
+  trait_decl_constructor : trait_decl -> string;
   trait_parent_clause_name : trait_decl -> trait_clause -> string;
   trait_const_name : trait_decl -> string -> string;
   trait_type_name : trait_decl -> string -> string;
@@ -388,6 +389,7 @@ type id =
   | TraitDeclId of TraitDeclId.id
   | TraitImplId of TraitImplId.id
   | LocalTraitClauseId of TraitClauseId.id
+  | TraitDeclConstructorId of TraitDeclId.id
   | TraitMethodId of TraitDeclId.id * string * T.RegionGroupId.id option
       (** Something peculiar with trait methods: because we have to take into
           account forward/backward functions, we may need to generate fields
@@ -801,6 +803,8 @@ let id_to_string (id : id) (ctx : extraction_ctx) : string =
   | TraitImplId id -> "trait_impl_id: " ^ TraitImplId.to_string id
   | LocalTraitClauseId id ->
       "local_trait_clause_id: " ^ TraitClauseId.to_string id
+  | TraitDeclConstructorId id ->
+      "trait_decl_constructor: " ^ trait_decl_id_to_string id
   | TraitParentClauseId (id, clause_id) ->
       "trait_parent_clause_id: " ^ trait_decl_id_to_string id ^ ", clause_id: "
       ^ TraitClauseId.to_string clause_id
@@ -959,6 +963,10 @@ let ctx_get_local_type (id : TypeDeclId.id) (ctx : extraction_ctx) : string =
 let ctx_get_assumed_type (id : assumed_ty) (ctx : extraction_ctx) : string =
   ctx_get_type (Assumed id) ctx
 
+let ctx_get_trait_constructor (id : trait_decl_id) (ctx : extraction_ctx) :
+    string =
+  ctx_get (TraitDeclConstructorId id) ctx
+
 let ctx_get_trait_self_clause (ctx : extraction_ctx) : string =
   ctx_get TraitSelfClauseId ctx
 
diff --git a/compiler/ExtractBuiltin.ml b/compiler/ExtractBuiltin.ml
index c6bde9c2..a54ab604 100644
--- a/compiler/ExtractBuiltin.ml
+++ b/compiler/ExtractBuiltin.ml
@@ -420,6 +420,7 @@ let builtin_fun_effects_map =
 type builtin_trait_decl_info = {
   rust_name : string;
   extract_name : string;
+  constructor : string;
   parent_clauses : string list;
   consts : (string * string) list;
   types : (string * (string * string list)) list;
@@ -444,6 +445,7 @@ let builtin_trait_decls_info () =
           | Coq | FStar | HOL4 -> String.concat "_" rust_name
           | Lean -> String.concat "." rust_name)
     in
+    let constructor = mk_struct_constructor extract_name in
     let consts = [] in
     let types =
       let mk_type item_name =
@@ -479,7 +481,15 @@ let builtin_trait_decls_info () =
       List.map mk_method methods
     in
     let rust_name = String.concat "::" rust_name in
-    { rust_name; extract_name; parent_clauses; consts; types; methods }
+    {
+      rust_name;
+      extract_name;
+      constructor;
+      parent_clauses;
+      consts;
+      types;
+      methods;
+    }
   in
   [
     (* Deref *)
diff --git a/compiler/ExtractTypes.ml b/compiler/ExtractTypes.ml
index a294d4ca..77f76bb4 100644
--- a/compiler/ExtractTypes.ml
+++ b/compiler/ExtractTypes.ml
@@ -697,6 +697,11 @@ let mk_formatter (ctx : trans_ctx) (crate_name : string)
     | Coq | HOL4 | Lean -> name
   in
 
+  let trait_decl_constructor (trait_decl : trait_decl) : string =
+    let name = trait_decl_name trait_decl in
+    ExtractBuiltin.mk_struct_constructor name
+  in
+
   let trait_parent_clause_name (trait_decl : trait_decl) (clause : trait_clause)
       : string =
     (* TODO: improve - it would be better to not use indices *)
@@ -937,6 +942,7 @@ let mk_formatter (ctx : trans_ctx) (crate_name : string)
     decreases_proof_name;
     trait_decl_name;
     trait_impl_name;
+    trait_decl_constructor;
     trait_parent_clause_name;
     trait_const_name;
     trait_type_name;
@@ -1254,6 +1260,9 @@ let rec extract_ty (ctx : extraction_ctx) (fmt : F.formatter)
           ctx_get_trait_type trait_ref.trait_decl_ref.trait_decl_id type_name
             ctx
         in
+        let add_brackets (s : string) =
+          if !backend = Coq then "(" ^ s ^ ")" else s
+        in
         (* There may be a special treatment depending on the instance id.
            See the comments for {!extract_trait_instance_id_with_dot}.
            TODO: there should be a cleaner way to do. The annoying thing
@@ -1276,7 +1285,7 @@ let rec extract_ty (ctx : extraction_ctx) (fmt : F.formatter)
             extract_trait_ref ctx fmt no_params_tys false trait_ref;
             extract_generic_args ctx fmt no_params_tys generics;
             if use_brackets then F.pp_print_string fmt ")";
-            F.pp_print_string fmt ("." ^ type_name))
+            F.pp_print_string fmt ("." ^ add_brackets type_name))
 
 and extract_trait_ref (ctx : extraction_ctx) (fmt : F.formatter)
     (no_params_tys : TypeDeclId.Set.t) (inside : bool) (tr : trait_ref) : unit =
@@ -1376,6 +1385,7 @@ and extract_trait_instance_id_with_dot (ctx : extraction_ctx)
 and extract_trait_instance_id (ctx : extraction_ctx) (fmt : F.formatter)
     (no_params_tys : TypeDeclId.Set.t) (inside : bool) (id : trait_instance_id)
     : unit =
+  let add_brackets (s : string) = if !backend = Coq then "(" ^ s ^ ")" else s in
   match id with
   | Self ->
       (* This has a specific treatment depending on the item we're extracting
@@ -1393,12 +1403,12 @@ and extract_trait_instance_id (ctx : extraction_ctx) (fmt : F.formatter)
       (* Use the trait decl id to lookup the name *)
       let name = ctx_get_trait_parent_clause decl_id clause_id ctx in
       extract_trait_instance_id_with_dot ctx fmt no_params_tys true inst_id;
-      F.pp_print_string fmt name
+      F.pp_print_string fmt (add_brackets name)
   | ItemClause (inst_id, decl_id, item_name, clause_id) ->
       (* Use the trait decl id to lookup the name *)
       let name = ctx_get_trait_item_clause decl_id item_name clause_id ctx in
       extract_trait_instance_id_with_dot ctx fmt no_params_tys true inst_id;
-      F.pp_print_string fmt name
+      F.pp_print_string fmt (add_brackets name)
   | TraitRef trait_ref ->
       extract_trait_ref ctx fmt no_params_tys inside trait_ref
   | UnknownTrait _ ->
@@ -2156,49 +2166,59 @@ let extract_type_decl (ctx : extraction_ctx) (fmt : F.formatter)
         extract_type_decl_gen ctx fmt type_decl_group kind def extract_body
     | HOL4 -> extract_type_decl_hol4_opaque ctx fmt def
 
+(** Generate a [Argument] instruction in Coq to allow omitting implicit
+    arguments for variants, fields, etc..
+
+    For instance, provided we have this definition:
+    {[
+      Inductive result A :=
+      | Return : A -> result A
+      | Fail_ : error -> result A.
+    ]}
+
+    We may want to generate those instructions:
+    {[
+      Arguments Return {_} a.
+      Arguments Fail_ {_}.
+    ]}
+ *)
+let extract_coq_arguments_instruction (ctx : extraction_ctx) (fmt : F.formatter)
+    (cons_name : string) (num_implicit_params : int) : unit =
+  (* Add a break before *)
+  F.pp_print_break fmt 0 0;
+  (* Open a box *)
+  F.pp_open_hovbox fmt ctx.indent_incr;
+  F.pp_print_break fmt 0 0;
+  F.pp_print_string fmt "Arguments";
+  F.pp_print_space fmt ();
+  F.pp_print_string fmt cons_name;
+  (* Print the type/const params and the trait clauses (`{T}`) *)
+  F.pp_print_space fmt ();
+  F.pp_print_string fmt "{";
+  Collections.List.iter_times num_implicit_params (fun () ->
+      F.pp_print_space fmt ();
+      F.pp_print_string fmt "_");
+  F.pp_print_space fmt ();
+  F.pp_print_string fmt "}.";
+
+  (* Close the box *)
+  F.pp_close_box fmt ()
+
 (** Auxiliary function.
 
-    Generate [Arguments] instructions in Coq.
+    Generate [Arguments] instructions in Coq for type definitions.
  *)
 let extract_type_decl_coq_arguments (ctx : extraction_ctx) (fmt : F.formatter)
     (kind : decl_kind) (decl : type_decl) : unit =
   assert (!backend = Coq);
-  (* Generating the [Arguments] instructions is useful only if there are type parameters *)
-  if decl.generics.types = [] && decl.generics.const_generics = [] then ()
+  (* Generating the [Arguments] instructions is useful only if there are parameters *)
+  let num_params =
+    List.length decl.generics.types
+    + List.length decl.generics.const_generics
+    + List.length decl.generics.trait_clauses
+  in
+  if num_params = 0 then ()
   else
-    (* Add the type params - note that we need those bindings only for the
-     * body translation (they are not top-level) *)
-    let _ctx_body, type_params, cg_params, trait_clauses =
-      ctx_add_generic_params decl.generics ctx
-    in
-    (* Auxiliary function to extract an [Arguments Cons {T} _ _.] instruction *)
-    let extract_arguments_info (cons_name : string) (fields : 'a list) : unit =
-      (* Add a break before *)
-      F.pp_print_break fmt 0 0;
-      (* Open a box *)
-      F.pp_open_hovbox fmt ctx.indent_incr;
-      F.pp_print_break fmt 0 0;
-      F.pp_print_string fmt "Arguments";
-      F.pp_print_space fmt ();
-      F.pp_print_string fmt cons_name;
-      (* Print the type/const params and the trait clauses (`{T}`) *)
-      List.iter
-        (fun (var : string) ->
-          F.pp_print_space fmt ();
-          F.pp_print_string fmt ("{" ^ var ^ "}"))
-        (List.concat [ type_params; cg_params; trait_clauses ]);
-      (* Print the fields (`_`) *)
-      List.iter
-        (fun _ ->
-          F.pp_print_space fmt ();
-          F.pp_print_string fmt "_")
-        fields;
-      F.pp_print_string fmt ".";
-
-      (* Close the box *)
-      F.pp_close_box fmt ()
-    in
-
     (* Generate the [Arguments] instruction *)
     match decl.kind with
     | Opaque -> ()
@@ -2206,23 +2226,23 @@ let extract_type_decl_coq_arguments (ctx : extraction_ctx) (fmt : F.formatter)
         let adt_id = AdtId decl.def_id in
         (* Generate the instruction for the record constructor *)
         let cons_name = ctx_get_struct adt_id ctx in
-        extract_arguments_info cons_name fields;
+        extract_coq_arguments_instruction ctx fmt cons_name num_params;
         (* Generate the instruction for the record projectors, if there are *)
         let is_rec = decl_is_from_rec_group kind in
         if not is_rec then
           FieldId.iteri
             (fun fid _ ->
               let cons_name = ctx_get_field adt_id fid ctx in
-              extract_arguments_info cons_name [])
+              extract_coq_arguments_instruction ctx fmt cons_name num_params)
             fields;
         (* Add breaks to insert new lines between definitions *)
         F.pp_print_break fmt 0 0
     | Enum variants ->
         (* Generate the instructions *)
         VariantId.iteri
-          (fun vid (v : variant) ->
+          (fun vid (_ : variant) ->
             let cons_name = ctx_get_variant (AdtId decl.def_id) vid ctx in
-            extract_arguments_info cons_name v.fields)
+            extract_coq_arguments_instruction ctx fmt cons_name num_params)
           variants;
         (* Add breaks to insert new lines between definitions *)
         F.pp_print_break fmt 0 0
diff --git a/compiler/FunsAnalysis.ml b/compiler/FunsAnalysis.ml
index 69c0df71..e17ea16f 100644
--- a/compiler/FunsAnalysis.ml
+++ b/compiler/FunsAnalysis.ml
@@ -104,9 +104,10 @@ let analyze_module (m : crate) (funs_map : fun_decl FunDeclId.Map.t)
                 (* None of the assumed functions can diverge nor are considered stateful *)
                 can_fail := !can_fail || Assumed.assumed_fun_can_fail id
             | TraitMethod _ ->
-                (* We consider trait functions can fail, diverge, and are not stateful *)
-                can_fail := true;
-                can_diverge := true);
+                (* We consider trait functions can fail, but can not diverge and are not stateful.
+                   TODO: this may cause issues if we use use a fuel parameter.
+                *)
+                can_fail := true);
             super#visit_Call env call
 
           method! visit_Panic env =
diff --git a/compiler/Translate.ml b/compiler/Translate.ml
index cb23198a..a3d96023 100644
--- a/compiler/Translate.ml
+++ b/compiler/Translate.ml
@@ -751,14 +751,17 @@ let export_functions_group (fmt : Format.formatter) (config : gen_config)
 
 (** Export a trait declaration. *)
 let export_trait_decl (fmt : Format.formatter) (_config : gen_config)
-    (ctx : gen_ctx) (trait_decl_id : Pure.trait_decl_id) : unit =
+    (ctx : gen_ctx) (trait_decl_id : Pure.trait_decl_id) (extract_decl : bool)
+    (extract_extra_info : bool) : unit =
   let trait_decl = T.TraitDeclId.Map.find trait_decl_id ctx.trans_trait_decls in
   (* Check if the trait declaration is builtin, in which case we ignore it *)
   let open ExtractBuiltin in
   let sname = name_to_simple_name trait_decl.name in
-  if SimpleNameMap.find_opt sname (builtin_trait_decls_map ()) = None then
+  if SimpleNameMap.find_opt sname (builtin_trait_decls_map ()) = None then (
     let ctx = { ctx with trait_decl_id = Some trait_decl.def_id } in
-    Extract.extract_trait_decl ctx fmt trait_decl
+    if extract_decl then Extract.extract_trait_decl ctx fmt trait_decl;
+    if extract_extra_info then
+      Extract.extract_trait_decl_extra_info ctx fmt trait_decl)
   else ()
 
 (** Export a trait implementation. *)
@@ -796,7 +799,12 @@ let extract_definitions (fmt : Format.formatter) (config : gen_config)
   let export_functions_group = export_functions_group fmt config ctx in
   let export_global = export_global fmt config ctx in
   let export_types_group = export_types_group fmt config ctx in
-  let export_trait_decl = export_trait_decl fmt config ctx in
+  let export_trait_decl_group id =
+    export_trait_decl fmt config ctx id true false
+  in
+  let export_trait_decl_group_extra_info id =
+    export_trait_decl fmt config ctx id false true
+  in
   let export_trait_impl = export_trait_impl fmt config ctx in
 
   let export_state_type () : unit =
@@ -833,8 +841,10 @@ let extract_definitions (fmt : Format.formatter) (config : gen_config)
         export_functions_group pure_funs
     | Global id -> export_global id
     | TraitDecl id ->
-        if config.extract_trait_decls && config.extract_transparent then
-          export_trait_decl id
+        (* TODO: update to extract groups *)
+        if config.extract_trait_decls && config.extract_transparent then (
+          export_trait_decl_group id;
+          export_trait_decl_group_extra_info id)
     | TraitImpl id ->
         if config.extract_trait_impls && config.extract_transparent then
           export_trait_impl id
-- 
cgit v1.3.1