JS transform suspend with Result return type to Promise

[Yentis]

I was wondering if it would be possible to have a transformer that converts
suspend fun foo(): Result<String>
to
fun foo(): Promise<String>
instead of
fun foo(): Promise<Result<String>>

I was thinking something like

fun <T> toAsync(block: suspend () -> Result<T>): Promise<T> {
    return coroutineScope.promise { block().getOrThrow() }
}

which technically works as a custom transformer but the return type isn't correct

[ForteScarlet]

Honestly, it's complicated. The convention for transformer functions is that the type of the first parameter block must be () -> T, not any kind of anomalous structure. The transformer's job is to bridge the suspend and non-suspend functions, not to transform the types between them.
Therefore, the return type of the transformed composite function should also be fully correlated (identical or inclusive) with the original function, not partially correlated.

Calling the transformer is relatively easy on the compiler, as it doesn't check the type of the block strictly - so it just has to compile. But the return value depends on T -- that is, the return value type of the source function.

Currently, T is essentially a known type to the compiler plugin. If we wanted to support something like Result<T> -> Promise<T>, List<T> -> Array<T>, then T would be unknown to the compiler plugin. What about List<List<T>> -> Sequence<T>?

Unfortunately, I haven't figured out a flexible way to implement it yet.

[Yentis]

Maybe the generic type for transformReturnType (assuming transformReturnTypeGeneric is true) can be specified in the annotation somehow, something like:

annotation class JsPromiseResult<T>(
    val baseName: String = "",
    val suffix: String = "Async",
    val asProperty: Boolean = false,
)

@JsPromiseResult<String>
@JsExport.Ignore
suspend fun test(): Result<String> {
    delay(500)
    return Result.success("")
}

Or as an extra property

[ForteScarlet]

I don't think directly marking generics on annotations is feasible – currently, generics on annotations can't be made generic. Therefore, code like below wouldn't be supported:

@JsPromiseResult<T>
@JsExport.Ignore
suspend <T> fun test(): Result<T> {
    ...
}

...or so I wanted to say, but it seems I misremembered. After a quick test, it appears that generics on the annotation itself can indeed be made generic (at least according to the IDE). This is actually an interesting approach, and I might try to verify it properly when I have time.