defer blocks discarding unit effects

[johnhungerford]

Minimized example

import kyo.*

def runInner: Unit < Async = defer:
  await(Console.println("test"))

@main def main(): Unit =
  import AllowUnsafe.embrace.danger
  val _ =  KyoApp.Unsafe.runAndBlock(Duration.Infinity)(runInner)

scalac options in build.sbt:

scalacOptions ++= Seq(
  "-Wvalue-discard", 
  "-Wnonunit-statement", 
  "-Wconf:msg=(discarded.*value|pure.*statement):error",
),

Expected result

Should cause compiler error: discarded non-Unit value of type Unit < (kyo.IO & kyo.Abort[java.io.IOException]) (If the defer block in runInner is replaced with a direct call to Console.println, this is what happens)

Actual result

No compiler error or warnings, and the application runs without displaying anything message

[johnhungerford]

Workaround: annotating runInner as Any < ... will cause the compiler to catch the error. It seems to be a problem only for unit values. Anyone working with kyo-direct might consider using Any in place of Unit until some solution is found.

[fwbrasil]

/bounty 100

[fwbrasil]

I took a look at this and couldn't find a way to fix it. It seems the compiler just bypasses the check. cc/ @rssh

[ahoy-jon]

I may have found something similar

//> using scala 3.7.0-RC3

//> using option -Wvalue-discard
//> using option -Wnonunit-statement
//> using option -Wconf:msg=(unused.*value|discarded.*value|pure.*statement):error
//> using option -language:strictEquality

//> using dep io.getkyo::kyo-prelude::0.18.0
//> using dep io.getkyo::kyo-core::0.18.0
//> using dep io.getkyo::kyo-direct::0.18.0
//> using dep io.getkyo::kyo-combinators::0.18.0

import kyo.*

object KyoAppTest extends KyoApp {
  val print: Unit < IO = Console.printLine("YO")
  val fail: Unit < Abort[Exception] = Abort.fail(new Exception("fail"))

  val prg = print *> fail

  val prgWithDefer = defer {
    print.now
    fail.now
  }

  val oups: Unit < (IO & Abort[Exception]) = defer {
    Console.printLine("YO").now
    Abort.fail(new Exception("fail")).now
  }

  val fixOups: Unit < (IO & Abort[Exception]) = defer {
    Console.printLine("YO").now
    Abort.fail(new Exception("fail")).now
    {}
  }

  val prgs=  Chunk(prg, prgWithDefer, oups, fixOups).zipWithIndex

  val all = Kyo.foreach(prgs)((prg, i) => Console.printLine(i) *> Abort.run(prg))

  run(all.unit)
}

0
YO
1
YO
2
3
YO

so it doesn't execute properly "oups"

  val oups: Unit < (IO & Abort[Exception]) = defer {
    Console.printLine("YO").now
    Abort.fail(new Exception("fail")).now
  }

but it works for

  val fixOups: Unit < (IO & Abort[Exception]) = defer {
    Console.printLine("YO").now
    Abort.fail(new Exception("fail")).now
    {}
  }

and other versions, such as

  val oups: Unit < (IO & Abort[Exception]) = defer {
    Console.printLine("YO").now
    Abort.fail(new Exception("fail")).unit.now
  }

There is a discard of the block for Nothing < S in tail position

[ahoy-jon]

I am not able to reproduce the original bug with io.getkyo::kyo-direct::0.18.0

def runInner: Unit < Async = defer:
  Console.printLine("test").now

object Kyo903 extends KyoApp {
  run(runInner)
}

produce

test

---

def runInner: Unit < Any = defer:
  Console.printLine("test").now

object Kyo903 extends KyoApp {
  run(runInner)
}

don't produce a compile error, and don't produce a result

[ahoy-jon]

So, what is happening. With this code

  def runInnerOK: Unit < IO = defer:
    Console.printLine("test").now

  def runInnerNOK: Unit < Any = defer:
    Console.printLine("test").now

we have (decompiled)

    public Object runInnerOK() {
        LazyRef var1 = new LazyRef();
        Async.InferAsyncArg InferAsyncArg_this = new Async.InferAsyncArg(this.given_KyoCpsMonad_s$5(var1));
        return InferAsyncArg_this.am().apply(RunInner$::runInnerOK$$anonfun$1);
    }

    public Object runInnerNOK() {
        Pending.package var1 = .MODULE$;
        LazyRef var4 = new LazyRef();
        Async.InferAsyncArg InferAsyncArg_this = new Async.InferAsyncArg(this.given_KyoCpsMonad_s$6(var4));
        InferAsyncArg_this.am().apply(RunInner$::$anonfun$1);
        BoxedUnit v$proxy7 = BoxedUnit.UNIT;
        return v$proxy7;
    }

Which show that the compiler is inserting a BoxedUnit.UNIT, and returns it, and doesn't warn on value-discard as other similar situations like:

def anyCallToUnit: Unit < Any =
    runInnerOK

discarded non-Unit value of type Unit < kyo.IO. Add `: Unit` to discard silently

---

The problem can be reproduced with

  transparent inline def toto: Unit < IO = Console.printLine("test")

  def tata: Unit < Any =
    toto

    public Object tata() {
        Pending.package var1 = .MODULE$;
        Frame.package.Frame var4 = kyo.Frame.package.Frame..MODULE$;
        Frame.package var5 = kyo.Frame.package..MODULE$;
        kyo.Console..MODULE$.printLine("test", "0dependent.scala:111:5|dependant.RunInner$|tata|def tata: Unit < Any =\n  toto\ud83d\udccd");
        BoxedUnit v$proxy8 = BoxedUnit.UNIT;
        return v$proxy8;
    }

It is an issue with transparent inline and value-discard warnings.

[ahoy-jon]

Done, it's here : scala/scala3#23018

Maybe it would be nice to have some Scalafix rules to detect those cases, or use a custom Unit type ?

opaque type Unit <: scala.Unit = scala.Unit

---

solutions for now

val x = defer { ... } .unit
val x:Any < ...  = defer {...}

[ahoy-jon]

created a Scalafix rule to help with it: https://github.com/ahoy-jon/kyo-scalafix-rules

[ahoy-jon]

⚠️ There is the same issue with Env.runLayer, provide:

  val runLayer: Unit < Any = {
    Env.runLayer(Layer.empty)(Console.printLine("test"))
  }
  val provide: Unit < Any = {
    Console.printLine("test").provide(Layer.empty)
  }

and probably runLiftTest.

[ahoy-jon]

#1202 solves the issue, by making the compiler report errors for those cases.

[hearnadam]

Nice work!

[fwbrasil]

Pretty cool! Thank you @ahoy-jon

[ahoy-jon]

Thank you! To make it clear, it fixes problems with:

• defer
• .provide
• Env.runLayer
• any transparent inline that would produce a Unit < S, and could be silently dropped by the compiler over a lift(()) like:

transparent inline def toto: Unit < IO = Console.printLine("test")

def tata: Unit < Any =
  toto