Use @async attribute instead of an external.

Author: cristianoc

example-async/lib/js/src/AA.js

@@ -1,9 +1,4 @@
 // Boilerplate currently handwritten
-external async0: Js.Fn.arity0<'r> => Js.Fn.arity0<Js.Promise.t<'r>> = "?async"
-external async1: Js.Fn.arity1<'a1 => 'r> => Js.Fn.arity1<'a1 => Js.Promise.t<'r>> = "?async"
-external async2: Js.Fn.arity2<('a1, 'a2) => 'r> => Js.Fn.arity2<('a1, 'a2) => Js.Promise.t<'r>> =
-  "?async"
-
 external await: Js.Promise.t<'a> => 'a = "?await"
 
 type testable = (. unit) => Js.Promise.t<unit>
@@ -17,20 +12,24 @@ let addTest1 = (t, x) => tests->Js.Array2.push((. ()) => t(. x))->ignore
 //
 // Basic tests
 
-let foo = async2((. x, y) => x + y)
+let foo = @async (. x, y) => x + y
 
-let bar = async1((. ff) => {
-  let a = await(ff(. 3, 4))
-  let b = await(foo(. 5, 6))
-  a + b
-})
+let bar =
+  @async
+  (. ff) => {
+    let a = await(ff(. 3, 4))
+    let b = await(foo(. 5, 6))
+    a + b
+  }
 
-let baz = async0((. ()) => await(bar(. foo)))
+let baz = @async (. ()) => await(bar(. foo))
 
-let testBaz: testable = async0((. ()) => {
-  let n = await(baz(.))
-  Js.log2("baz returned", n)
-})
+let testBaz: testable =
+  @async
+  (. ()) => {
+    let n = await(baz(.))
+    Js.log2("baz returned", n)
+  }
 
 testBaz->addTest
 
@@ -40,18 +39,19 @@ testBaz->addTest
 
 exception E(int)
 
-let e1: testable = async0((. ()) => raise(E(1000)))
-let e2: testable = async0((. ()) => Js.Exn.raiseError("Some JS error"))
-let e3: testable = async0((. ()) => await(e1(.)))
-let e4: testable = async0((. ()) => await(e2(.)))
+let e1: testable = @async (. ()) => raise(E(1000))
+let e2: testable = @async (. ()) => Js.Exn.raiseError("Some JS error")
+let e3: testable = @async (. ()) => await(e1(.))
+let e4: testable = @async (. ()) => await(e2(.))
 let e5: testable = %raw(`function() { return Promise.reject(new Error('fail')) }`)
 
-let testTryCatch = async1((. fn) =>
-  try await(fn(.)) catch {
-  | E(n) => Js.log2("testTryCatch: E", n)
-  | JsError(_) => Js.log("testTryCatch: JsError")
-  }
-)
+let testTryCatch =
+  @async
+  (. fn) =>
+    try await(fn(.)) catch {
+    | E(n) => Js.log2("testTryCatch: E", n)
+    | JsError(_) => Js.log("testTryCatch: JsError")
+    }
 
 testTryCatch->addTest1(e1)
 testTryCatch->addTest1(e2)
@@ -63,28 +63,32 @@ testTryCatch->addTest1(e5)
 //
 // Check for nested promise
 
-let singlePromise = async1((. x) => x + 1)
+let singlePromise = @async (. x) => x + 1
 
-let nestedPromise = async1((. x) => {
-  let resolve = x => [Js.Promise.resolve(x)]
-  let _result = singlePromise(. x + 1)->resolve
-  32
-})
+let nestedPromise =
+  @async
+  (. x) => {
+    let resolve = x => [Js.Promise.resolve(x)]
+    let _result = singlePromise(. x + 1)->resolve
+    32
+  }
 
 //
 //
 // Test error handling in fetch
 
 let explainError: unknown => string = %raw(`(e)=>e.toString()`)
 
-let testFetch = async1((. url) => {
-  switch await(Fetch.fetch(url)) {
-  | response =>
-    let status = response->Fetch.Response.status
-    Js.log2("Fetch returned status:", status)
-  | exception JsError(e) => Js.log2("Fetch returned an error:", e->explainError)
+let testFetch =
+  @async
+  (. url) => {
+    switch await(Fetch.fetch(url)) {
+    | response =>
+      let status = response->Fetch.Response.status
+      Js.log2("Fetch returned status:", status)
+    | exception JsError(e) => Js.log2("Fetch returned an error:", e->explainError)
+    }
   }
-})
 
 testFetch->addTest1("https://www.google.com/sdkjdkghdsg")
 testFetch->addTest1("https://www.google.comsdkjdkghdsg")
@@ -93,12 +97,14 @@ testFetch->addTest1("https://www.google.comsdkjdkghdsg")
 //
 // Run tests
 
-let runAllTests = async0((. ()) => {
-  for i in 0 to Array.length(tests) - 1 {
-    await(tests[i](.))
+let runAllTests =
+  @async
+  (. ()) => {
+    for i in 0 to Array.length(tests) - 1 {
+      await(tests[i](.))
+    }
+    // Note: this is no good, as await is inside a closure
+    //  tests->Js.Array2.forEach(test => await(test(.)))
   }
-  // Note: this is no good, as await is inside a closure
-  //  tests->Js.Array2.forEach(test => await(test(.)))
-})
 
 runAllTests(.)->ignore

example-async/src/AA.res

@@ -142,10 +142,11 @@ and expression_desc =
   *)
   | New of expression * expression list option (* TODO: option remove *)
   | Var of vident
-  | Fun of bool * ident list * block * Js_fun_env.t * bool
+  | Fun of bool * ident list * block * Js_fun_env.t * bool * bool
   (* The first parameter by default is false,
      it will be true when it's a method
-     The last pararemter [true] return unit
+     The second-last pararemter [true] return unit
+     The last pararemter [true] means async
   *)
   | Str of {delim: string option; txt: string}
   (* A string is UTF-8 encoded, and may contain

jscomp/core/j.ml

@@ -53,7 +53,7 @@ let free_variables (stats : idents_stats) =
     expression =
       (fun self exp ->
         match exp.expression_desc with
-        | Fun (_, _, _, env, _)
+        | Fun (_, _, _, env, _, _)
         (* a optimization to avoid walking into funciton again
             if it's already comuted
         *) ->

jscomp/core/js_analyzer.ml

@@ -297,7 +297,7 @@ let rec try_optimize_curry cxt f len function_id =
   Curry_gen.pp_optimize_curry f len;
   P.paren_group f 1 (fun _ -> expression ~level:1 cxt f function_id)
 
-and pp_function ~return_unit ~is_method cxt (f : P.t) ~fn_state
+and pp_function ~return_unit ~async ~is_method cxt (f : P.t) ~fn_state
     (l : Ident.t list) (b : J.block) (env : Js_fun_env.t) : cxt =
   match b with
   | [
@@ -415,7 +415,9 @@ and pp_function ~return_unit ~is_method cxt (f : P.t) ~fn_state
                     ->
                       P.string f "async ";
                       b
-                  | _ -> b
+                  | _ ->
+                    let () = if async then P.string f "async " in
+                    b
                 in
                 P.string f L.function_;
                 P.space f;
@@ -540,10 +542,10 @@ and expression_desc cxt ~(level : int) f x : cxt =
           let cxt = expression ~level:0 cxt f e1 in
           comma_sp f;
           expression ~level:0 cxt f e2)
-  | Fun (is_method, l, b, env, return_unit) ->
+  | Fun (is_method, l, b, env, return_unit, async) ->
       (* TODO: dump for comments *)
       pp_function ~is_method cxt f ~fn_state:default_fn_exp_state l b env
-        ~return_unit
+        ~return_unit ~async
       (* TODO:
          when [e] is [Js_raw_code] with arity
          print it in a more precise way
@@ -564,10 +566,10 @@ and expression_desc cxt ~(level : int) f x : cxt =
                       | [
                        {
                          expression_desc =
-                           Fun (is_method, l, b, env, return_unit);
+                           Fun (is_method, l, b, env, return_unit, async);
                        };
                       ] ->
-                          pp_function ~is_method ~return_unit cxt f
+                          pp_function ~is_method ~return_unit ~async cxt f
                             ~fn_state:(No_name { single_arg = true })
                             l b env
                       | _ -> arguments cxt f el)
@@ -912,8 +914,8 @@ and variable_declaration top cxt f (variable : J.variable_declaration) : cxt =
           statement_desc top cxt f (J.Exp e)
       | _ -> (
           match e.expression_desc with
-          | Fun (is_method, params, b, env, return_unit) ->
-              pp_function ~is_method cxt f ~return_unit
+          | Fun (is_method, params, b, env, return_unit, async) ->
+              pp_function ~is_method cxt f ~return_unit ~async
                 ~fn_state:(if top then Name_top name else Name_non_top name)
                 params b env
           | _ ->
@@ -1139,9 +1141,9 @@ and statement_desc top cxt f (s : J.statement_desc) : cxt =
       cxt
   | Return e -> (
       match e.expression_desc with
-      | Fun (is_method, l, b, env, return_unit) ->
+      | Fun (is_method, l, b, env, return_unit, async) ->
           let cxt =
-            pp_function ~return_unit ~is_method cxt f ~fn_state:Is_return l b
+            pp_function ~return_unit ~is_method ~async cxt f ~fn_state:Is_return l b
               env
           in
           semi f;

jscomp/core/js_dump.ml

@@ -197,20 +197,20 @@ let unit : t = { expression_desc = Undefined; comment = None }
    [Js_fun_env.empty] is a mutable state ..
 *)
 
-let ocaml_fun ?comment ?immutable_mask ~return_unit params block : t =
+let ocaml_fun ?comment ?immutable_mask ~return_unit ~async params block : t =
   let len = List.length params in
   {
     expression_desc =
       Fun
-        (false, params, block, Js_fun_env.make ?immutable_mask len, return_unit);
+        (false, params, block, Js_fun_env.make ?immutable_mask len, return_unit, async);
     comment;
   }
 
 let method_ ?comment ?immutable_mask ~return_unit params block : t =
   let len = List.length params in
   {
     expression_desc =
-      Fun (true, params, block, Js_fun_env.make ?immutable_mask len, return_unit);
+      Fun (true, params, block, Js_fun_env.make ?immutable_mask len, return_unit, false);
     comment;
   }
 
@@ -484,7 +484,7 @@ let bytes_length ?comment (e : t) : t =
 
 let function_length ?comment (e : t) : t =
   match e.expression_desc with
-  | Fun (b, params, _, _, _) ->
+  | Fun (b, params, _, _, _, _) ->
       let params_length = List.length params in
       int ?comment
         (Int32.of_int (if b then params_length - 1 else params_length))
@@ -1158,7 +1158,7 @@ let of_block ?comment ?e block : t =
                 Ext_list.append block
                   [ { J.statement_desc = Return e; comment } ]),
             Js_fun_env.make 0,
-            return_unit );
+            return_unit, (* async *) false);
     }
     []
 

jscomp/core/js_exp_make.ml

@@ -88,6 +88,7 @@ val ocaml_fun :
   ?comment:string ->
   ?immutable_mask:bool array ->
   return_unit:bool ->
+  async:bool ->
   J.ident list ->
   J.block ->
   t

jscomp/core/js_exp_make.mli

@@ -146,7 +146,7 @@ class fold =
       | Var _x0 ->
           let _self = _self#vident _x0 in
           _self
-      | Fun (_x0, _x1, _x2, _x3, _x4) ->
+      | Fun (_x0, _x1, _x2, _x3, _x4, _x5) ->
           let _self = list (fun _self -> _self#ident) _self _x1 in
           let _self = _self#block _x2 in
           _self

jscomp/core/js_fold.ml

@@ -137,7 +137,7 @@ let record_scope_pass =
     expression =
       (fun self state x ->
         match x.expression_desc with
-        | Fun (_method_, params, block, env, _return_unit) ->
+        | Fun (_method_, params, block, env, _return_unit, _async) ->
             (* Function is the only place to introduce a new scope in
                 ES5
                 TODO: check

jscomp/core/js_pass_scope.ml

@@ -165,7 +165,7 @@ let subst (export_set : Set_ident.t) stats =
                      Some
                        {
                          expression_desc =
-                           Fun (false, params, block, env, _return_unit);
+                           Fun (false, params, block, env, _return_unit, _async);
                          comment = _;
                        };
                    (*TODO: don't inline method tail call yet,
@@ -200,7 +200,7 @@ let subst (export_set : Set_ident.t) stats =
                    Call
                      ( {
                          expression_desc =
-                           Fun (false, params, block, env, _return_unit);
+                           Fun (false, params, block, env, _return_unit, _async);
                        },
                        args,
                        _info );

jscomp/core/js_pass_tailcall_inline.ml

@@ -152,7 +152,7 @@ let expression_desc : 'a. ('a, expression_desc) fn =
   | Var _x0 ->
       let st = _self.vident _self st _x0 in
       st
-  | Fun (_x0, _x1, _x2, _x3, _x4) ->
+  | Fun (_x0, _x1, _x2, _x3, _x4, _x5) ->
       let st = list _self.ident _self st _x1 in
       let st = _self.block _self st _x2 in
       st

jscomp/core/js_record_fold.ml

@@ -118,7 +118,7 @@ let expression_desc : expression_desc fn =
       _self.expression _self _x0;
       option (fun _self arg -> list _self.expression _self arg) _self _x1
   | Var _x0 -> _self.vident _self _x0
-  | Fun (_x0, _x1, _x2, _x3, _x4) ->
+  | Fun (_x0, _x1, _x2, _x3, _x4, _x5) ->
       list _self.ident _self _x1;
       _self.block _self _x2
   | Str _ -> ()

jscomp/core/js_record_iter.ml

@@ -150,10 +150,10 @@ let expression_desc : expression_desc fn =
   | Var _x0 ->
       let _x0 = _self.vident _self _x0 in
       Var _x0
-  | Fun (_x0, _x1, _x2, _x3, _x4) ->
+  | Fun (_x0, _x1, _x2, _x3, _x4, _x5) ->
       let _x1 = list _self.ident _self _x1 in
       let _x2 = _self.block _self _x2 in
-      Fun (_x0, _x1, _x2, _x3, _x4)
+      Fun (_x0, _x1, _x2, _x3, _x4, _x5)
   | Str _ as v -> v
   | Raw_js_code _ as v -> v
   | Array (_x0, _x1) ->