value-discard warning is not suppressed for methods with implicit params

[enzief]

reproduction steps

using Scala (2.13.2),

scala> def foo(implicit x: Int): Boolean = x % 2 == 1
def foo(implicit x: Int): Boolean

scala> implicit val i = 1
val i: Int = 1

scala> def f(): Unit = foo: Unit
                       ^
       warning: discarded non-Unit value
def f(): Unit

problem

expect no warning: discarded non-Unit value as per scala/scala#7563

explicitly passing implicit argument works

scala> def f(): Unit = foo(2): Unit
def f(): Unit

[som-snytt]

The adapted f(x) doesn't receive the magic annotation on f.

[adapt] (implicit i: scala.this.Int): scala.this.Int adapted to { T.this.f(x); () } based on pt scala.this.Unit

[steinybot]

This is a real pain in the neck when using ScalaTest. For example:

import org.scalatest.flatspec.AnyFlatSpec
import org.scalatest.matchers.should.Matchers

class ShouldSpec extends AnyFlatSpec with Matchers {

  behavior of "Foo"

  it must "do foo" in {
    123.shouldBe(an[Int]): Unit
    123.shouldBe(an[Int])
  }
}

I'm not even sure why. shouldBe is overloaded but this overload doesn't have any implicit parameters (it is a macro though):

    def shouldBe(anType: ResultOfAnTypeInvocation[_]): Assertion = macro TypeMatcherMacro.shouldBeAnTypeImpl

There are other overloads that do have implicit parameters. I tried reproducing this without using ScalaTest and was unable to.

[steinybot]

I should point out that my example is not for value-discard but nonunit-statement although I believe the suppression mechanism should work the same.

[steinybot]

I also don't know of a workaround for my case. Specifying the implicit parameter is not an option because there is no implicit parameter.

[som-snytt]

I believe the suppression mechanism should work the same.

They are different. I think there is a ticket somewhere for ScalaTest. Perhaps on sbt-tpolecat of all places. I hope to update nonunit-statement but there is not a tracking ticket.

typelevel/sbt-tpolecat#134

Edit: by mechanism I understood mechanism and not syntax. Yes, I think the syntax for expressing "I mean Unit here" is the same.

[som-snytt]

It seems this was fixed.

➜  scala -Wvalue-discard
Welcome to Scala 2.13.10 (OpenJDK 64-Bit Server VM, Java 19).
Type in expressions for evaluation. Or try :help.

scala> def foo(implicit x: Int): Boolean = x % 2 == 1
def foo(implicit x: Int): Boolean

scala> implicit def i: Int = 42
def i: Int

scala> foo(42)
val res0: Boolean = false

scala> foo
val res1: Boolean = false

scala> def u: Unit = foo
                     ^
       warning: discarded non-Unit value of type Boolean
def u: Unit

scala> def u: Unit = foo: Unit
def u: Unit

scala>

[som-snytt]

Actually the code to check for the annotation was updated by nonunit-statement PR so they share that much. That was 2.13.9. But the false positives for test frameworks is ongoing, as far as I know.

[steinybot]

Should I create another issue for the nonunit-statement problem?

[som-snytt]

@steinybot please feel free!