support @apply.transforms for applying transforms, and add migrations for Js_promise and Js_promise2

Author: zth

packages/@rescript/runtime/Js_promise.res

@@ -32,7 +32,16 @@ https://rescript-lang.org/docs/manual/latest/promise#promise-legacy
 
 @@warning("-103")
 
+@deprecated({
+  reason: "Use `promise` directly instead.",
+  migrate: %replace.type(: promise),
+})
 type t<+'a> = promise<'a>
+
+@deprecated({
+  reason: "Use `exn` directly instead.",
+  migrate: %replace.type(: exn),
+})
 type error = Js_promise2.error
 
 /*
@@ -43,29 +52,75 @@ type error
 ```
 */
 
+@deprecated({
+  reason: "Use `Promise.make` instead.",
+  migrate: Promise.make(
+    @apply.transforms(["labelledToUnlabelledArgumentsInFnDefinition"])
+    %insert.unlabelledArgument(0),
+  ),
+})
 @new
 external make: ((~resolve: 'a => unit, ~reject: exn => unit) => unit) => promise<'a> = "Promise"
 
 /* `make (fun resolve reject -> .. )` */
-@val @scope("Promise") external resolve: 'a => promise<'a> = "resolve"
-@val @scope("Promise") external reject: exn => promise<'a> = "reject"
-
-@val @scope("Promise") external all: array<promise<'a>> => promise<array<'a>> = "all"
-
-@val @scope("Promise") external all2: ((promise<'a0>, promise<'a1>)) => promise<('a0, 'a1)> = "all"
-
-@val @scope("Promise")
+@deprecated({
+  reason: "Use `Promise.resolve` instead.",
+  migrate: Promise.resolve(),
+})
+@val
+@scope("Promise")
+external resolve: 'a => promise<'a> = "resolve"
+@deprecated({
+  reason: "Use `Promise.reject` instead.",
+  migrate: Promise.reject(),
+})
+@val
+@scope("Promise")
+external reject: exn => promise<'a> = "reject"
+
+@deprecated({
+  reason: "Use `Promise.all` instead.",
+  migrate: Promise.all(),
+})
+@val
+@scope("Promise")
+external all: array<promise<'a>> => promise<array<'a>> = "all"
+
+@deprecated({
+  reason: "Use `Promise.all2` instead.",
+  migrate: Promise.all2(),
+})
+@val
+@scope("Promise")
+external all2: ((promise<'a0>, promise<'a1>)) => promise<('a0, 'a1)> = "all"
+
+@deprecated({
+  reason: "Use `Promise.all3` instead.",
+  migrate: Promise.all3(),
+})
+@val
+@scope("Promise")
 external all3: ((promise<'a0>, promise<'a1>, promise<'a2>)) => promise<('a0, 'a1, 'a2)> = "all"
 
-@val @scope("Promise")
+@deprecated({
+  reason: "Use `Promise.all4` instead.",
+  migrate: Promise.all4(),
+})
+@val
+@scope("Promise")
 external all4: ((promise<'a0>, promise<'a1>, promise<'a2>, promise<'a3>)) => promise<(
   'a0,
   'a1,
   'a2,
   'a3,
 )> = "all"
 
-@val @scope("Promise")
+@deprecated({
+  reason: "Use `Promise.all5` instead.",
+  migrate: Promise.all5(),
+})
+@val
+@scope("Promise")
 external all5: ((promise<'a0>, promise<'a1>, promise<'a2>, promise<'a3>, promise<'a4>)) => promise<(
   'a0,
   'a1,
@@ -74,18 +129,44 @@ external all5: ((promise<'a0>, promise<'a1>, promise<'a2>, promise<'a3>, promise
   'a4,
 )> = "all"
 
-@val @scope("Promise")
+@deprecated({
+  reason: "Use `Promise.all6` instead.",
+  migrate: Promise.all6(),
+})
+@val
+@scope("Promise")
 external all6: (
   (promise<'a0>, promise<'a1>, promise<'a2>, promise<'a3>, promise<'a4>, promise<'a5>)
 ) => promise<('a0, 'a1, 'a2, 'a3, 'a4, 'a5)> = "all"
 
-@val @scope("Promise") external race: array<promise<'a>> => promise<'a> = "race"
-
-@send external then_: (promise<'a>, 'a => promise<'b>) => promise<'b> = "then"
+@deprecated({
+  reason: "Use `Promise.race` instead.",
+  migrate: Promise.race(),
+})
+@val
+@scope("Promise")
+external race: array<promise<'a>> => promise<'a> = "race"
+
+@deprecated({
+  reason: "Use `Promise.then` instead.",
+  migrate: Promise.then(),
+})
+@send
+external then_: (promise<'a>, 'a => promise<'b>) => promise<'b> = "then"
+@deprecated({
+  reason: "Use `Promise.then` instead.",
+  migrate: Promise.then(%insert.unlabelledArgument(1), %insert.unlabelledArgument(0)),
+  migrateInPipeChain: Promise.then(%insert.unlabelledArgument(0)),
+})
 let then_ = (arg1, obj) => then_(obj, arg1)
 
 @send
 external catch: (promise<'a>, error => promise<'a>) => promise<'a> = "catch"
+@deprecated({
+  reason: "Use `Promise.catch` instead.",
+  migrate: Promise.catch(%insert.unlabelledArgument(1), %insert.unlabelledArgument(0)),
+  migrateInPipeChain: Promise.catch(%insert.unlabelledArgument(0)),
+})
 let catch = (arg1, obj) => catch(obj, arg1)
 /* ` p|> catch handler`
     Note in JS the returned promise type is actually runtime dependent,

packages/@rescript/runtime/Js_promise2.res

@@ -1,42 +1,100 @@
+@deprecated({
+  reason: "Use `promise` directly instead.",
+  migrate: %replace.type(: promise),
+})
 type t<+'a> = promise<'a>
 type error
 
 /** Type-safe t-first then */
+@deprecated({
+  reason: "Use `Promise.then` instead.",
+  migrate: Promise.then(),
+})
 let then: (promise<'a>, 'a => promise<'b>) => promise<'b> = %raw(`
   function(p, cont) {
     return Promise.resolve(p).then(cont)
   }
   `)
 
 /** Type-safe t-first catch */
+@deprecated({
+  reason: "Use `Promise.catch` instead.",
+  migrate: Promise.catch(),
+})
 let catch: (promise<'a>, error => promise<'a>) => promise<'a> = %raw(`
     function(p, cont) {
       return Promise.resolve(p).catch(cont)
     }
     `)
 
+@deprecated({
+  reason: "Use `Promise.make` instead.",
+  migrate: Promise.make(
+    @apply.transforms(["labelledToUnlabelledArgumentsInFnDefinition"])
+    %insert.unlabelledArgument(0),
+  ),
+})
 @new
 external make: ((~resolve: 'a => unit, ~reject: exn => unit) => unit) => promise<'a> = "Promise"
 
-@val @scope("Promise") external resolve: 'a => promise<'a> = "resolve"
-@val @scope("Promise") external reject: exn => promise<'a> = "reject"
+@deprecated({
+  reason: "Use `Promise.resolve` instead.",
+  migrate: Promise.resolve(),
+})
+@val
+@scope("Promise")
+external resolve: 'a => promise<'a> = "resolve"
+@deprecated({
+  reason: "Use `Promise.reject` instead.",
+  migrate: Promise.reject(),
+})
+@val
+@scope("Promise")
+external reject: exn => promise<'a> = "reject"
 
-@val @scope("Promise") external all: array<promise<'a>> => promise<array<'a>> = "all"
+@deprecated({
+  reason: "Use `Promise.all` instead.",
+  migrate: Promise.all(),
+})
+@val
+@scope("Promise")
+external all: array<promise<'a>> => promise<array<'a>> = "all"
 
-@val @scope("Promise") external all2: ((promise<'a0>, promise<'a1>)) => promise<('a0, 'a1)> = "all"
+@deprecated({
+  reason: "Use `Promise.all2` instead.",
+  migrate: Promise.all2(),
+})
+@val
+@scope("Promise")
+external all2: ((promise<'a0>, promise<'a1>)) => promise<('a0, 'a1)> = "all"
 
-@val @scope("Promise")
+@deprecated({
+  reason: "Use `Promise.all3` instead.",
+  migrate: Promise.all3(),
+})
+@val
+@scope("Promise")
 external all3: ((promise<'a0>, promise<'a1>, promise<'a2>)) => promise<('a0, 'a1, 'a2)> = "all"
 
-@val @scope("Promise")
+@deprecated({
+  reason: "Use `Promise.all4` instead.",
+  migrate: Promise.all4(),
+})
+@val
+@scope("Promise")
 external all4: ((promise<'a0>, promise<'a1>, promise<'a2>, promise<'a3>)) => promise<(
   'a0,
   'a1,
   'a2,
   'a3,
 )> = "all"
 
-@val @scope("Promise")
+@deprecated({
+  reason: "Use `Promise.all5` instead.",
+  migrate: Promise.all5(),
+})
+@val
+@scope("Promise")
 external all5: ((promise<'a0>, promise<'a1>, promise<'a2>, promise<'a3>, promise<'a4>)) => promise<(
   'a0,
   'a1,
@@ -45,12 +103,23 @@ external all5: ((promise<'a0>, promise<'a1>, promise<'a2>, promise<'a3>, promise
   'a4,
 )> = "all"
 
-@val @scope("Promise")
+@deprecated({
+  reason: "Use `Promise.all6` instead.",
+  migrate: Promise.all6(),
+})
+@val
+@scope("Promise")
 external all6: (
   (promise<'a0>, promise<'a1>, promise<'a2>, promise<'a3>, promise<'a4>, promise<'a5>)
 ) => promise<('a0, 'a1, 'a2, 'a3, 'a4, 'a5)> = "all"
 
-@val @scope("Promise") external race: array<promise<'a>> => promise<'a> = "race"
+@deprecated({
+  reason: "Use `Promise.race` instead.",
+  migrate: Promise.race(),
+})
+@val
+@scope("Promise")
+external race: array<promise<'a>> => promise<'a> = "race"
 
 external unsafe_async: 'a => promise<'a> = "%identity"
 external unsafe_await: promise<'a> => 'a = "%await"

tests/tools_tests/src/expected/StdlibMigration_Promise.res.expected

@@ -0,0 +1,40 @@
+let p1 = Promise.resolve(1)
+let p2 = Promise.reject(Failure("err"))
+
+let all1 = Promise.all([Promise.resolve(1), Promise.resolve(2)])
+let all2 = Promise.all2((Promise.resolve(1), Promise.resolve(2)))
+let all3 = Promise.all3((Promise.resolve(1), Promise.resolve(2), Promise.resolve(3)))
+let all4 = Promise.all4((
+  Promise.resolve(1),
+  Promise.resolve(2),
+  Promise.resolve(3),
+  Promise.resolve(4),
+))
+let all5 = Promise.all5((
+  Promise.resolve(1),
+  Promise.resolve(2),
+  Promise.resolve(3),
+  Promise.resolve(4),
+  Promise.resolve(5),
+))
+let all6 = Promise.all6((
+  Promise.resolve(1),
+  Promise.resolve(2),
+  Promise.resolve(3),
+  Promise.resolve(4),
+  Promise.resolve(5),
+  Promise.resolve(6),
+))
+
+let race1 = Promise.race([Promise.resolve(10), Promise.resolve(20)])
+
+let thenPipe = Promise.resolve(1)->Js.Promise.then_(x => Promise.resolve(x + 1), _)
+let thenDirect = Js.Promise.then_(x => Promise.resolve(x + 1), Promise.resolve(1))
+
+// Type alias migration
+external p: promise<int> = "p"
+
+// let catchPipe = Js.Promise.resolve(1)->Js.Promise.catch(_e => Js.Promise.resolve(0), _)
+// let catchDirect = Js.Promise.catch(_e => Js.Promise.resolve(0), Js.Promise.resolve(1))
+let make1 = Promise.make((resolve, reject) => resolve(1))
+

tests/tools_tests/src/expected/StdlibMigration_Promise2.res.expected

@@ -0,0 +1,41 @@
+let p1 = Promise.resolve(1)
+let p2 = Promise.reject(Failure("err"))
+
+let all1 = Promise.all([Promise.resolve(1), Promise.resolve(2)])
+let all2 = Promise.all2((Promise.resolve(1), Promise.resolve(2)))
+let all3 = Promise.all3((Promise.resolve(1), Promise.resolve(2), Promise.resolve(3)))
+
+let all4 = Promise.all4((
+  Promise.resolve(1),
+  Promise.resolve(2),
+  Promise.resolve(3),
+  Promise.resolve(4),
+))
+let all5 = Promise.all5((
+  Promise.resolve(1),
+  Promise.resolve(2),
+  Promise.resolve(3),
+  Promise.resolve(4),
+  Promise.resolve(5),
+))
+let all6 = Promise.all6((
+  Promise.resolve(1),
+  Promise.resolve(2),
+  Promise.resolve(3),
+  Promise.resolve(4),
+  Promise.resolve(5),
+  Promise.resolve(6),
+))
+
+let race1 = Promise.race([Promise.resolve(10), Promise.resolve(20)])
+
+let thenPipe = Promise.resolve(1)->Js.Promise2.then(x => Promise.resolve(x + 1))
+let thenDirect = Js.Promise2.then(Promise.resolve(1), x => Promise.resolve(x + 1))
+
+// Type alias migration
+external p2: promise<int> = "p2"
+
+// let catchPipe = Js.Promise2.resolve(1)->Js.Promise2.catch(_e => Js.Promise2.resolve(0))
+// let catchDirect = Js.Promise2.catch(Js.Promise2.resolve(1), _e => Js.Promise2.resolve(0))
+let make1 = Promise.make((resolve, reject) => resolve(1))
+