7 files changed, 193 insertions, 33 deletions

diff --git a/tests/hashmap/Hashmap.Funs.fst b/tests/hashmap/Hashmap.Funs.fst
index 83c245fb..921ed142 100644
--- a/tests/hashmap/Hashmap.Funs.fst
+++ b/tests/hashmap/Hashmap.Funs.fst
@@ -188,6 +188,10 @@ let hash_map_insert_no_resize_fwd_back
     end
   end
 
+(** [core::num::u32::{8}::MAX] *)
+let core_num_u32_max_body : result u32 = Return 4294967295
+let core_num_u32_max_c : u32 = eval_global core_num_u32_max_body
+
 (** [hashmap::HashMap::{0}::move_elements_from_list] *)
 let rec hash_map_move_elements_from_list_fwd_back
   (t : Type0) (ntable : hash_map_t t) (ls : list_t t) :
@@ -244,23 +248,24 @@ let rec hash_map_move_elements_fwd_back
 (** [hashmap::HashMap::{0}::try_resize] *)
 let hash_map_try_resize_fwd_back
   (t : Type0) (self : hash_map_t t) : result (hash_map_t t) =
-  begin match scalar_cast U32 Usize 4294967295 with
+  let i = core_num_u32_max_c in
+  begin match scalar_cast U32 Usize i with
   | Fail -> Fail
   | Return max_usize ->
     let capacity = vec_len (list_t t) self.hash_map_slots in
     begin match usize_div max_usize 2 with
     | Fail -> Fail
     | Return n1 ->
-      let (i, i0) = self.hash_map_max_load_factor in
-      begin match usize_div n1 i with
+      let (i0, i1) = self.hash_map_max_load_factor in
+      begin match usize_div n1 i0 with
       | Fail -> Fail
-      | Return i1 ->
-        if capacity <= i1
+      | Return i2 ->
+        if capacity <= i2
         then
           begin match usize_mul capacity 2 with
           | Fail -> Fail
-          | Return i2 ->
-            begin match hash_map_new_with_capacity_fwd t i2 i i0 with
+          | Return i3 ->
+            begin match hash_map_new_with_capacity_fwd t i3 i0 i1 with
             | Fail -> Fail
             | Return ntable ->
               begin match
@@ -268,13 +273,13 @@ let hash_map_try_resize_fwd_back
                 with
               | Fail -> Fail
               | Return (ntable0, _) ->
-                Return (Mkhash_map_t self.hash_map_num_entries (i, i0)
+                Return (Mkhash_map_t self.hash_map_num_entries (i0, i1)
                   ntable0.hash_map_max_load ntable0.hash_map_slots)
               end
             end
           end
         else
-          Return (Mkhash_map_t self.hash_map_num_entries (i, i0)
+          Return (Mkhash_map_t self.hash_map_num_entries (i0, i1)
             self.hash_map_max_load self.hash_map_slots)
       end
     end
diff --git a/tests/hashmap/Primitives.fst b/tests/hashmap/Primitives.fst
index fe351f3a..b3da25c2 100644
--- a/tests/hashmap/Primitives.fst
+++ b/tests/hashmap/Primitives.fst
@@ -34,6 +34,9 @@ let bind (#a #b : Type0) (m : result a) (f : a -> result b) : result b =
 // Monadic assert(...)
 let massert (b:bool) : result unit = if b then Return () else Fail
 
+// Unwrap a successful result by normalisation (used for globals).
+let eval_global (#a : Type0) (x : result a{Return? (normalize_term x)}) : a = Return?.v x
+
 (*** Misc *)
 type char = FStar.Char.char
 type string = string
diff --git a/tests/hashmap_on_disk/HashmapMain.Funs.fst b/tests/hashmap_on_disk/HashmapMain.Funs.fst
index d01046ec..1d8ee3da 100644
--- a/tests/hashmap_on_disk/HashmapMain.Funs.fst
+++ b/tests/hashmap_on_disk/HashmapMain.Funs.fst
@@ -198,6 +198,10 @@ let hashmap_hash_map_insert_no_resize_fwd_back
     end
   end
 
+(** [core::num::u32::{8}::MAX] *)
+let core_num_u32_max_body : result u32 = Return 4294967295
+let core_num_u32_max_c : u32 = eval_global core_num_u32_max_body
+
 (** [hashmap_main::hashmap::HashMap::{0}::move_elements_from_list] *)
 let rec hashmap_hash_map_move_elements_from_list_fwd_back
   (t : Type0) (ntable : hashmap_hash_map_t t) (ls : hashmap_list_t t) :
@@ -257,23 +261,24 @@ let rec hashmap_hash_map_move_elements_fwd_back
 (** [hashmap_main::hashmap::HashMap::{0}::try_resize] *)
 let hashmap_hash_map_try_resize_fwd_back
   (t : Type0) (self : hashmap_hash_map_t t) : result (hashmap_hash_map_t t) =
-  begin match scalar_cast U32 Usize 4294967295 with
+  let i = core_num_u32_max_c in
+  begin match scalar_cast U32 Usize i with
   | Fail -> Fail
   | Return max_usize ->
     let capacity = vec_len (hashmap_list_t t) self.hashmap_hash_map_slots in
     begin match usize_div max_usize 2 with
     | Fail -> Fail
     | Return n1 ->
-      let (i, i0) = self.hashmap_hash_map_max_load_factor in
-      begin match usize_div n1 i with
+      let (i0, i1) = self.hashmap_hash_map_max_load_factor in
+      begin match usize_div n1 i0 with
       | Fail -> Fail
-      | Return i1 ->
-        if capacity <= i1
+      | Return i2 ->
+        if capacity <= i2
         then
           begin match usize_mul capacity 2 with
           | Fail -> Fail
-          | Return i2 ->
-            begin match hashmap_hash_map_new_with_capacity_fwd t i2 i i0 with
+          | Return i3 ->
+            begin match hashmap_hash_map_new_with_capacity_fwd t i3 i0 i1 with
             | Fail -> Fail
             | Return ntable ->
               begin match
@@ -282,14 +287,14 @@ let hashmap_hash_map_try_resize_fwd_back
               | Fail -> Fail
               | Return (ntable0, _) ->
                 Return (Mkhashmap_hash_map_t self.hashmap_hash_map_num_entries
-                  (i, i0) ntable0.hashmap_hash_map_max_load
+                  (i0, i1) ntable0.hashmap_hash_map_max_load
                   ntable0.hashmap_hash_map_slots)
               end
             end
           end
         else
-          Return (Mkhashmap_hash_map_t self.hashmap_hash_map_num_entries (i,
-            i0) self.hashmap_hash_map_max_load self.hashmap_hash_map_slots)
+          Return (Mkhashmap_hash_map_t self.hashmap_hash_map_num_entries (i0,
+            i1) self.hashmap_hash_map_max_load self.hashmap_hash_map_slots)
       end
     end
   end
diff --git a/tests/hashmap_on_disk/Primitives.fst b/tests/hashmap_on_disk/Primitives.fst
index fe351f3a..b3da25c2 100644
--- a/tests/hashmap_on_disk/Primitives.fst
+++ b/tests/hashmap_on_disk/Primitives.fst
@@ -34,6 +34,9 @@ let bind (#a #b : Type0) (m : result a) (f : a -> result b) : result b =
 // Monadic assert(...)
 let massert (b:bool) : result unit = if b then Return () else Fail
 
+// Unwrap a successful result by normalisation (used for globals).
+let eval_global (#a : Type0) (x : result a{Return? (normalize_term x)}) : a = Return?.v x
+
 (*** Misc *)
 type char = FStar.Char.char
 type string = string
diff --git a/tests/misc/Constants.fst b/tests/misc/Constants.fst
new file mode 100644
index 00000000..06425e64
--- /dev/null
+++ b/tests/misc/Constants.fst
@@ -0,0 +1,141 @@
+(** THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS *)
+(** [constants] *)
+module Constants
+open Primitives
+
+#set-options "--z3rlimit 50 --fuel 1 --ifuel 1"
+
+(** [constants::X0] *)
+let x0_body : result u32 = Return 0
+let x0_c : u32 = eval_global x0_body
+
+(** [core::num::u32::{8}::MAX] *)
+let core_num_u32_max_body : result u32 = Return 4294967295
+let core_num_u32_max_c : u32 = eval_global core_num_u32_max_body
+
+(** [constants::X1] *)
+let x1_body : result u32 = let i = core_num_u32_max_c in Return i
+let x1_c : u32 = eval_global x1_body
+
+(** [constants::X2] *)
+let x2_body : result u32 = Return 3
+let x2_c : u32 = eval_global x2_body
+
+(** [constants::incr] *)
+let incr_fwd (n : u32) : result u32 =
+  begin match u32_add n 1 with | Fail -> Fail | Return i -> Return i end
+
+(** [constants::X3] *)
+let x3_body : result u32 =
+  begin match incr_fwd 32 with | Fail -> Fail | Return i -> Return i end
+let x3_c : u32 = eval_global x3_body
+
+(** [constants::mk_pair0] *)
+let mk_pair0_fwd (x : u32) (y : u32) : result (u32 & u32) = Return (x, y)
+
+(** [constants::Pair] *)
+type pair_t (t1 t2 : Type0) = { pair_x : t1; pair_y : t2; }
+
+(** [constants::mk_pair1] *)
+let mk_pair1_fwd (x : u32) (y : u32) : result (pair_t u32 u32) =
+  Return (Mkpair_t x y)
+
+(** [constants::P0] *)
+let p0_body : result (u32 & u32) =
+  begin match mk_pair0_fwd 0 1 with | Fail -> Fail | Return p -> Return p end
+let p0_c : (u32 & u32) = eval_global p0_body
+
+(** [constants::P1] *)
+let p1_body : result (pair_t u32 u32) =
+  begin match mk_pair1_fwd 0 1 with | Fail -> Fail | Return p -> Return p end
+let p1_c : pair_t u32 u32 = eval_global p1_body
+
+(** [constants::P2] *)
+let p2_body : result (u32 & u32) = Return (0, 1)
+let p2_c : (u32 & u32) = eval_global p2_body
+
+(** [constants::P3] *)
+let p3_body : result (pair_t u32 u32) = Return (Mkpair_t 0 1)
+let p3_c : pair_t u32 u32 = eval_global p3_body
+
+(** [constants::Wrap] *)
+type wrap_t (t : Type0) = { wrap_val : t; }
+
+(** [constants::Wrap::{0}::new] *)
+let wrap_new_fwd (t : Type0) (val0 : t) : result (wrap_t t) =
+  Return (Mkwrap_t val0)
+
+(** [constants::Y] *)
+let y_body : result (wrap_t i32) =
+  begin match wrap_new_fwd i32 2 with | Fail -> Fail | Return w -> Return w end
+let y_c : wrap_t i32 = eval_global y_body
+
+(** [constants::unwrap_y] *)
+let unwrap_y_fwd : result i32 = let w = y_c in Return w.wrap_val
+
+(** [constants::YVAL] *)
+let yval_body : result i32 =
+  begin match unwrap_y_fwd with | Fail -> Fail | Return i -> Return i end
+let yval_c : i32 = eval_global yval_body
+
+(** [constants::get_z1::Z1] *)
+let get_z1_z1_body : result i32 = Return 3
+let get_z1_z1_c : i32 = eval_global get_z1_z1_body
+
+(** [constants::get_z1] *)
+let get_z1_fwd : result i32 = let i = get_z1_z1_c in Return i
+
+(** [constants::add] *)
+let add_fwd (a : i32) (b : i32) : result i32 =
+  begin match i32_add a b with | Fail -> Fail | Return i -> Return i end
+
+(** [constants::Q1] *)
+let q1_body : result i32 = Return 5
+let q1_c : i32 = eval_global q1_body
+
+(** [constants::Q2] *)
+let q2_body : result i32 = let i = q1_c in Return i
+let q2_c : i32 = eval_global q2_body
+
+(** [constants::Q3] *)
+let q3_body : result i32 =
+  let i = q2_c in
+  begin match add_fwd i 3 with | Fail -> Fail | Return i0 -> Return i0 end
+let q3_c : i32 = eval_global q3_body
+
+(** [constants::get_z2] *)
+let get_z2_fwd : result i32 =
+  begin match get_z1_fwd with
+  | Fail -> Fail
+  | Return i ->
+    let i0 = q3_c in
+    begin match add_fwd i i0 with
+    | Fail -> Fail
+    | Return i1 ->
+      let i2 = q1_c in
+      begin match add_fwd i2 i1 with
+      | Fail -> Fail
+      | Return i3 -> Return i3
+      end
+    end
+  end
+
+(** [constants::S1] *)
+let s1_body : result u32 = Return 6
+let s1_c : u32 = eval_global s1_body
+
+(** [constants::S2] *)
+let s2_body : result u32 =
+  let i = s1_c in
+  begin match incr_fwd i with | Fail -> Fail | Return i0 -> Return i0 end
+let s2_c : u32 = eval_global s2_body
+
+(** [constants::S3] *)
+let s3_body : result (pair_t u32 u32) = let p = p3_c in Return p
+let s3_c : pair_t u32 u32 = eval_global s3_body
+
+(** [constants::S4] *)
+let s4_body : result (pair_t u32 u32) =
+  begin match mk_pair1_fwd 7 8 with | Fail -> Fail | Return p -> Return p end
+let s4_c : pair_t u32 u32 = eval_global s4_body
+
diff --git a/tests/misc/NoNestedBorrows.fst b/tests/misc/NoNestedBorrows.fst
index 35d32514..a694cff1 100644
--- a/tests/misc/NoNestedBorrows.fst
+++ b/tests/misc/NoNestedBorrows.fst
@@ -218,36 +218,36 @@ let _ = assert_norm (get_elem_test_fwd = Return ())
 (** [no_nested_borrows::test_char] *)
 let test_char_fwd : result char = Return 'a'
 
-(** [no_nested_borrows::Tree] *)
-type tree_t (t : Type0) =
-| TreeLeaf : t -> tree_t t
-| TreeNode : t -> node_elem_t t -> tree_t t -> tree_t t
-
 (** [no_nested_borrows::NodeElem] *)
-and node_elem_t (t : Type0) =
+type node_elem_t (t : Type0) =
 | NodeElemCons : tree_t t -> node_elem_t t -> node_elem_t t
 | NodeElemNil : node_elem_t t
 
-(** [no_nested_borrows::even] *)
-let rec even_fwd (x : u32) : result bool =
+(** [no_nested_borrows::Tree] *)
+and tree_t (t : Type0) =
+| TreeLeaf : t -> tree_t t
+| TreeNode : t -> node_elem_t t -> tree_t t -> tree_t t
+
+(** [no_nested_borrows::odd] *)
+let rec odd_fwd (x : u32) : result bool =
   if x = 0
-  then Return true
+  then Return false
   else
     begin match u32_sub x 1 with
     | Fail -> Fail
     | Return i ->
-      begin match odd_fwd i with | Fail -> Fail | Return b -> Return b end
+      begin match even_fwd i with | Fail -> Fail | Return b -> Return b end
     end
 
-(** [no_nested_borrows::odd] *)
-and odd_fwd (x : u32) : result bool =
+(** [no_nested_borrows::even] *)
+and even_fwd (x : u32) : result bool =
   if x = 0
-  then Return false
+  then Return true
   else
     begin match u32_sub x 1 with
     | Fail -> Fail
     | Return i ->
-      begin match even_fwd i with | Fail -> Fail | Return b -> Return b end
+      begin match odd_fwd i with | Fail -> Fail | Return b -> Return b end
     end
 
 (** [no_nested_borrows::test_even_odd] *)
diff --git a/tests/misc/Primitives.fst b/tests/misc/Primitives.fst
index fe351f3a..b3da25c2 100644
--- a/tests/misc/Primitives.fst
+++ b/tests/misc/Primitives.fst
@@ -34,6 +34,9 @@ let bind (#a #b : Type0) (m : result a) (f : a -> result b) : result b =
 // Monadic assert(...)
 let massert (b:bool) : result unit = if b then Return () else Fail
 
+// Unwrap a successful result by normalisation (used for globals).
+let eval_global (#a : Type0) (x : result a{Return? (normalize_term x)}) : a = Return?.v x
+
 (*** Misc *)
 type char = FStar.Char.char
 type string = string