feat: parenthetical syntax for cycles, timeout etc.

doc/md/examples/grammar.txt

@@ -214,6 +214,7 @@
     'break' <id> <exp_nullary>?
     'continue' <id>
     'debug' <exp_nest>
+    '(' <exp_post>? 'with' <list(<exp_field>, ';')> ')' <exp_nest>
     'if' <exp_nullary> <exp_nest>
     'if' <exp_nullary> <exp_nest> 'else' <exp_nest>
     'try' <exp_nest> <catch>

src/ir_def/arrange_ir.ml

@@ -57,7 +57,7 @@ and args = function
 and arg a = Atom a.it
 
 and prim = function
-  | CallPrim ts       -> "CallPrim" $$ List.map typ ts
+  | CallPrim (ts, _FIXME) -> "CallPrim" $$ List.map typ ts @ [exp _FIXME]
   | UnPrim (t, uo)    -> "UnPrim"     $$ [typ t; Arrange_ops.unop uo]
   | BinPrim (t, bo)   -> "BinPrim"    $$ [typ t; Arrange_ops.binop bo]
   | RelPrim (t, ro)   -> "RelPrim"    $$ [typ t; Arrange_ops.relop ro]

src/ir_def/check_ir.ml

@@ -398,7 +398,7 @@ let rec check_exp env (exp:Ir.exp) : unit =
   | PrimE (p, es) ->
     List.iter (check_exp env) es;
     begin match p, es with
-    | CallPrim insts, [exp1; exp2] ->
+    | CallPrim (insts, _FIXMEpars), [exp1; exp2] ->
       begin match T.promote (typ exp1) with
         | T.Func (sort, control, tbs, arg_tys, ret_tys) ->
           check_inst_bounds env tbs insts exp.at;

src/ir_def/construct.ml

@@ -312,14 +312,16 @@ let funcE name sort ctrl typ_binds args typs exp =
     note = Note.{ def with typ; eff = T.Triv };
   }
 
+let recordE' = ref (fun _ -> nullE ()) (* gets correctly filled below *)
+
 let callE exp1 typs exp2 =
   let typ =  match T.promote (typ exp1) with
     | T.Func (_sort, control, _, _, ret_tys) ->
       T.codom control (fun () -> List.hd typs) (List.map (T.open_ typs) ret_tys)
     | T.Non -> T.Non
     | _ -> raise (Invalid_argument "callE expect a function")
   in
-  let p = CallPrim typs in
+  let p = CallPrim (typs, !recordE' []) in
   let es = [exp1; exp2] in
   { it = PrimE (p, es);
     at = no_region;
@@ -351,7 +353,7 @@ let orE : Ir.exp -> Ir.exp -> Ir.exp = fun e1 e2 ->
 let impliesE : Ir.exp -> Ir.exp -> Ir.exp = fun e1 e2 ->
   orE (notE e1) e2
 let oldE : Ir.exp -> Ir.exp = fun e ->
-  { it = (primE (CallPrim [typ e]) [e]).it;
+  { it = (primE (CallPrim ([typ e], !recordE' [])) [e]).it;
     at = no_region;
     note = Note.{ def with
       typ = typ e;
@@ -771,6 +773,8 @@ let objE sort typ_flds flds =
 
 let recordE flds = objE T.Object [] flds
 
+let _ = recordE' := recordE
+
 let check_call_perform_status success mk_failure =
   ifE
     (callE

src/ir_def/ir.ml

@@ -113,7 +113,7 @@ and lexp' =
 all call-by-value. Many passes can treat them uniformly, so they are unified
 using the PrimE node. *)
 and prim =
-  | CallPrim of Type.typ list         (* function call *)
+  | CallPrim of Type.typ list * exp   (* function call *)
   | UnPrim of Type.typ * unop         (* unary operator *)
   | BinPrim of Type.typ * binop       (* binary operator *)
   | RelPrim of Type.typ * relop       (* relational operator *)
@@ -257,7 +257,7 @@ let replace_obj_pat pfs pats =
 
 let map_prim t_typ t_id p =
   match p with
-  | CallPrim ts -> CallPrim (List.map t_typ ts)
+  | CallPrim (ts, _FIXME) -> CallPrim (List.map t_typ ts, _FIXME)
   | UnPrim (ot, op) -> UnPrim (t_typ ot, op)
   | BinPrim (ot, op) -> BinPrim (t_typ ot, op)
   | RelPrim (ot, op) -> RelPrim (t_typ ot, op)

src/ir_interpreter/interpret_ir.ml

@@ -310,7 +310,7 @@ and interpret_exp_mut env exp (k : V.value V.cont) =
   | PrimE (p, es) ->
     interpret_exps env es [] (fun vs ->
       match p, vs with
-      | CallPrim typs, [v1; v2] ->
+      | CallPrim (typs, _), [v1; v2] ->
         let call_conv, f = V.as_func v1 in
         check_call_conv (List.hd es) call_conv;
         check_call_conv_arg env exp v2 call_conv;

src/ir_passes/async.ml

@@ -308,7 +308,7 @@ let transform prog =
       let v_ret = fresh_var "v" t_ret in
       let v_fail = fresh_var "e" t_fail in
       ([v_ret; v_fail] -->* (callE (t_exp exp1) [t0] (tupE [varE v_ret; varE v_fail]))).it
-    | PrimE (CallPrim typs, [exp1; exp2]) when is_awaitable_func exp1 ->
+    | PrimE (CallPrim (typs, _FIXME), [exp1; exp2]) when is_awaitable_func exp1 ->
       let ts1,ts2 =
         match typ exp1 with
         | T.Func (T.Shared _, T.Promises, tbs, ts1, ts2) ->

src/ir_passes/tailcall.ml

@@ -94,14 +94,14 @@ and assignEs vars exp : dec list =
 and exp' env e  : exp' = match e.it with
   | VarE _ | LitE _     -> e.it
   | AssignE (e1, e2)    -> AssignE (lexp env e1, exp env e2)
-  | PrimE (CallPrim insts, [e1; e2])  ->
+  | PrimE (CallPrim (insts, pars), [e1; e2])  ->
     begin match e1.it, env with
     | VarE f1, { tail_pos = true;
                  info = Some { func; typ_binds; temps; label; tail_called } }
          when f1 = func && are_generic_insts typ_binds insts  ->
       tail_called := true;
       (blockE (assignEs temps (exp env e2)) (breakE label (unitE ()))).it
-    | _,_-> PrimE (CallPrim insts, [exp env e1; exp env e2])
+    | _,_-> PrimE (CallPrim (insts, pars), [exp env e1; exp env e2])
     end
   | BlockE (ds, e)      -> BlockE (block env ds e)
   | IfE (e1, e2, e3)    -> IfE (exp env e1, tailexp env e2, tailexp env e3)

src/lowering/desugar.ml

@@ -123,7 +123,7 @@ and exp' at note = function
     let tys = List.map (T.open_ vars) res_tys in
     I.FuncE (name, s, control, tbs', args, tys, wrap (exp e))
   (* Primitive functions in the prelude have particular shapes *)
-  | S.CallE ({it=S.AnnotE ({it=S.PrimE p;_}, _);note;_}, _, e)
+  | S.CallE (None, {it=S.AnnotE ({it=S.PrimE p;_}, _);note;_}, _, e)
     when Lib.String.chop_prefix "num_conv" p <> None ->
     begin match String.split_on_char '_' p with
     | ["num"; "conv"; s1; s2] ->
@@ -132,7 +132,7 @@ and exp' at note = function
       I.PrimE (I.NumConvTrapPrim (p1, p2), [exp e])
     | _ -> assert false
     end
-  | S.CallE ({it=S.AnnotE ({it=S.PrimE p;_}, _);note;_}, _, e)
+  | S.CallE (None, {it=S.AnnotE ({it=S.PrimE p;_}, _);note;_}, _, e)
     when Lib.String.chop_prefix "num_wrap" p <> None ->
     begin match String.split_on_char '_' p with
     | ["num"; "wrap"; s1; s2] ->
@@ -141,71 +141,71 @@ and exp' at note = function
       I.PrimE (I.NumConvWrapPrim (p1, p2), [exp e])
     | _ -> assert false
     end
-  | S.CallE ({it=S.AnnotE ({it=S.PrimE "decodeUtf8";_},_);_}, _, e) ->
+  | S.CallE (None, {it=S.AnnotE ({it=S.PrimE "decodeUtf8";_},_);_}, _, e) ->
     I.PrimE (I.DecodeUtf8, [exp e])
-  | S.CallE ({it=S.AnnotE ({it=S.PrimE "encodeUtf8";_},_);_}, _, e) ->
+  | S.CallE (None, {it=S.AnnotE ({it=S.PrimE "encodeUtf8";_},_);_}, _, e) ->
     I.PrimE (I.EncodeUtf8, [exp e])
-  | S.CallE ({it=S.AnnotE ({it=S.PrimE "cast";_}, _);note;_}, _, e) ->
+  | S.CallE (None, {it=S.AnnotE ({it=S.PrimE "cast";_}, _);note;_}, _, e) ->
     begin match note.S.note_typ with
     | T.Func (T.Local, T.Returns, [], ts1, ts2) ->
       I.PrimE (I.CastPrim (T.seq ts1, T.seq ts2), [exp e])
     | _ -> assert false
     end
-  | S.CallE ({it=S.AnnotE ({it=S.PrimE "serialize";_}, _);note;_}, _, e) ->
+  | S.CallE (None, {it=S.AnnotE ({it=S.PrimE "serialize";_}, _);note;_}, _, e) ->
     begin match note.S.note_typ with
     | T.Func (T.Local, T.Returns, [], ts1, ts2) ->
       I.PrimE (I.SerializePrim ts1, [exp e])
     | _ -> assert false
     end
-  | S.CallE ({it=S.AnnotE ({it=S.PrimE "deserialize";_}, _);note;_}, _, e) ->
+  | S.CallE (None, {it=S.AnnotE ({it=S.PrimE "deserialize";_}, _);note;_}, _, e) ->
     begin match note.S.note_typ with
     | T.Func (T.Local, T.Returns, [], ts1, ts2) ->
       I.PrimE (I.DeserializePrim ts2, [exp e])
     | _ -> assert false
     end
-  | S.CallE ({it=S.AnnotE ({it=S.PrimE "caller";_},_);_}, _, {it=S.TupE es;_}) ->
+  | S.CallE (None, {it=S.AnnotE ({it=S.PrimE "caller";_},_);_}, _, {it=S.TupE es;_}) ->
     assert (es = []);
     I.PrimE (I.ICCallerPrim, [])
-  | S.CallE ({it=S.AnnotE ({it=S.PrimE "time";_},_);_}, _, {it=S.TupE es;_}) ->
+  | S.CallE (None, {it=S.AnnotE ({it=S.PrimE "time";_},_);_}, _, {it=S.TupE es;_}) ->
     assert (es = []);
     I.PrimE (I.SystemTimePrim, [])
   (* Cycles *)
-  | S.CallE ({it=S.AnnotE ({it=S.PrimE "cyclesBalance";_},_);_}, _, {it=S.TupE es;_}) ->
+  | S.CallE (None, {it=S.AnnotE ({it=S.PrimE "cyclesBalance";_},_);_}, _, {it=S.TupE es;_}) ->
     assert (es = []);
     I.PrimE (I.SystemCyclesBalancePrim, [])
-  | S.CallE ({it=S.AnnotE ({it=S.PrimE "cyclesAvailable";_},_);_}, _, {it=S.TupE es;_}) ->
+  | S.CallE (None, {it=S.AnnotE ({it=S.PrimE "cyclesAvailable";_},_);_}, _, {it=S.TupE es;_}) ->
     assert (es = []);
     I.PrimE (I.SystemCyclesAvailablePrim, [])
-  | S.CallE ({it=S.AnnotE ({it=S.PrimE "cyclesRefunded";_},_);_}, _, {it=S.TupE es;_}) ->
+  | S.CallE (None, {it=S.AnnotE ({it=S.PrimE "cyclesRefunded";_},_);_}, _, {it=S.TupE es;_}) ->
     assert (es = []);
     I.PrimE (I.SystemCyclesRefundedPrim, [])
-  | S.CallE ({it=S.AnnotE ({it=S.PrimE "cyclesAccept";_},_);_}, _, e) ->
+  | S.CallE (None, {it=S.AnnotE ({it=S.PrimE "cyclesAccept";_},_);_}, _, e) ->
     I.PrimE (I.SystemCyclesAcceptPrim, [exp e])
-  | S.CallE ({it=S.AnnotE ({it=S.PrimE "cyclesAdd";_},_);_}, _, e) ->
+  | S.CallE (None, {it=S.AnnotE ({it=S.PrimE "cyclesAdd";_},_);_}, _, e) ->
     I.PrimE (I.SystemCyclesAddPrim, [exp e])
   (* Certified data *)
-  | S.CallE ({it=S.AnnotE ({it=S.PrimE "setCertifiedData";_},_);_}, _, e) ->
+  | S.CallE (None, {it=S.AnnotE ({it=S.PrimE "setCertifiedData";_},_);_}, _, e) ->
     I.PrimE (I.SetCertifiedData, [exp e])
-  | S.CallE ({it=S.AnnotE ({it=S.PrimE "getCertificate";_},_);_}, _, {it=S.TupE es;_}) ->
+  | S.CallE (None, {it=S.AnnotE ({it=S.PrimE "getCertificate";_},_);_}, _, {it=S.TupE es;_}) ->
     I.PrimE (I.GetCertificate, [])
   (* Other *)
-  | S.CallE ({it=S.AnnotE ({it=S.PrimE p;_},_);_}, _, {it=S.TupE es;_}) ->
+  | S.CallE (None, {it=S.AnnotE ({it=S.PrimE p;_},_);_}, _, {it=S.TupE es;_}) ->
     I.PrimE (I.OtherPrim p, exps es)
-  | S.CallE ({it=S.AnnotE ({it=S.PrimE p;_},_);_}, _, e) ->
+  | S.CallE (None, {it=S.AnnotE ({it=S.PrimE p;_},_);_}, _, e) ->
     I.PrimE (I.OtherPrim p, [exp e])
   (* Optimizing array.size() *)
-  | S.CallE ({it=S.DotE (e1, proj); _}, _, {it=S.TupE [];_})
+  | S.CallE (None, {it=S.DotE (e1, proj); _}, _, {it=S.TupE [];_})
       when T.is_array e1.note.S.note_typ && proj.it = "size" ->
     I.PrimE (I.OtherPrim "array_len", [exp e1])
-  | S.CallE ({it=S.DotE (e1, proj); _}, _, {it=S.TupE [];_})
+  | S.CallE (None, {it=S.DotE (e1, proj); _}, _, {it=S.TupE [];_})
       when T.(is_prim Text) e1.note.S.note_typ && proj.it = "size" ->
     I.PrimE (I.OtherPrim "text_len", [exp e1])
-  | S.CallE ({it=S.DotE (e1, proj); _}, _, {it=S.TupE [];_})
+  | S.CallE (None, {it=S.DotE (e1, proj); _}, _, {it=S.TupE [];_})
       when T.(is_prim Blob) e1.note.S.note_typ && proj.it = "size" ->
     I.PrimE (I.OtherPrim "blob_size", [exp e1])
   (* Normal call *)
-  | S.CallE (e1, inst, e2) ->
-    I.PrimE (I.CallPrim inst.note, [exp e1; exp e2])
+  | S.CallE (_FIXME, e1, inst, e2) ->
+    I.PrimE (I.CallPrim (inst.note, Option.(value ~default:(recordE []) (map exp _FIXME))), [exp e1; exp e2])
   | S.BlockE [] -> (unitE ()).it
   | S.BlockE [{it = S.ExpD e; _}] -> (exp e).it
   | S.BlockE ds -> I.BlockE (block (T.is_unit note.Note.typ) ds)
@@ -220,7 +220,7 @@ and exp' at note = function
   | S.WhileE (e1, e2) -> (whileE (exp e1) (exp e2)).it
   | S.LoopE (e1, None) -> I.LoopE (exp e1)
   | S.LoopE (e1, Some e2) -> (loopWhileE (exp e1) (exp e2)).it
-  | S.ForE (p, {it=S.CallE ({it=S.DotE (arr, proj); _}, _, e1); _}, e2)
+  | S.ForE (p, {it=S.CallE (None, {it=S.DotE (arr, proj); _}, _, e1); _}, e2)
       when T.is_array arr.note.S.note_typ && (proj.it = "vals" || proj.it = "keys")
     -> (transform_for_to_while p arr proj e1 e2).it
   | S.ForE (p, e1, e2) -> (forE (pat p) (exp e1) (exp e2)).it

src/mo_def/arrange.ml

@@ -87,7 +87,7 @@ module Make (Cfg : Config) = struct
         Atom (if sugar then "" else "=");
         exp e'
       ]
-    | CallE (e1, ts, e2)  -> "CallE"   $$ [exp e1] @ inst ts @ [exp e2]
+    | CallE (_FIXME, e1, ts, e2)  -> "CallE"   $$ [exp e1] @ inst ts @ [exp e2]
     | BlockE ds           -> "BlockE"  $$ List.map dec ds
     | NotE e              -> "NotE"    $$ [exp e]
     | AndE (e1, e2)       -> "AndE"    $$ [exp e1; exp e2]

src/mo_def/syntax.ml

@@ -171,8 +171,8 @@ and exp' =
   | ArrayE of mut * exp list                   (* array *)
   | IdxE of exp * exp                          (* array indexing *)
   | FuncE of string * sort_pat * typ_bind list * pat * typ option * sugar * exp  (* function *)
-  | CallE of exp * inst * exp                  (* function call *)
-  | BlockE of dec list                         (* block (with type after avoidance)*)
+  | CallE of exp option * exp * inst * exp     (* function call *)
+  | BlockE of dec list                         (* block (with type after avoidance) *)
   | NotE of exp                                (* negation *)
   | AndE of exp * exp                          (* conjunction *)
   | OrE of exp * exp                           (* disjunction *)

src/mo_frontend/definedness.ml

@@ -82,7 +82,7 @@ let rec exp msgs e : f = match e.it with
   (* Eager uses are either first-class uses of a variable: *)
   | VarE i              -> M.singleton i.it Eager
   (* Or anything that is occurring in a call (as this may call a closure): *)
-  | CallE (e1, ts, e2)  -> eagerify (exps msgs [e1; e2])
+  | CallE (_FIXME, e1, ts, e2)  -> eagerify (exps msgs [e1; e2])
   (* And break, return, throw can be thought of as calling a continuation: *)
   | BreakE (i, e)       -> eagerify (exp msgs e)
   | RetE e              -> eagerify (exp msgs e)

src/mo_frontend/effect.ml

@@ -49,7 +49,7 @@ let effect_exp (exp:Syntax.exp) : T.eff = eff exp
 (* infer the effect of an expression, assuming all sub-expressions are correctly effect-annotated es *)
 let rec infer_effect_exp (exp:Syntax.exp) : T.eff =
   match exp.it with
-  | CallE (exp1, inst, exp2) when is_async_call exp1 inst exp2 ->
+  | CallE (_FIXME, exp1, inst, exp2) when is_async_call exp1 inst exp2 ->
     T.Await
   | PrimE _
   | VarE _
@@ -81,7 +81,7 @@ let rec infer_effect_exp (exp:Syntax.exp) : T.eff =
   | IdxE (exp1, exp2)
   | RelE (_, exp1, _, exp2)
   | AssignE (exp1, exp2)
-  | CallE (exp1, _, exp2)
+  | CallE (_(*FIXME*), exp1, _, exp2)
   | AndE (exp1, exp2)
   | OrE (exp1, exp2)
   | ImpliesE (exp1, exp2)

src/mo_frontend/parser.mly

@@ -605,7 +605,7 @@ exp_post(B) :
   | e=exp_post(B) DOT x=id
     { DotE(e, x) @? at $sloc }
   | e1=exp_post(B) inst=inst e2=exp_nullary(ob)
-    { CallE(e1, inst, e2) @? at $sloc }
+    { CallE(None, e1, inst, e2) @? at $sloc }
   | e1=exp_post(B) BANG
     { BangE(e1) @? at $sloc }
   | LPAR SYSTEM e1=exp_post(B) DOT x=id RPAR
@@ -703,6 +703,12 @@ exp_un(B) :
       BreakE(x', TupE([]) @? no_region) @? at $sloc }
   | DEBUG e=exp_nest
     { DebugE(e) @? at $sloc }
+  | LPAR base=exp_post(ob)? WITH fs=seplist(exp_field, semicolon) RPAR e=exp_nest (* parentheticals to qualify message sends *)
+    { match e.it with
+      | CallE _
+      | AsyncE (Type.Fut, _, _) -> e
+      | _ -> { e with it = ObjE(Option.to_list base, fs) }
+    }
   | IF b=exp_nullary(ob) e1=exp_nest %prec IF_NO_ELSE
     { IfE(b, e1, TupE([]) @? at $sloc) @? at $sloc }
   | IF b=exp_nullary(ob) e1=exp_nest ELSE e2=exp_nest

src/mo_frontend/traversals.ml

@@ -31,8 +31,8 @@ let rec over_exp (f : exp -> exp) (exp : exp) : exp = match exp.it with
      f { exp with it = RelE (x, over_exp f exp1, y, over_exp f exp2) }
   | AssignE (exp1, exp2) ->
      f { exp with it = AssignE (over_exp f exp1, over_exp f exp2) }
-  | CallE (exp1, x, exp2) ->
-     f { exp with it = CallE (over_exp f exp1, x, over_exp f exp2) }
+  | CallE (par_opt, exp1, x, exp2) ->
+     f { exp with it = CallE (Option.map (over_exp f) par_opt, over_exp f exp1, x, over_exp f exp2) }
   | AndE (exp1, exp2) ->
      f { exp with it = AndE (over_exp f exp1, over_exp f exp2) }
   | OrE (exp1, exp2) ->

src/mo_frontend/typing.ml

@@ -947,7 +947,7 @@ let rec is_explicit_exp e =
     true
   | LitE l -> is_explicit_lit !l
   | UnE (_, _, e1) | OptE e1 | DoOptE e1
-  | ProjE (e1, _) | DotE (e1, _) | BangE e1 | IdxE (e1, _) | CallE (e1, _, _)
+  | ProjE (e1, _) | DotE (e1, _) | BangE e1 | IdxE (e1, _) | CallE (_(*FIXME: correct?*), e1, _, _)
   | LabelE (_, _, e1) | AsyncE (_, _, e1) | AwaitE (_, e1) ->
     is_explicit_exp e1
   | BinE (_, e1, _, e2) | IfE (_, e1, e2) ->
@@ -1483,7 +1483,7 @@ and infer_exp'' env exp : T.typ =
     end;
     let ts1 = match pat.it with TupP _ -> T.seq_of_tup t1 | _ -> [t1] in
     T.Func (sort, c, T.close_binds cs tbs, List.map (T.close cs) ts1, List.map (T.close cs) ts2)
-  | CallE (exp1, inst, exp2) ->
+  | CallE (_FIXME, exp1, inst, exp2) ->
     infer_call env exp1 inst exp2 exp.at None
   | BlockE decs ->
     let t, _ = infer_block env decs exp.at false in
@@ -1868,7 +1868,7 @@ and check_exp' env0 t exp : T.typ =
     in
     check_exp_strong (adjoin_vals env' ve2) t2 exp;
     t
-  | CallE (exp1, inst, exp2), _ ->
+  | CallE (_FIXME, exp1, inst, exp2), _ ->
     let t' = infer_call env exp1 inst exp2 exp.at (Some t) in
     if not (T.sub t' t) then
       local_error env0 exp.at "M0096"

src/mo_interpreter/interpret.ml

@@ -570,7 +570,7 @@ and interpret_exp_mut env exp (k : V.value V.cont) =
       | T.Shared _ -> make_message env name exp.note.note_typ v
       | T.Local -> v
     in k v'
-  | CallE (exp1, typs, exp2) ->
+  | CallE (_FIXME, exp1, typs, exp2) ->
     interpret_exp env exp1 (fun v1 ->
       interpret_exp env exp2 (fun v2 ->
         let call_conv, f = V.as_func v1 in

src/viper/trans.ml

@@ -416,7 +416,7 @@ and stmt ctxt (s : M.exp) : seqn =
   | M.AssertE (M.Runtime, e) ->
     !!([],
        [ !!(AssumeS (exp ctxt e)) ])
-  | M.(CallE({it = VarE m; _}, inst, {it = TupE args; _})) ->
+  | M.(CallE(_, {it = VarE m; _}, inst, {it = TupE args; _})) ->
     !!([],
        [ !!(MethodCallS ([], id m,
        let self_var = self ctxt m.at in

test/run-drun/clone.mo

@@ -8,8 +8,8 @@ actor Cloner {
    // passing itself as first argument, using available funds
    public shared func makeCloneable(init : Nat): async Lib.Cloneable {
       let accepted = Cycles.accept<system>(Cycles.available());
-      Cycles.add<system>(accepted);
-      await Lib.Cloneable(makeCloneable, init);
+      Cycles.add<system>(accepted); // FIXME: remove
+      await (with cycles = accepted) Lib.Cloneable(makeCloneable, init);
    };
 
    public shared func test() : async () {