From d41ab33a4240f893049a84f7853808ae2630a5ae Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Mon, 7 Nov 2022 09:26:11 +0100
Subject: Add some .mli files

---
 compiler/Driver.ml                  |   1 +
 compiler/Interpreter.ml             |   8 +-
 compiler/InterpreterBorrows.ml      |  80 +++++++++--------
 compiler/InterpreterBorrows.mli     |  34 ++++++++
 compiler/InterpreterBorrowsCore.ml  |  17 ++--
 compiler/InterpreterExpansion.ml    |  66 +++-----------
 compiler/InterpreterExpansion.mli   |  73 ++++++++++++++++
 compiler/InterpreterExpressions.ml  | 126 ++++++++++++++++++++------
 compiler/InterpreterExpressions.mli |  37 ++++++++
 compiler/InterpreterPaths.ml        | 170 +++++-------------------------------
 compiler/InterpreterPaths.mli       | 105 ++++++++++++++++++++++
 compiler/InterpreterProjectors.ml   |  54 +-----------
 compiler/InterpreterProjectors.mli  | 115 ++++++++++++++++++++++++
 compiler/InterpreterStatements.ml   |  71 ++++-----------
 compiler/InterpreterStatements.mli  |  63 +++++++++++++
 compiler/Logging.ml                 |   3 +
 16 files changed, 642 insertions(+), 381 deletions(-)
 create mode 100644 compiler/InterpreterBorrows.mli
 create mode 100644 compiler/InterpreterExpansion.mli
 create mode 100644 compiler/InterpreterExpressions.mli
 create mode 100644 compiler/InterpreterPaths.mli
 create mode 100644 compiler/InterpreterProjectors.mli
 create mode 100644 compiler/InterpreterStatements.mli

(limited to 'compiler')

diff --git a/compiler/Driver.ml b/compiler/Driver.ml
index bd9396c0..d19aca93 100644
--- a/compiler/Driver.ml
+++ b/compiler/Driver.ml
@@ -138,6 +138,7 @@ let () =
   paths_log#set_level EL.Info;
   expressions_log#set_level EL.Info;
   expansion_log#set_level EL.Info;
+  projectors_log#set_level EL.Info;
   borrows_log#set_level EL.Info;
   invariants_log#set_level EL.Info;
   pure_utils_log#set_level EL.Info;
diff --git a/compiler/Interpreter.ml b/compiler/Interpreter.ml
index cf40c5b8..d3b3c7e6 100644
--- a/compiler/Interpreter.ml
+++ b/compiler/Interpreter.ml
@@ -131,7 +131,7 @@ let evaluate_function_symbolic_synthesize_backward_from_return
   let ret_inst_sg = instantiate_fun_sig type_params sg in
   let ret_rty = ret_inst_sg.output in
   (* Move the return value out of the return variable *)
-  let cf_pop_frame = ctx_pop_frame config in
+  let cf_pop_frame = pop_frame config in
 
   (* We need to find the parents regions/abstractions of the region we
    * will end - this will allow us to, first, mark the other return
@@ -191,7 +191,7 @@ let evaluate_function_symbolic_synthesize_backward_from_return
     let target_abs_ids = List.append parent_input_abs_ids [ current_abs_id ] in
     let cf_end_target_abs cf =
       List.fold_left
-        (fun cf id -> end_abstraction config [] id cf)
+        (fun cf id -> end_abstraction config id cf)
         cf target_abs_ids
     in
     (* Generate the Return node *)
@@ -244,7 +244,7 @@ let evaluate_function_symbolic (config : C.partial_config) (synthesize : bool)
           | None ->
               (* Forward translation *)
               (* Pop the frame and retrieve the returned value at the same time*)
-              let cf_pop = ctx_pop_frame config in
+              let cf_pop = pop_frame config in
               (* Generate the Return node *)
               let cf_return ret_value : m_fun =
                fun _ -> Some (SA.Return (Some ret_value))
@@ -309,7 +309,7 @@ module Test = struct
       match res with
       | Return ->
           (* Ok: drop the local variables and finish *)
-          ctx_pop_frame config (fun _ _ -> None) ctx
+          pop_frame config (fun _ _ -> None) ctx
       | _ ->
           raise
             (Failure
diff --git a/compiler/InterpreterBorrows.ml b/compiler/InterpreterBorrows.ml
index 288ebc27..1b4907ac 100644
--- a/compiler/InterpreterBorrows.ml
+++ b/compiler/InterpreterBorrows.ml
@@ -12,21 +12,21 @@ open InterpreterBorrowsCore
 open InterpreterProjectors
 
 (** The local logger *)
-let log = InterpreterBorrowsCore.log
+let log = L.borrows_log
 
 (** Auxiliary function to end borrows: lookup a borrow in the environment,
     update it (by returning an updated environment where the borrow has been
     replaced by {!V.Bottom})) if we can end the borrow (for instance, it is not
     an outer borrow...) or return the reason why we couldn't update the borrow.
 
-    [end_borrow] then simply performs a loop: as long as we need to end (outer)
+    [end_borrow_aux] then simply performs a loop: as long as we need to end (outer)
     borrows, we end them, before finally ending the borrow we wanted to end in the
     first place.
 
     [allowed_abs]: if not [None], allows to get a borrow in the given
     abstraction without ending the whole abstraction first. This parameter
-    allows us to use {!end_borrow} as an auxiliary function for
-    {!end_abstraction} (we end all the borrows in the abstraction one by one
+    allows us to use {!end_borrow_aux} as an auxiliary function for
+    {!end_abstraction_aux} (we end all the borrows in the abstraction one by one
     before removing the abstraction from the context).
 *)
 let end_borrow_get_borrow (allowed_abs : V.AbstractionId.id option)
@@ -705,7 +705,7 @@ let reborrow_shared (original_bid : V.BorrowId.id) (new_bid : V.BorrowId.id)
   assert !r;
   { ctx with env }
 
-(** Auxiliary function: see {!end_borrow} *)
+(** Auxiliary function: see {!end_borrow_aux} *)
 let give_back (config : C.config) (l : V.BorrowId.id) (bc : g_borrow_content)
     (ctx : C.eval_ctx) : C.eval_ctx =
   (* Debug *)
@@ -796,8 +796,8 @@ let convert_avalue_to_given_back_value (abs_kind : V.abs_kind)
 
     [allowed_abs]: see the comment for {!end_borrow_get_borrow}.
 
-    [chain]: contains the list of borrows/abstraction ids on which {!end_borrow}
-    and {!end_abstraction} were called, to remember the chain of calls. This is
+    [chain]: contains the list of borrows/abstraction ids on which {!end_borrow_aux}
+    and {!end_abstraction_aux} were called, to remember the chain of calls. This is
     useful for debugging purposes, and also for sanity checks to detect cycles
     (which shouldn't happen if the environment is well-formed).
 
@@ -809,12 +809,14 @@ let convert_avalue_to_given_back_value (abs_kind : V.abs_kind)
     perform anything smart and is trusted, and another function for the
     book-keeping.
  *)
-let rec end_borrow (config : C.config) (chain : borrow_or_abs_ids)
+let rec end_borrow_aux (config : C.config) (chain : borrow_or_abs_ids)
     (allowed_abs : V.AbstractionId.id option) (l : V.BorrowId.id) : cm_fun =
  fun cf ctx ->
   (* Check that we don't loop *)
   let chain0 = chain in
-  let chain = add_borrow_or_abs_id_to_chain "end_borrow: " (BorrowId l) chain in
+  let chain =
+    add_borrow_or_abs_id_to_chain "end_borrow_aux: " (BorrowId l) chain
+  in
   log#ldebug
     (lazy
       ("end borrow: " ^ V.BorrowId.to_string l ^ ":\n- original context:\n"
@@ -884,22 +886,22 @@ let rec end_borrow (config : C.config) (chain : borrow_or_abs_ids)
            * inside another borrow *)
           let allowed_abs' = None in
           (* End the outer borrows *)
-          let cc = end_borrows config chain allowed_abs' bids in
+          let cc = end_borrows_aux config chain allowed_abs' bids in
           (* Retry to end the borrow *)
-          let cc = comp cc (end_borrow config chain0 allowed_abs l) in
+          let cc = comp cc (end_borrow_aux config chain0 allowed_abs l) in
           (* Check and apply *)
           comp cc cf_check cf ctx
       | OuterBorrows (Borrow bid) | InnerLoans (Borrow bid) ->
           let allowed_abs' = None in
           (* End the outer borrow *)
-          let cc = end_borrow config chain allowed_abs' bid in
+          let cc = end_borrow_aux config chain allowed_abs' bid in
           (* Retry to end the borrow *)
-          let cc = comp cc (end_borrow config chain0 allowed_abs l) in
+          let cc = comp cc (end_borrow_aux config chain0 allowed_abs l) in
           (* Check and apply *)
           comp cc cf_check cf ctx
       | OuterAbs abs_id ->
           (* The borrow is inside an abstraction: end the whole abstraction *)
-          let cf_end_abs = end_abstraction config chain abs_id in
+          let cf_end_abs = end_abstraction_aux config chain abs_id in
           (* Compose with a sanity check *)
           comp cf_end_abs cf_check cf ctx)
   | Ok (ctx, None) ->
@@ -922,7 +924,7 @@ let rec end_borrow (config : C.config) (chain : borrow_or_abs_ids)
       (* Do a sanity check and continue *)
       cf_check cf ctx
 
-and end_borrows (config : C.config) (chain : borrow_or_abs_ids)
+and end_borrows_aux (config : C.config) (chain : borrow_or_abs_ids)
     (allowed_abs : V.AbstractionId.id option) (lset : V.BorrowId.Set.t) : cm_fun
     =
  fun cf ->
@@ -930,20 +932,22 @@ and end_borrows (config : C.config) (chain : borrow_or_abs_ids)
    * so that we actually end from the smallest id to the highest id - just
    * a matter of taste, and may make debugging easier *)
   let ids = V.BorrowId.Set.fold (fun id ids -> id :: ids) lset [] in
-  List.fold_left (fun cf id -> end_borrow config chain allowed_abs id cf) cf ids
+  List.fold_left
+    (fun cf id -> end_borrow_aux config chain allowed_abs id cf)
+    cf ids
 
-and end_abstraction (config : C.config) (chain : borrow_or_abs_ids)
+and end_abstraction_aux (config : C.config) (chain : borrow_or_abs_ids)
     (abs_id : V.AbstractionId.id) : cm_fun =
  fun cf ctx ->
   (* Check that we don't loop *)
   let chain =
-    add_borrow_or_abs_id_to_chain "end_abstraction: " (AbsId abs_id) chain
+    add_borrow_or_abs_id_to_chain "end_abstraction_aux: " (AbsId abs_id) chain
   in
   (* Remember the original context for printing purposes *)
   let ctx0 = ctx in
   log#ldebug
     (lazy
-      ("end_abstraction: "
+      ("end_abstraction_aux: "
       ^ V.AbstractionId.to_string abs_id
       ^ "\n- original context:\n" ^ eval_ctx_to_string ctx0));
 
@@ -954,12 +958,12 @@ and end_abstraction (config : C.config) (chain : borrow_or_abs_ids)
   assert abs.can_end;
 
   (* End the parent abstractions first *)
-  let cc = end_abstractions config chain abs.parents in
+  let cc = end_abstractions_aux config chain abs.parents in
   let cc =
     comp_unit cc (fun ctx ->
         log#ldebug
           (lazy
-            ("end_abstraction: "
+            ("end_abstraction_aux: "
             ^ V.AbstractionId.to_string abs_id
             ^ "\n- context after parent abstractions ended:\n"
             ^ eval_ctx_to_string ctx)))
@@ -971,7 +975,7 @@ and end_abstraction (config : C.config) (chain : borrow_or_abs_ids)
     comp_unit cc (fun ctx ->
         log#ldebug
           (lazy
-            ("end_abstraction: "
+            ("end_abstraction_aux: "
             ^ V.AbstractionId.to_string abs_id
             ^ "\n- context after loans ended:\n" ^ eval_ctx_to_string ctx)))
   in
@@ -1000,7 +1004,7 @@ and end_abstraction (config : C.config) (chain : borrow_or_abs_ids)
     comp_unit cc (fun ctx ->
         log#ldebug
           (lazy
-            ("end_abstraction: "
+            ("end_abstraction_aux: "
             ^ V.AbstractionId.to_string abs_id
             ^ "\n- original context:\n" ^ eval_ctx_to_string ctx0
             ^ "\n\n- new context:\n" ^ eval_ctx_to_string ctx)))
@@ -1012,14 +1016,16 @@ and end_abstraction (config : C.config) (chain : borrow_or_abs_ids)
   (* Apply the continuation *)
   cc cf ctx
 
-and end_abstractions (config : C.config) (chain : borrow_or_abs_ids)
+and end_abstractions_aux (config : C.config) (chain : borrow_or_abs_ids)
     (abs_ids : V.AbstractionId.Set.t) : cm_fun =
  fun cf ->
   (* This is not necessary, but we prefer to reorder the abstraction ids,
    * so that we actually end from the smallest id to the highest id - just
    * a matter of taste, and may make debugging easier *)
   let abs_ids = V.AbstractionId.Set.fold (fun id ids -> id :: ids) abs_ids [] in
-  List.fold_left (fun cf id -> end_abstraction config chain id cf) cf abs_ids
+  List.fold_left
+    (fun cf id -> end_abstraction_aux config chain id cf)
+    cf abs_ids
 
 and end_abstraction_loans (config : C.config) (chain : borrow_or_abs_ids)
     (abs_id : V.AbstractionId.id) : cm_fun =
@@ -1039,8 +1045,8 @@ and end_abstraction_loans (config : C.config) (chain : borrow_or_abs_ids)
       (* There are loans: end the corresponding borrows, then recheck *)
       let cc : cm_fun =
         match bids with
-        | Borrow bid -> end_borrow config chain None bid
-        | Borrows bids -> end_borrows config chain None bids
+        | Borrow bid -> end_borrow_aux config chain None bid
+        | Borrows bids -> end_borrows_aux config chain None bids
       in
       (* Reexplore, looking for loans *)
       let cc = comp cc (end_abstraction_loans config chain abs_id) in
@@ -1326,7 +1332,7 @@ and end_proj_loans_symbolic (config : C.config) (chain : borrow_or_abs_ids)
             V.AbstractionId.Set.empty abs_ids
         in
         (* End the abstractions and continue *)
-        end_abstractions config chain abs_ids cf ctx
+        end_abstractions_aux config chain abs_ids cf ctx
       in
       (* End the internal borrows projectors and the loans projector *)
       let cf_end_internal : cm_fun =
@@ -1379,7 +1385,7 @@ and end_proj_loans_symbolic (config : C.config) (chain : borrow_or_abs_ids)
         cf ctx)
       else
         (* The borrows proj comes from a different abstraction: end it. *)
-        let cc = end_abstraction config chain abs_id' in
+        let cc = end_abstraction_aux config chain abs_id' in
         (* Retry ending the projector of loans *)
         let cc =
           comp cc (end_proj_loans_symbolic config chain abs_id regions sv)
@@ -1389,11 +1395,13 @@ and end_proj_loans_symbolic (config : C.config) (chain : borrow_or_abs_ids)
         (* Continue *)
         cc cf ctx
 
-let end_outer_borrow config : V.BorrowId.id -> cm_fun =
-  end_borrow config [] None
+let end_borrow config : V.BorrowId.id -> cm_fun = end_borrow_aux config [] None
+
+let end_borrows config : V.BorrowId.Set.t -> cm_fun =
+  end_borrows_aux config [] None
 
-let end_outer_borrows config : V.BorrowId.Set.t -> cm_fun =
-  end_borrows config [] None
+let end_abstraction config = end_abstraction_aux config []
+let end_abstractions config = end_abstractions_aux config []
 
 (** Helper function: see {!activate_inactivated_mut_borrow}.
 
@@ -1504,8 +1512,8 @@ let rec activate_inactivated_mut_borrow (config : C.config) (l : V.BorrowId.id)
           (* End the loans *)
           let cc =
             match lc with
-            | V.SharedLoan (bids, _) -> end_outer_borrows config bids
-            | V.MutLoan bid -> end_outer_borrow config bid
+            | V.SharedLoan (bids, _) -> end_borrows config bids
+            | V.MutLoan bid -> end_borrow config bid
           in
           (* Recursive call *)
           let cc = comp cc (activate_inactivated_mut_borrow config l) in
@@ -1524,7 +1532,7 @@ let rec activate_inactivated_mut_borrow (config : C.config) (l : V.BorrowId.id)
           (* End the borrows which borrow from the value, at the exception of
              the borrow we want to promote *)
           let bids = V.BorrowId.Set.remove l bids in
-          let cc = end_outer_borrows config bids in
+          let cc = end_borrows config bids in
           (* Promote the loan - TODO: this will fail if the value contains
            * any loans. In practice, it shouldn't, but we could also
            * look for loans inside the value and end them before promoting
diff --git a/compiler/InterpreterBorrows.mli b/compiler/InterpreterBorrows.mli
new file mode 100644
index 00000000..0733a15b
--- /dev/null
+++ b/compiler/InterpreterBorrows.mli
@@ -0,0 +1,34 @@
+module T = Types
+module V = Values
+module C = Contexts
+module Subst = Substitute
+module L = Logging
+module S = SynthesizeSymbolic
+open Cps
+open InterpreterProjectors
+
+(** When copying values, we duplicate the shared borrows. This is tantamount to
+    reborrowing the shared value. The [reborrow_shared original_id new_bid ctx]
+    applies this change to an environment [ctx] by inserting a new borrow id in
+    the set of borrows tracked by a shared value, referenced by the
+    [original_bid] argument.  *)
+val reborrow_shared : V.BorrowId.id -> V.BorrowId.id -> C.eval_ctx -> C.eval_ctx
+
+(** End a borrow identified by its id, while preserving the invariants.
+
+    If the borrow is inside another borrow/an abstraction or contains loans,
+    [end_borrow] will end those borrows/abstractions/loans first.
+  *)
+val end_borrow : C.config -> V.BorrowId.id -> cm_fun
+
+(** End a set of borrows identified by their ids, while preserving the invariants. *)
+val end_borrows : C.config -> V.BorrowId.Set.t -> cm_fun
+
+(** End an abstraction while preserving the invariants. *)
+val end_abstraction : C.config -> V.AbstractionId.id -> cm_fun
+
+(** End a set of abstractions while preserving the invariants. *)
+val end_abstractions : C.config -> V.AbstractionId.Set.t -> cm_fun
+
+(** Activate a reserved borrow into a mutable borrow, while preserving the invariants. *)
+val activate_inactivated_mut_borrow : C.config -> V.BorrowId.id -> cm_fun
diff --git a/compiler/InterpreterBorrowsCore.ml b/compiler/InterpreterBorrowsCore.ml
index 214f2cda..7cd447c3 100644
--- a/compiler/InterpreterBorrowsCore.ml
+++ b/compiler/InterpreterBorrowsCore.ml
@@ -1,6 +1,7 @@
-(* This file defines the basic blocks to implement the semantics of borrows.
- * Note that those functions are not only used in InterpreterBorrows, but
- * also in Invariants or InterpreterProjectors *)
+(** This file defines the basic blocks to implement the semantics of borrows.
+    Note that those functions are not only used in InterpreterBorrows, but
+    also in Invariants or InterpreterProjectors
+ *)
 
 module T = Types
 module V = Values
@@ -35,6 +36,11 @@ let ek_all : exploration_kind =
 type borrow_ids = Borrows of V.BorrowId.Set.t | Borrow of V.BorrowId.id
 [@@deriving show]
 
+type borrow_ids_or_symbolic_value =
+  | BorrowIds of borrow_ids
+  | SymbolicValue of V.symbolic_value
+[@@deriving show]
+
 exception FoundBorrowIds of borrow_ids
 
 type priority_borrows_or_abs =
@@ -43,11 +49,6 @@ type priority_borrows_or_abs =
   | InnerLoans of borrow_ids
 [@@deriving show]
 
-type borrow_ids_or_symbolic_value =
-  | BorrowIds of borrow_ids
-  | SymbolicValue of V.symbolic_value
-[@@deriving show]
-
 let update_if_none opt x = match opt with None -> Some x | _ -> opt
 
 (** Utility exception *)
diff --git a/compiler/InterpreterExpansion.ml b/compiler/InterpreterExpansion.ml
index cd6df2b0..c2807311 100644
--- a/compiler/InterpreterExpansion.ml
+++ b/compiler/InterpreterExpansion.ml
@@ -468,13 +468,12 @@ let apply_branching_symbolic_expansions_non_borrow (config : C.config)
   let seel = List.map fst see_cf_l in
   S.synthesize_symbolic_expansion sv sv_place seel subterms
 
-(** Expand a symbolic boolean *)
-let expand_symbolic_bool (config : C.config) (sp : V.symbolic_value)
-    (sp_place : SA.mplace option) (cf_true : m_fun) (cf_false : m_fun) : m_fun =
+let expand_symbolic_bool (config : C.config) (sv : V.symbolic_value)
+    (sv_place : SA.mplace option) (cf_true : m_fun) (cf_false : m_fun) : m_fun =
  fun ctx ->
   (* Compute the expanded value *)
-  let original_sv = sp in
-  let original_sv_place = sp_place in
+  let original_sv = sv in
+  let original_sv_place = sv_place in
   let rty = original_sv.V.sv_ty in
   assert (rty = T.Bool);
   (* Expand the symbolic value to true or false and continue execution *)
@@ -485,24 +484,17 @@ let expand_symbolic_bool (config : C.config) (sp : V.symbolic_value)
   apply_branching_symbolic_expansions_non_borrow config original_sv
     original_sv_place seel ctx
 
-(** Expand a symbolic value.
-    
-    [allow_branching]: if [true] we can branch (by expanding enumerations with
-    stricly more than one variant), otherwise we can't.
-    
-    TODO: rename [sp] to [sv]
- *)
 let expand_symbolic_value (config : C.config) (allow_branching : bool)
-    (sp : V.symbolic_value) (sp_place : SA.mplace option) : cm_fun =
+    (sv : V.symbolic_value) (sv_place : SA.mplace option) : cm_fun =
  fun cf ctx ->
   (* Debug *)
-  log#ldebug (lazy ("expand_symbolic_value:" ^ symbolic_value_to_string ctx sp));
+  log#ldebug (lazy ("expand_symbolic_value:" ^ symbolic_value_to_string ctx sv));
   (* Remember the initial context for printing purposes *)
   let ctx0 = ctx in
   (* Compute the expanded value - note that when doing so, we may introduce
    * fresh symbolic values in the context (which thus gets updated) *)
-  let original_sv = sp in
-  let original_sv_place = sp_place in
+  let original_sv = sv in
+  let original_sv_place = sv_place in
   let rty = original_sv.V.sv_ty in
   let cc : cm_fun =
    fun cf ctx ->
@@ -512,7 +504,7 @@ let expand_symbolic_value (config : C.config) (allow_branching : bool)
     | T.Adt (T.AdtId def_id, regions, types) ->
         (* Compute the expanded value *)
         let seel =
-          compute_expanded_symbolic_adt_value allow_branching sp.sv_kind def_id
+          compute_expanded_symbolic_adt_value allow_branching sv.sv_kind def_id
             regions types ctx
         in
         (* Check for branching *)
@@ -528,7 +520,7 @@ let expand_symbolic_value (config : C.config) (allow_branching : bool)
         let ty = Collections.List.to_cons_nil types in
         (* Compute the expanded value *)
         let seel =
-          compute_expanded_symbolic_option_value allow_branching sp.sv_kind ty
+          compute_expanded_symbolic_option_value allow_branching sv.sv_kind ty
         in
 
         (* Check for branching *)
@@ -540,7 +532,7 @@ let expand_symbolic_value (config : C.config) (allow_branching : bool)
     (* Tuples *)
     | T.Adt (T.Tuple, [], tys) ->
         (* Generate the field values *)
-        let see = compute_expanded_symbolic_tuple_value sp.sv_kind tys in
+        let see = compute_expanded_symbolic_tuple_value sv.sv_kind tys in
         (* Apply in the context *)
         let ctx =
           apply_symbolic_expansion_non_borrow config original_sv see ctx
@@ -552,7 +544,7 @@ let expand_symbolic_value (config : C.config) (allow_branching : bool)
           original_sv_place see expr
     (* Boxes *)
     | T.Adt (T.Assumed T.Box, [], [ boxed_ty ]) ->
-        let see = compute_expanded_symbolic_box_value sp.sv_kind boxed_ty in
+        let see = compute_expanded_symbolic_box_value sv.sv_kind boxed_ty in
         (* Apply in the context *)
         let ctx =
           apply_symbolic_expansion_non_borrow config original_sv see ctx
@@ -569,7 +561,7 @@ let expand_symbolic_value (config : C.config) (allow_branching : bool)
     (* Booleans *)
     | T.Bool ->
         assert allow_branching;
-        expand_symbolic_bool config sp sp_place cf cf ctx
+        expand_symbolic_bool config sv sv_place cf cf ctx
     | _ ->
         raise
           (Failure ("expand_symbolic_value: unexpected type: " ^ T.show_rty rty))
@@ -580,7 +572,7 @@ let expand_symbolic_value (config : C.config) (allow_branching : bool)
         log#ldebug
           (lazy
             ("expand_symbolic_value: "
-            ^ symbolic_value_to_string ctx0 sp
+            ^ symbolic_value_to_string ctx0 sv
             ^ "\n\n- original context:\n" ^ eval_ctx_to_string ctx0
             ^ "\n\n- new context:\n" ^ eval_ctx_to_string ctx ^ "\n"));
         (* Sanity check: the symbolic value has disappeared *)
@@ -589,32 +581,6 @@ let expand_symbolic_value (config : C.config) (allow_branching : bool)
   (* Continue *)
   cc cf ctx
 
-(** Symbolic integers are expanded upon evaluating a [switch], when the integer
-    is not an enumeration discriminant.
-    Note that a discriminant is never symbolic: we evaluate discriminant values
-    upon evaluating [eval_discriminant], which always generates a concrete value
-    (because if we call it on a symbolic enumeration, we expand the enumeration
-    *then* evaluate the discriminant). This is how we can spot "regular" switches
-    over integers.
-
-
-    When expanding a boolean upon evaluating an [if ... then ... else ...],
-    or an enumeration just before matching over it, we can simply expand the
-    boolean/enumeration (generating a list of contexts from which to execute)
-    then retry evaluating the [if ... then ... else ...] or the [match]: as
-    the scrutinee will then have a concrete value, the interpreter will switch
-    to the proper branch.
-    
-    However, when expanding a "regular" integer for a switch, there is always an
-    *otherwise* branch that we can take, for which the integer must remain symbolic
-    (because in this branch the scrutinee can take a range of values). We thus
-    can't simply expand then retry to evaluate the [switch], because then we
-    would loop...
-    
-    For this reason, we take the list of branches to execute as parameters, and
-    directly jump to those branches after the expansion, without reevaluating the
-    switch. The continuation is thus for the execution *after* the switch.
-*)
 let expand_symbolic_int (config : C.config) (sv : V.symbolic_value)
     (sv_place : SA.mplace option) (int_type : T.integer_type)
     (tgts : (V.scalar_value * m_fun) list) (otherwise : m_fun) : m_fun =
@@ -636,7 +602,6 @@ let expand_symbolic_int (config : C.config) (sv : V.symbolic_value)
   (* Then expand and evaluate - this generates the proper symbolic AST *)
   apply_branching_symbolic_expansions_non_borrow config sv sv_place tgts
 
-(** See [expand_symbolic_value] *)
 let expand_symbolic_value_no_branching (config : C.config)
     (sv : V.symbolic_value) (sv_place : SA.mplace option) : cm_fun =
   let allow_branching = false in
@@ -723,9 +688,6 @@ let greedy_expand_symbolics_with_borrows (config : C.config) : cm_fun =
   (* Apply *)
   expand cf ctx
 
-(** If this mode is activated through the [config], greedily expand the symbolic
-    values which need to be expanded. See [config] for more information.
- *)
 let greedy_expand_symbolic_values (config : C.config) : cm_fun =
  fun cf ctx ->
   if config.greedy_expand_symbolics_with_borrows then (
diff --git a/compiler/InterpreterExpansion.mli b/compiler/InterpreterExpansion.mli
new file mode 100644
index 00000000..ee9f9e44
--- /dev/null
+++ b/compiler/InterpreterExpansion.mli
@@ -0,0 +1,73 @@
+module T = Types
+module PV = PrimitiveValues
+module V = Values
+module E = Expressions
+module C = Contexts
+module Subst = Substitute
+module L = Logging
+module Inv = Invariants
+module S = SynthesizeSymbolic
+module SA = SymbolicAst
+open Cps
+open InterpreterBorrows
+
+type proj_kind = LoanProj | BorrowProj
+
+(** Expand a symbolic boolean *)
+val expand_symbolic_bool :
+  C.config -> V.symbolic_value -> SA.mplace option -> m_fun -> m_fun -> m_fun
+
+(** Expand a symbolic value.
+    
+    Parameters:
+    - [config]
+    - [allow_branching]: if [true] we can branch (by expanding enumerations with
+      stricly more than one variant), otherwise we can't.
+    - [sv]
+    - [sv_place]
+ *)
+val expand_symbolic_value :
+  C.config -> bool -> V.symbolic_value -> SA.mplace option -> cm_fun
+
+(** Symbolic integers are expanded upon evaluating a [switch], when the integer
+    is not an enumeration discriminant.
+    Note that a discriminant is never symbolic: we evaluate discriminant values
+    upon evaluating [eval_discriminant], which always generates a concrete value
+    (because if we call it on a symbolic enumeration, we expand the enumeration
+    *then* evaluate the discriminant). This is how we can spot "regular" switches
+    over integers.
+
+    When expanding a boolean upon evaluating an [if ... then ... else ...],
+    or an enumeration just before matching over it, we can simply expand the
+    boolean/enumeration (generating a list of contexts from which to execute)
+    then retry evaluating the [if ... then ... else ...] or the [match]: as
+    the scrutinee will then have a concrete value, the interpreter will switch
+    to the proper branch.
+    
+    However, when expanding a "regular" integer for a switch, there is always an
+    *otherwise* branch that we can take, for which the integer must remain symbolic
+    (because in this branch the scrutinee can take a range of values). We thus
+    can't simply expand then retry to evaluate the [switch], because then we
+    would loop...
+    
+    For this reason, we take the list of branches to execute as parameters, and
+    directly jump to those branches after the expansion, without reevaluating the
+    switch. The continuation is thus for the execution *after* the switch.
+ *)
+val expand_symbolic_int :
+  C.config ->
+  V.symbolic_value ->
+  SA.mplace option ->
+  T.integer_type ->
+  (V.scalar_value * m_fun) list ->
+  m_fun ->
+  m_fun
+
+(** See {!expand_symbolic_value} *)
+val expand_symbolic_value_no_branching :
+  C.config -> V.symbolic_value -> SA.mplace option -> cm_fun
+
+(** If this mode is activated through the [config], greedily expand the symbolic
+    values which need to be expanded. See {!C.config} for more information.
+ *)
+val greedy_expand_symbolic_values : C.config -> cm_fun
diff --git a/compiler/InterpreterExpressions.ml b/compiler/InterpreterExpressions.ml
index c604bb00..a7c17a45 100644
--- a/compiler/InterpreterExpressions.ml
+++ b/compiler/InterpreterExpressions.ml
@@ -34,7 +34,7 @@ let expand_primitively_copyable_at_place (config : C.config)
   (* Small helper *)
   let rec expand : cm_fun =
    fun cf ctx ->
-    let v = read_place_unwrap config access p ctx in
+    let v = read_place config access p ctx in
     match
       find_first_primitively_copyable_sv_with_borrows
         ctx.type_context.type_infos v
@@ -53,12 +53,12 @@ let expand_primitively_copyable_at_place (config : C.config)
 (** Read a place (CPS-style function).
 
     We also check that the value *doesn't contain bottoms or inactivated
-    borrows.
+    borrows*.
  *)
 let read_place (config : C.config) (access : access_kind) (p : E.place)
     (cf : V.typed_value -> m_fun) : m_fun =
  fun ctx ->
-  let v = read_place_unwrap config access p ctx in
+  let v = read_place config access p ctx in
   (* Check that there are no bottoms in the value *)
   assert (not (bottom_in_value ctx.ended_regions v));
   (* Check that there are no inactivated borrows in the value *)
@@ -79,8 +79,8 @@ let read_place (config : C.config) (access : access_kind) (p : E.place)
     We also check, after the reorganization, that the value at the place
     *doesn't contain any bottom nor inactivated borrows*.
 
-    [expand_prim_copy]: if true, expand the symbolic values which are primitively
-    copyable and contain borrows.
+    [expand_prim_copy]: if [true], expand the symbolic values which are
+    primitively copyable and contain borrows.
  *)
 let access_rplace_reorganize_and_read (config : C.config)
     (expand_prim_copy : bool) (access : access_kind) (p : E.place)
@@ -131,6 +131,77 @@ let primitive_to_typed_value (ty : T.ety) (cv : V.primitive_value) :
   (* Remaining cases (invalid) *)
   | _, _ -> raise (Failure "Improperly typed constant value")
 
+(** Copy a value, and return the resulting value.
+
+    Note that copying values might update the context. For instance, when
+    copying shared borrows, we need to insert new shared borrows in the context.
+
+    Also, this function is actually more general than it should be: it can be
+    used to copy concrete ADT values, while ADT copy should be done through the
+    Copy trait (i.e., by calling a dedicated function). This is why we added a
+    parameter to control this copy ([allow_adt_copy]). Note that here by ADT we
+    mean the user-defined ADTs (not tuples or assumed types).
+ *)
+let rec copy_value (allow_adt_copy : bool) (config : C.config)
+    (ctx : C.eval_ctx) (v : V.typed_value) : C.eval_ctx * V.typed_value =
+  log#ldebug
+    (lazy
+      ("copy_value: "
+      ^ typed_value_to_string ctx v
+      ^ "\n- context:\n" ^ eval_ctx_to_string ctx));
+  (* Remark: at some point we rewrote this function to use iterators, but then
+   * we reverted the changes: the result was less clear actually. In particular,
+   * the fact that we have exhaustive matches below makes very obvious the cases
+   * in which we need to fail *)
+  match v.V.value with
+  | V.Primitive _ -> (ctx, v)
+  | V.Adt av ->
+      (* Sanity check *)
+      (match v.V.ty with
+      | T.Adt (T.Assumed (T.Box | Vec), _, _) ->
+          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 *)
+      | _ -> raise (Failure "Unreachable"));
+      let ctx, fields =
+        List.fold_left_map
+          (copy_value allow_adt_copy config)
+          ctx av.field_values
+      in
+      (ctx, { v with V.value = V.Adt { av with field_values = fields } })
+  | V.Bottom -> raise (Failure "Can't copy ⊥")
+  | V.Borrow bc -> (
+      (* We can only copy shared borrows *)
+      match bc with
+      | SharedBorrow (mv, bid) ->
+          (* We need to create a new borrow id for the copied borrow, and
+           * update the context accordingly *)
+          let bid' = C.fresh_borrow_id () in
+          let ctx = InterpreterBorrows.reborrow_shared bid bid' ctx in
+          (ctx, { v with V.value = V.Borrow (SharedBorrow (mv, bid')) })
+      | MutBorrow (_, _) -> raise (Failure "Can't copy a mutable borrow")
+      | V.InactivatedMutBorrow _ ->
+          raise (Failure "Can't copy an inactivated mut borrow"))
+  | V.Loan lc -> (
+      (* We can only copy shared loans *)
+      match lc with
+      | V.MutLoan _ -> raise (Failure "Can't copy a mutable loan")
+      | V.SharedLoan (_, sv) ->
+          (* We don't copy the shared loan: only the shared value inside *)
+          copy_value allow_adt_copy config ctx sv)
+  | V.Symbolic sp ->
+      (* We can copy only if the type is "primitively" copyable.
+       * Note that in the general case, copy is a trait: copying values
+       * thus requires calling the proper function. Here, we copy values
+       * for very simple types such as integers, shared borrows, etc. *)
+      assert (ty_is_primitively_copyable (Subst.erase_regions sp.V.sv_ty));
+      (* If the type is copyable, we simply return the current value. Side
+       * remark: what is important to look at when copying symbolic values
+       * is symbolic expansion. The important subcase is the expansion of shared
+       * borrows: when doing so, every occurrence of the same symbolic value
+       * must use a fresh borrow id. *)
+      (ctx, v)
+
 (** Reorganize the environment in preparation for the evaluation of an operand.
 
     Evaluating an operand requires reorganizing the environment to get access
@@ -148,7 +219,7 @@ let primitive_to_typed_value (ty : T.ety) (cv : V.primitive_value) :
       dest <- f(move x, move y);
       ...
     ]}
-    Because of the way [end_borrow] is implemented, when giving back the borrow
+    Because of the way {!end_borrow} is implemented, when giving back the borrow
     [l0] upon evaluating [move y], we won't notice that [shared_borrow l0] has
     disappeared from the environment (it has been moved and not assigned yet,
     and so is hanging in "thin air").
@@ -158,13 +229,15 @@ let primitive_to_typed_value (ty : T.ety) (cv : V.primitive_value) :
     by access *and* move operations have already been applied.
 
     Rk.: in the formalization, we always have an explicit "reorganization" step
-    in the rule premises, before the actual operand evaluation.
+    in the rule premises, before the actual operand evaluation, that allows to
+    reorganize the environment so that it satisfies the proper conditions. This
+    function's role is to do the reorganization.
     
     Rk.: doing this is actually not completely necessary because when
     generating MIR, rustc introduces intermediate assignments for all the function
     parameters. Still, it is better for soundness purposes, and corresponds to
-    what we do in the formalization (because we don't enforce constraints
-    in the formalization).
+    what we do in the formalization (because we don't enforce the same constraints
+    as MIR in the formalization).
  *)
 let prepare_eval_operand_reorganize (config : C.config) (op : E.operand) :
     cm_fun =
@@ -234,22 +307,12 @@ let eval_operand_no_reorganize (config : C.config) (op : E.operand)
         (* Check that there are no bottoms in the value we are about to move *)
         assert (not (bottom_in_value ctx.ended_regions v));
         let bottom : V.typed_value = { V.value = Bottom; ty = v.ty } in
-        match write_place config access p bottom ctx with
-        | Error _ -> raise (Failure "Unreachable")
-        | Ok ctx -> cf v ctx
+        let ctx = write_place config access p bottom ctx in
+        cf v ctx
       in
       (* Compose and apply *)
       comp cc move cf ctx
 
-(** Evaluate an operand.
-
-    Reorganize the context, then evaluate the operand.
-
-    **Warning**: this function shouldn't be used to evaluate a list of
-    operands (for a function call, for instance): we must do *one* reorganization
-    of the environment, before evaluating all the operands at once.
-    Use [eval_operands] instead.
- *)
 let eval_operand (config : C.config) (op : E.operand)
     (cf : V.typed_value -> m_fun) : m_fun =
  fun ctx ->
@@ -602,7 +665,7 @@ let eval_rvalue_ref (config : C.config) (p : E.place) (bkind : E.borrow_kind)
               ({ v with V.value = v' }, v)
         in
         (* Update the borrowed value in the context *)
-        let ctx = write_place_unwrap config access p nv ctx in
+        let ctx = write_place config access p nv ctx in
         (* Compute the rvalue - simply a shared borrow with a the fresh id.
          * Note that the reference is *mutable* if we do a two-phase borrow *)
         let rv_ty =
@@ -637,7 +700,7 @@ let eval_rvalue_ref (config : C.config) (p : E.place) (bkind : E.borrow_kind)
         (* Compute the value with which to replace the value at place p *)
         let nv = { v with V.value = V.Loan (V.MutLoan bid) } in
         (* Update the value in the context *)
-        let ctx = write_place_unwrap config access p nv ctx in
+        let ctx = write_place config access p nv ctx in
         (* Continue *)
         cf rv ctx
       in
@@ -699,10 +762,6 @@ let eval_rvalue_aggregate (config : C.config)
   (* Compose and apply *)
   comp eval_ops compute cf
 
-(** Evaluate an rvalue which is not a global.
-
-    Transmits the computed rvalue to the received continuation.
- *)
 let eval_rvalue_not_global (config : C.config) (rvalue : E.rvalue)
     (cf : (V.typed_value, eval_error) result -> m_fun) : m_fun =
  fun ctx ->
@@ -723,3 +782,16 @@ let eval_rvalue_not_global (config : C.config) (rvalue : E.rvalue)
       comp_wrap (eval_rvalue_aggregate config aggregate_kind ops) ctx
   | E.Discriminant p -> comp_wrap (eval_rvalue_discriminant config p) ctx
   | E.Global _ -> raise (Failure "Unreachable")
+
+let eval_fake_read (config : C.config) (p : E.place) : cm_fun =
+ fun cf ctx ->
+  let expand_prim_copy = false in
+  let cf_prepare cf =
+    access_rplace_reorganize_and_read config expand_prim_copy Read p cf
+  in
+  let cf_continue cf v : m_fun =
+   fun ctx ->
+    assert (not (bottom_in_value ctx.ended_regions v));
+    cf ctx
+  in
+  comp cf_prepare cf_continue cf ctx
diff --git a/compiler/InterpreterExpressions.mli b/compiler/InterpreterExpressions.mli
new file mode 100644
index 00000000..c610e939
--- /dev/null
+++ b/compiler/InterpreterExpressions.mli
@@ -0,0 +1,37 @@
+module T = Types
+module PV = PrimitiveValues
+module V = Values
+module LA = LlbcAst
+module E = Expressions
+module C = Contexts
+module Subst = Substitute
+module L = Logging
+module Inv = Invariants
+module S = SynthesizeSymbolic
+open Cps
+open InterpreterPaths
+
+(** Evaluate an operand.
+
+    Reorganize the context, then evaluate the operand.
+
+    **Warning**: this function shouldn't be used to evaluate a list of
+    operands (for a function call, for instance): we must do *one* reorganization
+    of the environment, before evaluating all the operands at once.
+    Use {!eval_operands} instead.
+ *)
+val eval_operand : C.config -> E.operand -> (V.typed_value -> m_fun) -> m_fun
+
+(** Evaluate several operands at once. *)
+val eval_operands :
+  C.config -> E.operand list -> (V.typed_value list -> m_fun) -> m_fun
+
+(** Evaluate an rvalue which is not a global.
+
+    Transmits the computed rvalue to the received continuation.
+ *)
+val eval_rvalue_not_global :
+  C.config -> E.rvalue -> ((V.typed_value, eval_error) result -> m_fun) -> m_fun
+
+(** Evaluate a fake read (update the context so that we can read a place) *)
+val eval_fake_read : C.config -> E.place -> cm_fun
diff --git a/compiler/InterpreterPaths.ml b/compiler/InterpreterPaths.ml
index cc5b5864..73b446da 100644
--- a/compiler/InterpreterPaths.ml
+++ b/compiler/InterpreterPaths.ml
@@ -5,7 +5,6 @@ module C = Contexts
 module Subst = Substitute
 module L = Logging
 open Cps
-open TypesUtils
 open ValuesUtils
 open InterpreterUtils
 open InterpreterBorrowsCore
@@ -307,12 +306,12 @@ let access_kind_to_projection_access (access : access_kind) : projection_access
         lookup_shared_borrows = false;
       }
 
-(** Read the value at a given place.
+(** Attempt to read the value at a given place.
 
     Note that we only access the value at the place, and do not check that
     the value is "well-formed" (for instance that it doesn't contain bottoms).
  *)
-let read_place (config : C.config) (access : access_kind) (p : E.place)
+let try_read_place (config : C.config) (access : access_kind) (p : E.place)
     (ctx : C.eval_ctx) : V.typed_value path_access_result =
   let access = access_kind_to_projection_access access in
   (* The update function is the identity *)
@@ -334,14 +333,14 @@ let read_place (config : C.config) (access : access_kind) (p : E.place)
           raise (Failure "Unexpected environment update"));
       Ok read_value
 
-let read_place_unwrap (config : C.config) (access : access_kind) (p : E.place)
+let read_place (config : C.config) (access : access_kind) (p : E.place)
     (ctx : C.eval_ctx) : V.typed_value =
-  match read_place config access p ctx with
+  match try_read_place config access p ctx with
   | Error e -> raise (Failure ("Unreachable: " ^ show_path_fail_kind e))
   | Ok v -> v
 
-(** Update the value at a given place *)
-let write_place (_config : C.config) (access : access_kind) (p : E.place)
+(** Attempt to update the value at a given place *)
+let try_write_place (_config : C.config) (access : access_kind) (p : E.place)
     (nv : V.typed_value) (ctx : C.eval_ctx) : C.eval_ctx path_access_result =
   let access = access_kind_to_projection_access access in
   (* The update function substitutes the value with the new value *)
@@ -352,13 +351,12 @@ let write_place (_config : C.config) (access : access_kind) (p : E.place)
       (* We ignore the read value *)
       Ok ctx
 
-let write_place_unwrap (config : C.config) (access : access_kind) (p : E.place)
+let write_place (config : C.config) (access : access_kind) (p : E.place)
     (nv : V.typed_value) (ctx : C.eval_ctx) : C.eval_ctx =
-  match write_place config access p nv ctx with
+  match try_write_place config access p nv ctx with
   | Error e -> raise (Failure ("Unreachable: " ^ show_path_fail_kind e))
   | Ok ctx -> ctx
 
-(** Compute an expanded ADT bottom value *)
 let compute_expanded_bottom_adt_value (tyctx : T.type_decl T.TypeDeclId.Map.t)
     (def_id : T.TypeDeclId.id) (opt_variant_id : T.VariantId.id option)
     (regions : T.erased_region list) (types : T.ety list) : V.typed_value =
@@ -378,7 +376,6 @@ let compute_expanded_bottom_adt_value (tyctx : T.type_decl T.TypeDeclId.Map.t)
   let ty = T.Adt (T.AdtId def_id, regions, types) in
   { V.value = av; V.ty }
 
-(** Compute an expanded Option bottom value *)
 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
@@ -392,7 +389,6 @@ let compute_expanded_bottom_option_value (variant_id : T.VariantId.id)
   let ty = T.Adt (T.Assumed T.Option, [], [ param_ty ]) in
   { V.value = av; ty }
 
-(** Compute an expanded tuple bottom value *)
 let compute_expanded_bottom_tuple_value (field_types : T.ety list) :
     V.typed_value =
   (* Generate the field values *)
@@ -469,29 +465,21 @@ let expand_bottom_value_from_projection (config : C.config)
              ("Unreachable: " ^ E.show_projection_elem pe ^ ", " ^ T.show_ety ty))
   in
   (* Update the context by inserting the expanded value at the proper place *)
-  match write_place config access p' nv ctx with
+  match try_write_place config access p' nv ctx with
   | Ok ctx -> ctx
   | Error _ -> raise (Failure "Unreachable")
 
-(** Update the environment to be able to read a place.
-
-    When reading a place, we may be stuck along the way because some value
-    is borrowed, we reach a symbolic value, etc. In this situation [read_place]
-    fails while returning precise information about the failure. This function
-    uses this information to update the environment (by ending borrows,
-    expanding symbolic values) until we manage to fully read the place.
- *)
 let rec update_ctx_along_read_place (config : C.config) (access : access_kind)
     (p : E.place) : cm_fun =
  fun cf ctx ->
   (* Attempt to read the place: if it fails, update the environment and retry *)
-  match read_place config access p ctx with
+  match try_read_place config access p ctx with
   | Ok _ -> cf ctx
   | Error err ->
       let cc =
         match err with
-        | FailSharedLoan bids -> end_outer_borrows config bids
-        | FailMutLoan bid -> end_outer_borrow config bid
+        | FailSharedLoan bids -> end_borrows config bids
+        | FailMutLoan bid -> end_borrow config bid
         | FailInactivatedMutBorrow bid ->
             activate_inactivated_mut_borrow config bid
         | FailSymbolic (i, sp) ->
@@ -510,23 +498,19 @@ let rec update_ctx_along_read_place (config : C.config) (access : access_kind)
       in
       comp cc (update_ctx_along_read_place config access p) cf ctx
 
-(** Update the environment to be able to write to a place.
-
-    See {!update_ctx_along_read_place}.
-*)
 let rec update_ctx_along_write_place (config : C.config) (access : access_kind)
     (p : E.place) : cm_fun =
  fun cf ctx ->
   (* Attempt to *read* (yes, *read*: we check the access to the place, and
      write to it later) the place: if it fails, update the environment and retry *)
-  match read_place config access p ctx with
+  match try_read_place config access p ctx with
   | Ok _ -> cf ctx
   | Error err ->
       (* Update the context *)
       let cc =
         match err with
-        | FailSharedLoan bids -> end_outer_borrows config bids
-        | FailMutLoan bid -> end_outer_borrow config bid
+        | FailSharedLoan bids -> end_borrows config bids
+        | FailMutLoan bid -> end_borrow config bid
         | FailInactivatedMutBorrow bid ->
             activate_inactivated_mut_borrow config bid
         | FailSymbolic (_pe, sp) ->
@@ -549,15 +533,6 @@ let rec update_ctx_along_write_place (config : C.config) (access : access_kind)
 (** Small utility used to break control-flow *)
 exception UpdateCtx of cm_fun
 
-(** End the loans at a given place: read the value, if it contains a loan,
-    end this loan, repeat.
-
-    This is used when reading or borrowing values. We typically
-    first call {!update_ctx_along_read_place} or {!update_ctx_along_write_place}
-    to get access to the value, then call this function to "prepare" the value:
-    when moving values, we can't move a value which contains loans and thus need
-    to end them, etc.
- *)
 let rec end_loans_at_place (config : C.config) (access : access_kind)
     (p : E.place) : cm_fun =
  fun cf ctx ->
@@ -587,17 +562,17 @@ let rec end_loans_at_place (config : C.config) (access : access_kind)
             match access with
             | Read -> super#visit_SharedLoan env bids v
             | Write | Move ->
-                let cc = end_outer_borrows config bids in
+                let cc = end_borrows config bids in
                 raise (UpdateCtx cc))
         | V.MutLoan bid ->
             (* We always need to end mutable borrows *)
-            let cc = end_outer_borrow config bid in
+            let cc = end_borrow config bid in
             raise (UpdateCtx cc)
     end
   in
 
   (* First, retrieve the value *)
-  match read_place config access p ctx with
+  match try_read_place config access p ctx with
   | Error _ -> raise (Failure "Unreachable")
   | Ok v -> (
       (* Inspect the value and update the context while doing so.
@@ -615,26 +590,13 @@ let rec end_loans_at_place (config : C.config) (access : access_kind)
          * a recursive call to reinspect the value *)
         comp cc (end_loans_at_place config access p) cf ctx)
 
-(** 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).
-
-    This is used to drop values when evaluating the drop statement or before
-    writing to a place.
-    
-    Note that we don't do what is defined in the formalization: we move the
-    value to a temporary dummy value, then explore this value and end the outer
-    loans which are inside as long as we find some, then move the resulting
-    value back to where it was. This shouldn't make any difference, really (note
-    that the place is *inside* a borrow, if we end the borrow, we won't be able
-    to reinsert the value back).
- *)
 let drop_outer_loans_at_lplace (config : C.config) (p : E.place) : cm_fun =
  fun cf ctx ->
   (* Move the current value in the place outside of this place and into
    * a dummy variable *)
   let access = Write in
-  let v = read_place_unwrap config access p ctx in
-  let ctx = write_place_unwrap config access p (mk_bottom v.V.ty) ctx in
+  let v = read_place config access p ctx in
+  let ctx = write_place config access p (mk_bottom v.V.ty) ctx in
   let dummy_id = C.fresh_dummy_var_id () in
   let ctx = C.ctx_push_dummy_var ctx dummy_id v in
   (* Auxiliary function *)
@@ -652,9 +614,8 @@ let drop_outer_loans_at_lplace (config : C.config) (p : E.place) : cm_fun =
         (* There are: end them then retry *)
         let cc =
           match c with
-          | LoanContent (V.SharedLoan (bids, _)) ->
-              end_outer_borrows config bids
-          | LoanContent (V.MutLoan bid) -> end_outer_borrow config bid
+          | LoanContent (V.SharedLoan (bids, _)) -> end_borrows config bids
+          | LoanContent (V.MutLoan bid) -> end_borrow config bid
           | BorrowContent _ -> raise (Failure "Unreachable")
         in
         (* Retry *)
@@ -668,7 +629,7 @@ let drop_outer_loans_at_lplace (config : C.config) (p : E.place) : cm_fun =
         (* Pop *)
         let ctx, v = C.ctx_remove_dummy_var ctx dummy_id in
         (* Reinsert *)
-        let ctx = write_place_unwrap config access p v ctx in
+        let ctx = write_place config access p v ctx in
         (* Sanity check *)
         assert (not (outer_loans_in_value v));
         (* Continue *)
@@ -677,89 +638,6 @@ let drop_outer_loans_at_lplace (config : C.config) (p : E.place) : cm_fun =
   (* Continue *)
   cc cf ctx
 
-(** Copy a value, and return the resulting value.
-
-    Note that copying values might update the context. For instance, when
-    copying shared borrows, we need to insert new shared borrows in the context.
- 
-    Also, this function is actually more general than it should be: it can be used
-    to copy concrete ADT values, while ADT copy should be done through the Copy
-    trait (i.e., by calling a dedicated function). This is why we added a parameter
-    to control this copy. Note that here by ADT we mean the user-defined ADTs
-    (not tuples or assumed types).
-    
-    TODO: move
- *)
-let rec copy_value (allow_adt_copy : bool) (config : C.config)
-    (ctx : C.eval_ctx) (v : V.typed_value) : C.eval_ctx * V.typed_value =
-  log#ldebug
-    (lazy
-      ("copy_value: "
-      ^ typed_value_to_string ctx v
-      ^ "\n- context:\n" ^ eval_ctx_to_string ctx));
-  (* Remark: at some point we rewrote this function to use iterators, but then
-   * we reverted the changes: the result was less clear actually. In particular,
-   * the fact that we have exhaustive matches below makes very obvious the cases
-   * in which we need to fail *)
-  match v.V.value with
-  | V.Primitive _ -> (ctx, v)
-  | V.Adt av ->
-      (* Sanity check *)
-      (match v.V.ty with
-      | T.Adt (T.Assumed (T.Box | Vec), _, _) ->
-          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 *)
-      | _ -> raise (Failure "Unreachable"));
-      let ctx, fields =
-        List.fold_left_map
-          (copy_value allow_adt_copy config)
-          ctx av.field_values
-      in
-      (ctx, { v with V.value = V.Adt { av with field_values = fields } })
-  | V.Bottom -> raise (Failure "Can't copy ⊥")
-  | V.Borrow bc -> (
-      (* We can only copy shared borrows *)
-      match bc with
-      | SharedBorrow (mv, bid) ->
-          (* We need to create a new borrow id for the copied borrow, and
-           * update the context accordingly *)
-          let bid' = C.fresh_borrow_id () in
-          let ctx = reborrow_shared bid bid' ctx in
-          (ctx, { v with V.value = V.Borrow (SharedBorrow (mv, bid')) })
-      | MutBorrow (_, _) -> raise (Failure "Can't copy a mutable borrow")
-      | V.InactivatedMutBorrow _ ->
-          raise (Failure "Can't copy an inactivated mut borrow"))
-  | V.Loan lc -> (
-      (* We can only copy shared loans *)
-      match lc with
-      | V.MutLoan _ -> raise (Failure "Can't copy a mutable loan")
-      | V.SharedLoan (_, sv) ->
-          (* We don't copy the shared loan: only the shared value inside *)
-          copy_value allow_adt_copy config ctx sv)
-  | V.Symbolic sp ->
-      (* We can copy only if the type is "primitively" copyable.
-       * Note that in the general case, copy is a trait: copying values
-       * thus requires calling the proper function. Here, we copy values
-       * for very simple types such as integers, shared borrows, etc. *)
-      assert (ty_is_primitively_copyable (Subst.erase_regions sp.V.sv_ty));
-      (* If the type is copyable, we simply return the current value. Side
-       * remark: what is important to look at when copying symbolic values
-       * is symbolic expansion. The important subcase is the expansion of shared
-       * borrows: when doing so, every occurrence of the same symbolic value
-       * must use a fresh borrow id. *)
-      (ctx, v)
-
-(** Small utility.
-    
-    Prepare a place which is to be used as the destination of an assignment:
-    update the environment along the paths, end the outer loans at this place, etc.
-
-    Return the updated context and the (updated) value at the end of the
-    place. This value should not contain any outer loan (and we check
-    it is the case). Note that this value is very likely to contain {!V.Bottom}
-    subvalues.
- *)
 let prepare_lplace (config : C.config) (p : E.place)
     (cf : V.typed_value -> m_fun) : m_fun =
  fun ctx ->
@@ -775,7 +653,7 @@ let prepare_lplace (config : C.config) (p : E.place)
   (* Read the value and check it *)
   let read_check cf : m_fun =
    fun ctx ->
-    let v = read_place_unwrap config access p ctx in
+    let v = read_place config access p ctx in
     (* Sanity checks *)
     assert (not (outer_loans_in_value v));
     (* Continue *)
diff --git a/compiler/InterpreterPaths.mli b/compiler/InterpreterPaths.mli
new file mode 100644
index 00000000..ed00b7c5
--- /dev/null
+++ b/compiler/InterpreterPaths.mli
@@ -0,0 +1,105 @@
+module T = Types
+module V = Values
+module E = Expressions
+module C = Contexts
+module Subst = Substitute
+module L = Logging
+open Cps
+open InterpreterExpansion
+module Synth = SynthesizeSymbolic
+
+type access_kind = Read | Write | Move
+
+(** Update the environment to be able to read a place.
+
+    When reading a place, we may be stuck along the way because some value
+    is borrowed, we reach a symbolic value, etc. This function repeatedly
+    updates the environment (by ending borrows, expanding symbolic values, etc.)
+    until it manages to fully access the provided place.
+ *)
+val update_ctx_along_read_place : C.config -> access_kind -> E.place -> cm_fun
+
+(** Update the environment to be able to write to a place.
+
+    See {!update_ctx_along_read_place}.
+*)
+val update_ctx_along_write_place : C.config -> access_kind -> E.place -> cm_fun
+
+(** Read the value at a given place.
+
+    Note that we only access the value at the place, and do not check that
+    the value is "well-formed" (for instance that it doesn't contain bottoms).
+ *)
+val read_place :
+  C.config -> access_kind -> E.place -> C.eval_ctx -> V.typed_value
+
+(** Update the value at a given place.
+
+    This function is an auxiliary function and is not safe: it will not check if
+    the overwritten value contains borrows, loans, etc. and will simply
+    overwrite it.
+ *)
+val write_place :
+  C.config ->
+  access_kind ->
+  E.place ->
+  V.typed_value ->
+  C.eval_ctx ->
+  C.eval_ctx
+
+(** Compute an expanded tuple ⊥ value.
+
+    [compute_expanded_bottom_tuple_value [ty0, ..., tyn]] returns
+    [(⊥:ty0, ..., ⊥:tyn)]
+ *)
+val compute_expanded_bottom_tuple_value : T.ety list -> V.typed_value
+
+(** Compute an expanded ADT ⊥ value *)
+val compute_expanded_bottom_adt_value :
+  T.type_decl T.TypeDeclId.Map.t ->
+  T.TypeDeclId.id ->
+  T.VariantId.id option ->
+  T.erased_region list ->
+  T.ety list ->
+  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).
+
+    This is used to drop values when evaluating the drop statement or before
+    writing to a place.
+
+    Note that we don't do what is defined in the formalization: we move the
+    value to a temporary dummy value, then explore this value and end the outer
+    loans which are inside as long as we find some, then move the resulting
+    value back to where it was. This shouldn't make any difference, really (note
+    that the place is *inside* a borrow, if we end the borrow, we won't be able
+    to reinsert the value back).
+ *)
+val drop_outer_loans_at_lplace : C.config -> E.place -> cm_fun
+
+(** End the loans at a given place: read the value, if it contains a loan,
+    end this loan, repeat.
+
+    This is used when reading or borrowing values. We typically
+    first call {!update_ctx_along_read_place} or {!update_ctx_along_write_place}
+    to get access to the value, then call this function to "prepare" the value:
+    when moving values, we can't move a value which contains loans and thus need
+    to end them, etc.
+ *)
+val end_loans_at_place : C.config -> access_kind -> E.place -> cm_fun
+
+(** Small utility.
+
+    Prepare a place which is to be used as the destination of an assignment:
+    update the environment along the paths, end the outer loans at this place, etc.
+
+    Return the updated context and the (updated) value at the end of the
+    place. This value should not contain any outer loan (and we check it is the
+    case). Note that this value is very likely to contain ⊥ subvalues.
+  *)
+val prepare_lplace : C.config -> E.place -> (V.typed_value -> m_fun) -> m_fun
diff --git a/compiler/InterpreterProjectors.ml b/compiler/InterpreterProjectors.ml
index b77a94c4..67bbe21f 100644
--- a/compiler/InterpreterProjectors.ml
+++ b/compiler/InterpreterProjectors.ml
@@ -8,12 +8,9 @@ open TypesUtils
 open InterpreterUtils
 open InterpreterBorrowsCore
 
-(** Auxiliary function.
+(** The local logger *)
+let log = L.projectors_log
 
-    Apply a proj_borrows on a shared borrow.
-    Note that when projecting over shared values, we generate
-    {!V.abstract_shared_borrows}, not {!V.avalue}s.
-*)
 let rec apply_proj_borrows_on_shared_borrow (ctx : C.eval_ctx)
     (fresh_reborrow : V.BorrowId.id -> V.BorrowId.id)
     (regions : T.RegionId.Set.t) (v : V.typed_value) (ty : T.rty) :
@@ -93,38 +90,6 @@ let rec apply_proj_borrows_on_shared_borrow (ctx : C.eval_ctx)
         [ V.AsbProjReborrows (s, ty) ]
     | _ -> raise (Failure "Unreachable")
 
-(** Apply (and reduce) a projector over borrows to a value.
-
-    - [regions]: the regions we project
-    - [v]: the value over which we project
-    - [ty]: the projection type (is used to map borrows to regions, or to
-      interpret the borrows as belonging to some regions...). Remember that
-      [v] doesn't contain region information.
-      For instance, if we have:
-      [v <: ty] where:
-      - [v = mut_borrow l ...]
-      - [ty = Ref (r, ...)]
-      then we interpret the borrow [l] as belonging to region [r]
-    
-    Also, when applying projections on shared values, we need to apply
-    reborrows. This is a bit annoying because, with the way we compute
-    the projection on borrows, we can't update the context immediately.
-    Instead, we remember the list of borrows we have to insert in the
-    context *afterwards*.
-
-    [check_symbolic_no_ended] controls whether we check or not whether
-    symbolic values don't contain already ended regions.
-    This check is activated when applying projectors upon calling a function
-    (because we need to check that function arguments don't contain ⊥),
-    but deactivated when expanding symbolic values:
-    {[
-      fn f<'a,'b>(x : &'a mut u32, y : &'b mut u32) -> (&'a mut u32, &'b mut u32);
-
-      let p = f(&mut x, &mut y); // p -> @s0
-      assert(x == ...); // end 'a
-      let z = p.1; // HERE: the symbolic expansion of @s0 contains ended regions
-    ]}
-*)
 let rec apply_proj_borrows (check_symbolic_no_ended : bool) (ctx : C.eval_ctx)
     (fresh_reborrow : V.BorrowId.id -> V.BorrowId.id)
     (regions : T.RegionId.Set.t) (ancestors_regions : T.RegionId.Set.t)
@@ -251,7 +216,6 @@ let rec apply_proj_borrows (check_symbolic_no_ended : bool) (ctx : C.eval_ctx)
     in
     { V.value; V.ty }
 
-(** Convert a symbolic expansion *which is not a borrow* to a value *)
 let symbolic_expansion_non_borrow_to_value (sv : V.symbolic_value)
     (see : V.symbolic_expansion) : V.typed_value =
   let ty = Subst.erase_regions sv.V.sv_ty in
@@ -268,12 +232,6 @@ let symbolic_expansion_non_borrow_to_value (sv : V.symbolic_value)
   in
   { V.value; V.ty }
 
-(** Convert a symbolic expansion to a value.
-
-    If the expansion is a mutable reference expansion, it converts it to a borrow.
-    This function is meant to be used when reducing projectors over borrows,
-    during a symbolic expansion.
-  *)
 let symbolic_expansion_non_shared_borrow_to_value (sv : V.symbolic_value)
     (see : V.symbolic_expansion) : V.typed_value =
   match see with
@@ -497,14 +455,6 @@ let apply_reborrows (reborrows : (V.BorrowId.id * V.BorrowId.id) list)
   (* Return *)
   ctx
 
-(** Auxiliary function to prepare reborrowing operations (used when
-    applying projectors).
-    
-    Returns two functions:
-    - a function to generate fresh re-borrow ids, and register the reborrows
-    - a function to apply the reborrows in a context
-    Those functions are of course stateful.
- *)
 let prepare_reborrows (config : C.config) (allow_reborrows : bool) :
     (V.BorrowId.id -> V.BorrowId.id) * (C.eval_ctx -> C.eval_ctx) =
   let reborrows : (V.BorrowId.id * V.BorrowId.id) list ref = ref [] in
diff --git a/compiler/InterpreterProjectors.mli b/compiler/InterpreterProjectors.mli
new file mode 100644
index 00000000..a6d8bd5c
--- /dev/null
+++ b/compiler/InterpreterProjectors.mli
@@ -0,0 +1,115 @@
+module T = Types
+module V = Values
+module E = Expressions
+module C = Contexts
+module Subst = Substitute
+module L = Logging
+open InterpreterBorrowsCore
+
+(** Auxiliary function.
+
+    Apply a proj_borrows on a shared borrow.
+    Note that when projecting over shared values, we generate
+    {!V.abstract_shared_borrows}, not {!V.avalue}s.
+*)
+val apply_proj_loans_on_symbolic_expansion :
+  T.RegionId.Set.t -> V.symbolic_expansion -> T.rty -> V.typed_avalue
+
+(** Convert a symbolic expansion *which is not a borrow* to a value *)
+val symbolic_expansion_non_borrow_to_value :
+  V.symbolic_value -> V.symbolic_expansion -> V.typed_value
+
+(** Convert a symbolic expansion *which is not a shared borrow* to a value.
+
+    If the expansion is a mutable reference expansion, it converts it to a borrow.
+    This function is meant to be used when reducing projectors over borrows,
+    during a symbolic expansion.
+  *)
+val symbolic_expansion_non_shared_borrow_to_value :
+  V.symbolic_value -> V.symbolic_expansion -> V.typed_value
+
+(** Auxiliary function to prepare reborrowing operations (used when
+    applying projectors).
+
+    Returns two functions:
+    - a function to generate fresh re-borrow ids, and register the reborrows
+    - a function to apply the reborrows in a context
+    Those functions are of course stateful.
+
+    Parameters:
+    - [config]
+    - [allow_reborrows]
+ *)
+val prepare_reborrows :
+  C.config ->
+  bool ->
+  (V.BorrowId.id -> V.BorrowId.id) * (C.eval_ctx -> C.eval_ctx)
+
+(** Apply (and reduce) a projector over borrows to a value.
+
+    Parameters:
+    - [check_symbolic_no_ended]: controls whether we check or not whether
+      symbolic values don't contain already ended regions.
+      This check is activated when applying projectors upon calling a function
+      (because we need to check that function arguments don't contain ⊥),
+      but deactivated when expanding symbolic values:
+      {[
+        fn f<'a,'b>(x : &'a mut u32, y : &'b mut u32) -> (&'a mut u32, &'b mut u32);
+
+        let p = f(&mut x, &mut y); // p -> @s0
+        assert(x == ...); // end 'a
+        let z = p.1; // HERE: the symbolic expansion of @s0 contains ended regions
+      ]}
+    - [ctx]
+
+    - [fresh_reborrow]: a function which generates fresh ids for reborrows, and
+      registers the reborrows (to be applied later to the context).
+
+      When applying projections on shared values, we need to apply
+      reborrows. This is a bit annoying because, with the way we compute
+      the projection on borrows, we can't update the context immediately.
+      Instead, we remember the list of borrows we have to insert in the
+      context *afterwards*.
+
+      See {!prepare_reborrows}
+
+    - [regions]: the regions to project
+    - [ancestor_regions]
+    - [v]: the value on which to apply the projection
+
+    - [ty]: the projection type (is used to map borrows to regions, or in other
+      words to interpret the borrows as belonging to some regions). Remember that
+      [v] doesn't contain region information.
+      For instance, if we have:
+      [v <: ty] where:
+      - [v = mut_borrow l ...]
+      - [ty = Ref (r, ...)]
+      then we interpret the borrow [l] as belonging to region [r]
+*)
+val apply_proj_borrows :
+  bool ->
+  C.eval_ctx ->
+  (V.BorrowId.id -> V.BorrowId.id) ->
+  T.RegionId.Set.t ->
+  T.RegionId.Set.t ->
+  V.typed_value ->
+  T.rty ->
+  V.typed_avalue
+
+(** Parameters:
+    - [config]
+    - [ctx]
+    - [regions]: the regions to project
+    - [ancestors_regions]
+    - [v]: the value on which to apply the projection
+    - [ty]: the type (with regions) to use for the projection
+
+ *)
+val apply_proj_borrows_on_input_value :
+  C.config ->
+  C.eval_ctx ->
+  T.RegionId.Set.t ->
+  T.RegionId.Set.t ->
+  V.typed_value ->
+  T.rty ->
+  C.eval_ctx * V.typed_avalue
diff --git a/compiler/InterpreterStatements.ml b/compiler/InterpreterStatements.ml
index 4d447ffe..66196349 100644
--- a/compiler/InterpreterStatements.ml
+++ b/compiler/InterpreterStatements.ml
@@ -39,12 +39,12 @@ let drop_value (config : C.config) (p : E.place) : cm_fun =
   let replace cf (v : V.typed_value) ctx =
     (* Move the value at destination (that we will overwrite) to a dummy variable
      * to preserve the borrows it may contain *)
-    let mv = read_place_unwrap config access p ctx in
+    let mv = InterpreterPaths.read_place config access p ctx in
     let dummy_id = C.fresh_dummy_var_id () in
     let ctx = C.ctx_push_dummy_var ctx dummy_id mv in
     (* Update the destination to ⊥ *)
     let nv = { v with value = V.Bottom } in
-    let ctx = write_place_unwrap config access p nv ctx in
+    let ctx = write_place config access p nv ctx in
     log#ldebug
       (lazy
         ("drop_value: place: " ^ place_to_string ctx p ^ "\n- Final context:\n"
@@ -119,14 +119,14 @@ let assign_to_place (config : C.config) (rv : V.typed_value) (p : E.place) :
    fun ctx ->
     (* Move the value at destination (that we will overwrite) to a dummy variable
      * to preserve the borrows *)
-    let mv = read_place_unwrap config Write p ctx in
+    let mv = InterpreterPaths.read_place config Write p ctx in
     let dest_vid = C.fresh_dummy_var_id () in
     let ctx = C.ctx_push_dummy_var ctx dest_vid mv in
     (* Write to the destination *)
     (* Checks - maybe the bookkeeping updated the rvalue and introduced bottoms *)
     assert (not (bottom_in_value ctx.ended_regions rv));
     (* Update the destination *)
-    let ctx = write_place_unwrap config Write p rv ctx in
+    let ctx = write_place config Write p rv ctx in
     (* Debug *)
     log#ldebug
       (lazy
@@ -322,19 +322,10 @@ let move_return_value (config : C.config) (cf : V.typed_value -> m_fun) : m_fun
   let cc = eval_operand config (E.Move (mk_place_from_var_id ret_vid)) in
   cc cf ctx
 
-(** Pop the current frame.
-    
-    Drop all the local variables but the return variable, move the return
-    value out of the return variable, remove all the local variables (but not the
-    abstractions!) from the context, remove the {!C.Frame} indicator delimiting the
-    current frame and handle the return value to the continuation.
-    
-    TODO: rename (remove the "ctx_")
- *)
-let ctx_pop_frame (config : C.config) (cf : V.typed_value -> m_fun) : m_fun =
+let pop_frame (config : C.config) (cf : V.typed_value -> m_fun) : m_fun =
  fun ctx ->
   (* Debug *)
-  log#ldebug (lazy ("ctx_pop_frame:\n" ^ eval_ctx_to_string ctx));
+  log#ldebug (lazy ("pop_frame:\n" ^ eval_ctx_to_string ctx));
 
   (* List the local variables, but the return variable *)
   let ret_vid = E.VarId.zero in
@@ -352,7 +343,7 @@ let ctx_pop_frame (config : C.config) (cf : V.typed_value -> m_fun) : m_fun =
   (* Debug *)
   log#ldebug
     (lazy
-      ("ctx_pop_frame: locals in which to drop the outer loans: ["
+      ("pop_frame: locals in which to drop the outer loans: ["
       ^ String.concat "," (List.map E.VarId.to_string locals)
       ^ "]"));
 
@@ -383,7 +374,7 @@ let ctx_pop_frame (config : C.config) (cf : V.typed_value -> m_fun) : m_fun =
     comp_check_value cc (fun _ ctx ->
         log#ldebug
           (lazy
-            ("ctx_pop_frame: after dropping outer loans in local variables:\n"
+            ("pop_frame: after dropping outer loans in local variables:\n"
            ^ eval_ctx_to_string ctx)))
   in
 
@@ -410,7 +401,7 @@ let ctx_pop_frame (config : C.config) (cf : V.typed_value -> m_fun) : m_fun =
 
 (** Pop the current frame and assign the returned value to its destination. *)
 let pop_frame_assign (config : C.config) (dest : E.place) : cm_fun =
-  let cf_pop = ctx_pop_frame config in
+  let cf_pop = pop_frame config in
   let cf_assign cf ret_value : m_fun =
     assign_to_place config ret_value dest cf
   in
@@ -547,7 +538,9 @@ let eval_box_free (config : C.config) (region_params : T.erased_region list)
   match (region_params, type_params, args) with
   | [], [ boxed_ty ], [ E.Move input_box_place ] ->
       (* Required type checking *)
-      let input_box = read_place_unwrap config Write input_box_place ctx in
+      let input_box =
+        InterpreterPaths.read_place config Write input_box_place ctx
+      in
       (let input_ty = ty_get_box input_box.V.ty in
        assert (input_ty = boxed_ty));
 
@@ -642,15 +635,6 @@ let eval_non_local_function_call_concrete (config : C.config)
       (* Compose and apply *)
       comp cf_eval_ops cf_eval_call
 
-(** Instantiate a function signature, introducing fresh abstraction ids and
-    region ids. This is mostly used in preparation of function calls, when
-    evaluating in symbolic mode of course.
-    
-    Note: there are no region parameters, because they should be erased.
-    
-    **Rk.:** this function is **stateful** and generates fresh abstraction ids
-    for the region groups.
- *)
 let instantiate_fun_sig (type_params : T.ety list) (sg : A.fun_sig) :
     A.inst_fun_sig =
   (* Generate fresh abstraction ids and create a substitution from region
@@ -757,20 +741,6 @@ let create_empty_abstractions_from_abs_region_groups (call_id : V.FunCallId.id)
   (* Apply *)
   T.RegionGroupId.mapi create_abs rgl
 
-(** Helper.
-
-    Create a list of abstractions from a list of regions groups, and insert
-    them in the context.
-
-    [region_can_end]: gives the region groups from which we generate functions
-    which can end or not.
-    
-    [compute_abs_avalues]: this function must compute, given an initialized,
-    empty (i.e., with no avalues) abstraction, compute the avalues which
-    should be inserted in this abstraction before we insert it in the context.
-    Note that this function may update the context: it is necessary when
-    computing borrow projections, for instance.
-*)
 let create_push_abstractions_from_abs_region_groups (call_id : V.FunCallId.id)
     (kind : V.abs_kind) (rgl : A.abs_region_group list)
     (region_can_end : T.RegionGroupId.id -> bool)
@@ -857,17 +827,7 @@ let rec eval_statement (config : C.config) (st : A.statement) : st_cm_fun =
 
             (* Compose and apply *)
             comp cf_eval_rvalue cf_assign cf ctx)
-    | A.FakeRead p ->
-        let expand_prim_copy = false in
-        let cf_prepare cf =
-          access_rplace_reorganize_and_read config expand_prim_copy Read p cf
-        in
-        let cf_continue cf v : m_fun =
-         fun ctx ->
-          assert (not (bottom_in_value ctx.ended_regions v));
-          cf ctx
-        in
-        comp cf_prepare cf_continue (cf Unit) ctx
+    | A.FakeRead p -> eval_fake_read config p (cf Unit) ctx
     | A.SetDiscriminant (p, variant_id) ->
         set_discriminant config p variant_id cf ctx
     | A.Drop p -> drop_value config p (cf Unit) ctx
@@ -1256,7 +1216,7 @@ and eval_function_call_symbolic_from_inst_sig (config : C.config)
       abs_ids := with_loans_abs;
       (* End the abstractions which can be ended *)
       let no_loans_abs = V.AbstractionId.Set.of_list no_loans_abs in
-      let cc = InterpreterBorrows.end_abstractions config [] no_loans_abs in
+      let cc = InterpreterBorrows.end_abstractions config no_loans_abs in
       (* Recursive call *)
       let cc = comp cc end_abs_with_no_loans in
       (* Continue *)
@@ -1362,8 +1322,7 @@ and eval_local_function_call (config : C.config) (fid : A.FunDeclId.id)
       eval_local_function_call_symbolic config fid region_args type_args args
         dest
 
-(** Evaluate a statement seen as a function body (auxiliary helper for
-    [eval_statement]) *)
+(** Evaluate a statement seen as a function body *)
 and eval_function_body (config : C.config) (body : A.statement) : st_cm_fun =
  fun cf ctx ->
   let cc = eval_statement config body in
diff --git a/compiler/InterpreterStatements.mli b/compiler/InterpreterStatements.mli
new file mode 100644
index 00000000..1bfd1c78
--- /dev/null
+++ b/compiler/InterpreterStatements.mli
@@ -0,0 +1,63 @@
+module T = Types
+module PV = PrimitiveValues
+module V = Values
+module E = Expressions
+module C = Contexts
+module Subst = Substitute
+module A = LlbcAst
+module L = Logging
+module Inv = Invariants
+module S = SynthesizeSymbolic
+open Cps
+open InterpreterExpressions
+
+(** Pop the current frame.
+
+    Drop all the local variables (which has the effect of moving their values to
+    dummy variables, after ending the proper borrows of course) but the return
+    variable, move the return value out of the return variable, remove all the
+    local variables (but preserve the abstractions!), remove the {!C.Frame} indicator
+    delimiting the current frame and handle the return value to the continuation.
+ *)
+val pop_frame : C.config -> (V.typed_value -> m_fun) -> m_fun
+
+(** Instantiate a function signature, introducing **fresh** abstraction ids and
+    region ids. This is mostly used in preparation of function calls, when
+    evaluating in symbolic mode of course.
+
+    Note: there are no region parameters, because they should be erased.
+ *)
+val instantiate_fun_sig : T.ety list -> LA.fun_sig -> LA.inst_fun_sig
+
+(** Helper.
+
+    Create a list of abstractions from a list of regions groups, and insert
+    them in the context.
+
+    Parameters:
+    - [call_id]
+    - [kind]
+    - [rgl]: "region group list"
+    - [region_can_end]: gives the region groups from which we generate functions
+      which can end or not.
+    - [compute_abs_avalues]: this function must compute, given an initialized,
+      empty (i.e., with no avalues) abstraction, compute the avalues which
+      should be inserted in this abstraction before we insert it in the context.
+      Note that this function may update the context: it is necessary when
+      computing borrow projections, for instance.
+    - [ctx]
+*)
+val create_push_abstractions_from_abs_region_groups :
+  V.FunCallId.id ->
+  V.abs_kind ->
+  LA.abs_region_group list ->
+  (T.RegionGroupId.id -> bool) ->
+  (V.abs -> C.eval_ctx -> C.eval_ctx * V.typed_avalue list) ->
+  C.eval_ctx ->
+  C.eval_ctx
+
+(** Evaluate a statement *)
+val eval_statement : C.config -> LA.statement -> st_cm_fun
+
+(** Evaluate a statement seen as a function body *)
+val eval_function_body : C.config -> LA.statement -> st_cm_fun
diff --git a/compiler/Logging.ml b/compiler/Logging.ml
index 7b95f41d..5f22506b 100644
--- a/compiler/Logging.ml
+++ b/compiler/Logging.ml
@@ -36,6 +36,9 @@ let paths_log = L.get_logger "MainLogger.Interpreter.Paths"
 (** Logger for InterpreterExpansion *)
 let expansion_log = L.get_logger "MainLogger.Interpreter.Expansion"
 
+(** Logger for InterpreterProjectors *)
+let projectors_log = L.get_logger "MainLogger.Interpreter.Projectors"
+
 (** Logger for InterpreterBorrows *)
 let borrows_log = L.get_logger "MainLogger.Interpreter.Borrows"
 
-- 
cgit v1.2.3