confusing suggestion when non-Unit expression is adapted to Unit (expression discarded in statement position)

[scf37]

Compiler version

3.3.0

Minimized code

def fa(f: String ?=> Unit): Unit = f(using "hello")
fa(42) // compiles with warning but does nothing

Output

[warn] -- [E129] Potential Issue Warning: /Test.scala:13:11 
[warn] 13 |        fa(42) // compiles but does nothing
[warn]    |           ^^
[warn]    |A pure expression does nothing in statement position; you may be omitting necessary parentheses
[warn]    |
[warn]    | longer explanation available when compiling with `-explain`

Expectation

Compilation error. I expect this because 42 seems to not match the type String ?=> Unit

[som-snytt]

That is normal, but you want to use -Wvalue-discard -Wnonunit-statement -Wunused:all if you code with Unit. (As of 3.4.0-RC1-bin-SNAPSHOT.)

Possibly -Wunused:params is not implemented, which should enable -Wunused:implicits. I would expect m and n to warn, and also for the context function that disregards its context to warn.

I would expect f { summon[String] } to warn, since summon is not side-effecting, and would spuriously consume the contextual parameter. (It is summoned but discarded, so something should warn.)

def f(g: String ?=> Unit): Unit = g(using "hello")

def k(s: String): Unit = s * 2 // warns

def m(implicit s: String): Unit = println()
def n(s: String): Unit = println()

@main def test() =
  f(println("goodbye"))
  f(println(summon[String])) // expected usage
  f { summon[String] }
  f { summon[String] * 2 } // warns

[nicolasstucki]

The warning should take into account that this is a statement in the unit expression {42; ()}. If we desugar by hand, the warning becomes clearer:

  |def test = fa({42; ()})
  |               ^^
  |A pure expression does nothing in statement position; you may be omitting necessary parentheses

We have a similar case in

  |def f: Unit = 32
  |              ^^
  |A pure expression does nothing in statement position; you may be omitting necessary parentheses

[scf37]

Similar cases:

def fa(f: => Unit): Unit = f
fa(42) // compiles with warning but does nothing

or even

def fa(f: Unit): Unit = f
fa(42) // compiles with warning but does nothing

I'm not sure it can or should be fixed. My 'gut feeling' was String ?=> Unit is a function while in practice it is more like by-name parameter with implicits.

[som-snytt]

@scf37 if by "I'm not sure it can or should be fixed", you mean, it's very convenient that the language allows values to be discarded, then I agree. I think the "fix" is to warn and -Werror.

About Nicolas's comment, there is some ambiguity, since an expression may wind up in "statement position" after some rewrite such as "value discard" conversion. So both warnings are relevant. I just changed Scala 2 to emit the same "category" warning for both cases, to make it easier to silence them or make them errors, as they are really the same concern.