Update the generated files

1 files changed, 84 insertions, 81 deletions

diff --git a/tests/fstar/traits/Traits.fst b/tests/fstar/traits/Traits.fst
index 0760de2e..b4a4e7bc 100644
--- a/tests/fstar/traits/Traits.fst
+++ b/tests/fstar/traits/Traits.fst
@@ -9,14 +9,14 @@ open Primitives
     Source: 'src/traits.rs', lines 1:0-1:19 *)
 noeq type boolTrait_t (self : Type0) = { get_bool : self -> result bool; }
 
-(** [traits::{bool}::get_bool]:
+(** [traits::{(traits::BoolTrait for bool)}::get_bool]:
     Source: 'src/traits.rs', lines 12:4-12:30 *)
-let bool_get_bool (self : bool) : result bool =
+let boolTraitBool_get_bool (self : bool) : result bool =
   Return self
 
-(** Trait implementation: [traits::{bool}]
+(** Trait implementation: [traits::{(traits::BoolTrait for bool)}]
     Source: 'src/traits.rs', lines 11:0-11:23 *)
-let traits_BoolTraitBoolInst : boolTrait_t bool = { get_bool = bool_get_bool; }
+let boolTraitBool : boolTrait_t bool = { get_bool = boolTraitBool_get_bool; }
 
 (** [traits::BoolTrait::ret_true]:
     Source: 'src/traits.rs', lines 6:4-6:30 *)
@@ -29,27 +29,27 @@ let boolTrait_ret_true
 (** [traits::test_bool_trait_bool]:
     Source: 'src/traits.rs', lines 17:0-17:44 *)
 let test_bool_trait_bool (x : bool) : result bool =
-  let* b = bool_get_bool x in
-  if b then boolTrait_ret_true traits_BoolTraitBoolInst x else Return false
+  let* b = boolTraitBool_get_bool x in
+  if b then boolTrait_ret_true boolTraitBool x else Return false
 
-(** [traits::{core::option::Option<T>#1}::get_bool]:
+(** [traits::{(traits::BoolTrait for core::option::Option<T>)#1}::get_bool]:
     Source: 'src/traits.rs', lines 23:4-23:30 *)
-let option_get_bool (t : Type0) (self : option t) : result bool =
+let boolTraitcoreoptionOptionT_get_bool
+  (t : Type0) (self : option t) : result bool =
   begin match self with | None -> Return false | Some _ -> Return true end
 
-(** Trait implementation: [traits::{core::option::Option<T>#1}]
+(** Trait implementation: [traits::{(traits::BoolTrait for core::option::Option<T>)#1}]
     Source: 'src/traits.rs', lines 22:0-22:31 *)
-let traits_BoolTraitcoreoptionOptionTInst (t : Type0) : boolTrait_t (option t)
-  = {
-  get_bool = option_get_bool t;
+let boolTraitcoreoptionOptionT (t : Type0) : boolTrait_t (option t) = {
+  get_bool = boolTraitcoreoptionOptionT_get_bool t;
 }
 
 (** [traits::test_bool_trait_option]:
     Source: 'src/traits.rs', lines 31:0-31:54 *)
 let test_bool_trait_option (t : Type0) (x : option t) : result bool =
-  let* b = option_get_bool t x in
+  let* b = boolTraitcoreoptionOptionT_get_bool t x in
   if b
-  then boolTrait_ret_true (traits_BoolTraitcoreoptionOptionTInst t) x
+  then boolTrait_ret_true (boolTraitcoreoptionOptionT t) x
   else Return false
 
 (** [traits::test_bool_trait]:
@@ -62,86 +62,85 @@ let test_bool_trait
     Source: 'src/traits.rs', lines 39:0-39:15 *)
 noeq type toU64_t (self : Type0) = { to_u64 : self -> result u64; }
 
-(** [traits::{u64#2}::to_u64]:
+(** [traits::{(traits::ToU64 for u64)#2}::to_u64]:
     Source: 'src/traits.rs', lines 44:4-44:26 *)
-let u64_to_u64 (self : u64) : result u64 =
+let toU64U64_to_u64 (self : u64) : result u64 =
   Return self
 
-(** Trait implementation: [traits::{u64#2}]
+(** Trait implementation: [traits::{(traits::ToU64 for u64)#2}]
     Source: 'src/traits.rs', lines 43:0-43:18 *)
-let traits_ToU64U64Inst : toU64_t u64 = { to_u64 = u64_to_u64; }
+let toU64U64 : toU64_t u64 = { to_u64 = toU64U64_to_u64; }
 
-(** [traits::{(A, A)#3}::to_u64]:
+(** [traits::{(traits::ToU64 for (A, A))#3}::to_u64]:
     Source: 'src/traits.rs', lines 50:4-50:26 *)
-let pair_to_u64
+let toU64Pair_to_u64
   (a : Type0) (toU64AInst : toU64_t a) (self : (a & a)) : result u64 =
   let (x, x1) = self in
   let* i = toU64AInst.to_u64 x in
   let* i1 = toU64AInst.to_u64 x1 in
   u64_add i i1
 
-(** Trait implementation: [traits::{(A, A)#3}]
+(** Trait implementation: [traits::{(traits::ToU64 for (A, A))#3}]
     Source: 'src/traits.rs', lines 49:0-49:31 *)
-let traits_ToU64TupleAAInst (a : Type0) (toU64AInst : toU64_t a) : toU64_t (a &
-  a) = {
-  to_u64 = pair_to_u64 a toU64AInst;
+let toU64Pair (a : Type0) (toU64AInst : toU64_t a) : toU64_t (a & a) = {
+  to_u64 = toU64Pair_to_u64 a toU64AInst;
 }
 
 (** [traits::f]:
     Source: 'src/traits.rs', lines 55:0-55:36 *)
 let f (t : Type0) (toU64TInst : toU64_t t) (x : (t & t)) : result u64 =
-  pair_to_u64 t toU64TInst x
+  toU64Pair_to_u64 t toU64TInst x
 
 (** [traits::g]:
     Source: 'src/traits.rs', lines 59:0-61:18 *)
 let g
-  (t : Type0) (toU64TupleTTInst : toU64_t (t & t)) (x : (t & t)) : result u64 =
-  toU64TupleTTInst.to_u64 x
+  (t : Type0) (toU64PairInst : toU64_t (t & t)) (x : (t & t)) : result u64 =
+  toU64PairInst.to_u64 x
 
 (** [traits::h0]:
     Source: 'src/traits.rs', lines 66:0-66:24 *)
 let h0 (x : u64) : result u64 =
-  u64_to_u64 x
+  toU64U64_to_u64 x
 
 (** [traits::Wrapper]
     Source: 'src/traits.rs', lines 70:0-70:21 *)
 type wrapper_t (t : Type0) = { x : t; }
 
-(** [traits::{traits::Wrapper<T>#4}::to_u64]:
+(** [traits::{(traits::ToU64 for traits::Wrapper<T>)#4}::to_u64]:
     Source: 'src/traits.rs', lines 75:4-75:26 *)
-let wrapper_to_u64
+let toU64traitsWrapperT_to_u64
   (t : Type0) (toU64TInst : toU64_t t) (self : wrapper_t t) : result u64 =
   toU64TInst.to_u64 self.x
 
-(** Trait implementation: [traits::{traits::Wrapper<T>#4}]
+(** Trait implementation: [traits::{(traits::ToU64 for traits::Wrapper<T>)#4}]
     Source: 'src/traits.rs', lines 74:0-74:35 *)
-let traits_ToU64traitsWrapperTInst (t : Type0) (toU64TInst : toU64_t t) :
-  toU64_t (wrapper_t t) = {
-  to_u64 = wrapper_to_u64 t toU64TInst;
+let toU64traitsWrapperT (t : Type0) (toU64TInst : toU64_t t) : toU64_t
+  (wrapper_t t) = {
+  to_u64 = toU64traitsWrapperT_to_u64 t toU64TInst;
 }
 
 (** [traits::h1]:
     Source: 'src/traits.rs', lines 80:0-80:33 *)
 let h1 (x : wrapper_t u64) : result u64 =
-  wrapper_to_u64 u64 traits_ToU64U64Inst x
+  toU64traitsWrapperT_to_u64 u64 toU64U64 x
 
 (** [traits::h2]:
     Source: 'src/traits.rs', lines 84:0-84:41 *)
 let h2 (t : Type0) (toU64TInst : toU64_t t) (x : wrapper_t t) : result u64 =
-  wrapper_to_u64 t toU64TInst x
+  toU64traitsWrapperT_to_u64 t toU64TInst x
 
 (** Trait declaration: [traits::ToType]
     Source: 'src/traits.rs', lines 88:0-88:19 *)
 noeq type toType_t (self t : Type0) = { to_type : self -> result t; }
 
-(** [traits::{u64#5}::to_type]:
+(** [traits::{(traits::ToType<bool> for u64)#5}::to_type]:
     Source: 'src/traits.rs', lines 93:4-93:28 *)
-let u64_to_type (self : u64) : result bool =
+let toTypeU64Bool_to_type (self : u64) : result bool =
   Return (self > 0)
 
-(** Trait implementation: [traits::{u64#5}]
+(** Trait implementation: [traits::{(traits::ToType<bool> for u64)#5}]
     Source: 'src/traits.rs', lines 92:0-92:25 *)
-let traits_ToTypeU64BoolInst : toType_t u64 bool = { to_type = u64_to_type; }
+let toTypeU64Bool : toType_t u64 bool = { to_type = toTypeU64Bool_to_type; }
 
 (** Trait declaration: [traits::OfType]
     Source: 'src/traits.rs', lines 98:0-98:16 *)
@@ -189,17 +188,17 @@ noeq type testType_test_TestTrait_t (self : Type0) = {
   test : self -> result bool;
 }
 
-(** [traits::{traits::TestType<T>#6}::test::{traits::{traits::TestType<T>#6}::test::TestType1}::test]:
+(** [traits::{traits::TestType<T>#6}::test::{(traits::{traits::TestType<T>#6}::test::TestTrait for traits::{traits::TestType<T>#6}::test::TestType1)}::test]:
     Source: 'src/traits.rs', lines 139:12-139:34 *)
-let testType_test_TestType1_test
+let testType_test_TestTraittraitsTestTypetestTestType1_test
   (self : testType_test_TestType1_t) : result bool =
   Return (self > 1)
 
-(** Trait implementation: [traits::{traits::TestType<T>#6}::test::{traits::{traits::TestType<T>#6}::test::TestType1}]
+(** Trait implementation: [traits::{traits::TestType<T>#6}::test::{(traits::{traits::TestType<T>#6}::test::TestTrait for traits::{traits::TestType<T>#6}::test::TestType1)}]
     Source: 'src/traits.rs', lines 138:8-138:36 *)
-let traits_TestType_test_TestTraittraitstraitsTestTypeTtestTestType1Inst :
+let testType_test_TestTraittraitsTestTypetestTestType1 :
   testType_test_TestTrait_t testType_test_TestType1_t = {
-  test = testType_test_TestType1_test;
+  test = testType_test_TestTraittraitsTestTypetestTestType1_test;
 }
 
 (** [traits::{traits::TestType<T>#6}::test]:
@@ -209,31 +208,34 @@ let testType_test
   result bool
   =
   let* x1 = toU64TInst.to_u64 x in
-  if x1 > 0 then testType_test_TestType1_test 0 else Return false
+  if x1 > 0
+  then testType_test_TestTraittraitsTestTypetestTestType1_test 0
+  else Return false
 
 (** [traits::BoolWrapper]
     Source: 'src/traits.rs', lines 150:0-150:22 *)
 type boolWrapper_t = bool
 
-(** [traits::{traits::BoolWrapper#7}::to_type]:
+(** [traits::{(traits::ToType<T> for traits::BoolWrapper)#7}::to_type]:
     Source: 'src/traits.rs', lines 156:4-156:25 *)
-let boolWrapper_to_type
+let toTypetraitsBoolWrapperT_to_type
   (t : Type0) (toTypeBoolTInst : toType_t bool t) (self : boolWrapper_t) :
   result t
   =
   toTypeBoolTInst.to_type self
 
-(** Trait implementation: [traits::{traits::BoolWrapper#7}]
+(** Trait implementation: [traits::{(traits::ToType<T> for traits::BoolWrapper)#7}]
     Source: 'src/traits.rs', lines 152:0-152:33 *)
-let traits_ToTypetraitsBoolWrapperTInst (t : Type0) (toTypeBoolTInst : toType_t
-  bool t) : toType_t boolWrapper_t t = {
-  to_type = boolWrapper_to_type t toTypeBoolTInst;
+let toTypetraitsBoolWrapperT (t : Type0) (toTypeBoolTInst : toType_t bool t) :
+  toType_t boolWrapper_t t = {
+  to_type = toTypetraitsBoolWrapperT_to_type t toTypeBoolTInst;
 }
 
 (** [traits::WithConstTy::LEN2]
     Source: 'src/traits.rs', lines 164:4-164:21 *)
-let with_const_ty_len2_body : result usize = Return 32
-let with_const_ty_len2_c : usize = eval_global with_const_ty_len2_body
+let with_const_ty_len2_default_body : result usize = Return 32
+let with_const_ty_len2_default : usize =
+  eval_global with_const_ty_len2_default_body
 
 (** Trait declaration: [traits::WithConstTy]
     Source: 'src/traits.rs', lines 161:0-161:39 *)
@@ -246,25 +248,26 @@ noeq type withConstTy_t (self : Type0) (len : usize) = {
   f : tW -> array u8 len -> result tW;
 }
 
-(** [traits::{bool#8}::LEN1]
+(** [traits::{(traits::WithConstTy<32: usize> for bool)#8}::LEN1]
     Source: 'src/traits.rs', lines 175:4-175:21 *)
-let bool_len1_body : result usize = Return 12
-let bool_len1_c : usize = eval_global bool_len1_body
+let with_const_ty_bool32_len1_body : result usize = Return 12
+let with_const_ty_bool32_len1 : usize =
+  eval_global with_const_ty_bool32_len1_body
 
-(** [traits::{bool#8}::f]:
+(** [traits::{(traits::WithConstTy<32: usize> for bool)#8}::f]:
     Source: 'src/traits.rs', lines 180:4-180:39 *)
-let bool_f (i : u64) (a : array u8 32) : result u64 =
+let withConstTyBool32_f (i : u64) (a : array u8 32) : result u64 =
   Return i
 
-(** Trait implementation: [traits::{bool#8}]
+(** Trait implementation: [traits::{(traits::WithConstTy<32: usize> for bool)#8}]
     Source: 'src/traits.rs', lines 174:0-174:29 *)
-let traits_WithConstTyBool32Inst : withConstTy_t bool 32 = {
-  cLEN1 = bool_len1_c;
-  cLEN2 = with_const_ty_len2_c;
+let withConstTyBool32 : withConstTy_t bool 32 = {
+  cLEN1 = with_const_ty_bool32_len1;
+  cLEN2 = with_const_ty_len2_default;
   tV = u8;
   tW = u64;
-  tW_clause_0 = traits_ToU64U64Inst;
-  f = bool_f;
+  tW_clause_0 = toU64U64;
+  f = withConstTyBool32_f;
 }
 
 (** [traits::use_with_const_ty1]:
@@ -354,14 +357,14 @@ noeq type childTrait1_t (self : Type0) = {
   parentTrait1SelfInst : parentTrait1_t self;
 }
 
-(** Trait implementation: [traits::{usize#9}]
+(** Trait implementation: [traits::{(traits::ParentTrait1 for usize)#9}]
     Source: 'src/traits.rs', lines 224:0-224:27 *)
-let traits_ParentTrait1UsizeInst : parentTrait1_t usize = ()
+let parentTrait1Usize : parentTrait1_t usize = ()
 
-(** Trait implementation: [traits::{usize#10}]
+(** Trait implementation: [traits::{(traits::ChildTrait1 for usize)#10}]
     Source: 'src/traits.rs', lines 225:0-225:26 *)
-let traits_ChildTrait1UsizeInst : childTrait1_t usize = {
-  parentTrait1SelfInst = traits_ParentTrait1UsizeInst;
+let childTrait1Usize : childTrait1_t usize = {
+  parentTrait1SelfInst = parentTrait1Usize;
 }
 
 (** Trait declaration: [traits::Iterator]
@@ -407,27 +410,27 @@ noeq type childTrait2_t (self : Type0) = {
     parentTrait2SelfInst.tU_clause_0.tTarget;
 }
 
-(** Trait implementation: [traits::{u32#11}]
+(** Trait implementation: [traits::{(traits::WithTarget for u32)#11}]
     Source: 'src/traits.rs', lines 264:0-264:23 *)
-let traits_WithTargetU32Inst : withTarget_t u32 = { tTarget = u32; }
+let withTargetU32 : withTarget_t u32 = { tTarget = u32; }
 
-(** Trait implementation: [traits::{u32#12}]
+(** Trait implementation: [traits::{(traits::ParentTrait2 for u32)#12}]
     Source: 'src/traits.rs', lines 268:0-268:25 *)
-let traits_ParentTrait2U32Inst : parentTrait2_t u32 = {
+let parentTrait2U32 : parentTrait2_t u32 = {
   tU = u32;
-  tU_clause_0 = traits_WithTargetU32Inst;
+  tU_clause_0 = withTargetU32;
 }
 
-(** [traits::{u32#13}::convert]:
+(** [traits::{(traits::ChildTrait2 for u32)#13}::convert]:
     Source: 'src/traits.rs', lines 273:4-273:29 *)
-let u32_convert (x : u32) : result u32 =
+let childTrait2U32_convert (x : u32) : result u32 =
   Return x
 
-(** Trait implementation: [traits::{u32#13}]
+(** Trait implementation: [traits::{(traits::ChildTrait2 for u32)#13}]
     Source: 'src/traits.rs', lines 272:0-272:24 *)
-let traits_ChildTrait2U32Inst : childTrait2_t u32 = {
-  parentTrait2SelfInst = traits_ParentTrait2U32Inst;
-  convert = u32_convert;
+let childTrait2U32 : childTrait2_t u32 = {
+  parentTrait2SelfInst = parentTrait2U32;
+  convert = childTrait2U32_convert;
 }
 
 (** Trait declaration: [traits::CFnOnce]