[kernel][core] IO and Async optimizations (#973)

I noticed a few regressions with recent changes while inspecting
benchmarks

Author: fwbrasil

kyo-core/shared/src/main/scala/kyo/IO.scala

@@ -42,7 +42,7 @@ object IO:
       *   The suspended computation wrapped in an IO effect.
       */
     inline def apply[A, S](inline f: Safepoint ?=> A < S)(using inline frame: Frame): A < (IO & S) =
-        Effect.defer(f)
+        Effect.deferInline(f)
 
     /** Ensures that a finalizer is run after the main computation, regardless of success or failure.
       *
@@ -69,7 +69,7 @@ object IO:
     object Unsafe:
 
         inline def apply[A, S](inline f: AllowUnsafe ?=> A < S)(using inline frame: Frame): A < (IO & S) =
-            Effect.defer {
+            Effect.deferInline {
                 import AllowUnsafe.embrace.danger
                 f
             }

kyo-core/shared/src/main/scala/kyo/scheduler/IOPromise.scala

@@ -130,7 +130,7 @@ private[kyo] class IOPromise[+E, +A](init: State[E, A]) extends Safepoint.Interc
                 case l: Linked[E, A] @unchecked =>
                     onCompleteLoop(l.p)
                 case v =>
-                    IOPromise.eval(f, v.asInstanceOf[Result[E, A]])
+                    IOPromise.eval(f(v.asInstanceOf[Result[E, A]]))
         onCompleteLoop(this)
     end onComplete
 
@@ -245,10 +245,10 @@ private[kyo] object IOPromise:
             new Pending[E, A]:
                 def waiters: Int = self.waiters + 1
                 def interrupt[E2 >: E](error: Error[E2]) =
-                    eval(f, error.asInstanceOf[Error[E]])
+                    eval(f(error.asInstanceOf[Error[E]]))
                     self
                 def run[E2 >: E, A2 >: A](v: Result[E2, A2]) =
-                    eval(f, v.asInstanceOf[Result[E, A]])
+                    eval(f(v.asInstanceOf[Result[E, A]]))
                     self
                 end run
 
@@ -265,7 +265,7 @@ private[kyo] object IOPromise:
         inline def onInterrupt(inline f: Error[E] => Unit): Pending[E, A] =
             new Pending[E, A]:
                 def interrupt[E2 >: E](error: Error[E2]) =
-                    eval(f, error.asInstanceOf[Error[E]])
+                    eval(f(error.asInstanceOf[Error[E]]))
                     self
                 def waiters: Int = self.waiters + 1
                 def run[E2 >: E, A2 >: A](v: Result[E2, A2]) =
@@ -319,8 +319,8 @@ private[kyo] object IOPromise:
         end Empty
     end Pending
 
-    private inline def eval[A, B](inline f: A => Unit, value: A): Unit =
-        try f(value)
+    private inline def eval[A](inline f: => Unit): Unit =
+        try f
         catch
             case ex if NonFatal(ex) =>
                 given Frame = Frame.internal

kyo-core/shared/src/main/scala/kyo/scheduler/IOTask.scala

@@ -34,6 +34,8 @@ sealed private[kyo] class IOTask[Ctx, E, A] private (
 
     private inline def erasedAbortTag = Tag[Abort[Any]].asInstanceOf[Tag[Abort[E]]]
 
+    private inline def locally[A](inline f: A): A = f
+
     final private def eval(startMillis: Long, clock: InternalClock)(using Safepoint) =
         try
             curr = Boundary.restoring(trace, this) {

kyo-kernel/shared/src/main/scala/kyo/kernel/Effect.scala

@@ -61,7 +61,11 @@ object Effect:
         end try
     end catching
 
-    private[kyo] def defer[A, S](f: Safepoint ?=> A < S)(using _frame: Frame): A < S =
+    private[kyo] def defer[A, S](f: Safepoint ?=> A < S)(using Frame): A < S =
+        deferInline(f)
+
+    @nowarn("msg=anonymous")
+    private[kyo] inline def deferInline[A, S](inline f: Safepoint ?=> A < S)(using inline _frame: Frame): A < S =
         new KyoDefer[A, S]:
             def frame = _frame
             def apply(v: Unit, context: Context)(using Safepoint) =