Infer Any/AnyVal warning suppressed by inclusion in Unit block

[blast-hardcheese]

reproduction steps

Reproduction repo: blast-hardcheese/scala-bug-xlint-infer-any, includes all compiler output for all versions.

using representative Scala versions from 2.11.0 through 2.13.6,

object Bogus {
  Option.empty[String].contains(1234) // Emits a warning

  def should(func: => Unit): Unit = func

  should {
    Option.empty[String].contains(1234) // Does not warn
  }

  println(Option.empty[String].contains(1234)) // does not warn
}

should output three warnings (as the code is the same in both places; if it warns in one place, it should warn in the others) but only one warning is emitted for all versions from 2.11.0 onwards.

problem

It seems as though being part of a block whose result type gets coerced to Unit disables the following warning:

a type was inferred to be `Any`; this may indicate a programming error.

This is particularly devastating when it is observed that this is a common pattern in scalatest. As a result, nonsensical tests fail to flag -Xfatal-warnings and defects are subject to being caught by the runtime.

This may be related to #12320 (and #9211, by association), but as this is explicitly a regression in the compiler from 2.10.7, I'm calling this out separately.

---

Thank you all for your work, it is a pleasure to use what you have built.

[som-snytt]

The println example is because it avoids warning if the expected type is Any -- println(Any). Probably, if there is no dependency in the result type, that check should be skipped.

The should example is because the application is first typed in silent mode. That will normally emit warnings, but the lint here checks for silent mode explicitly ("reportErrors"). What's needed is a protocol for "emit warnings if successful result is used". I see a test failure with the check removed: List(1,2,3).toSet warns for some reason.

Edit: it also enables warning on 1 to 5 contains 5L which is marked "should warn".

Edit: List(42).toSet() with parens warns about adapting to set.apply(()) which is super evil.

[SethTisue]

Note that Scala 3 doesn't have this warning at all. (As with a ton of Scala 2 warnings and lints.)

[blast-hardcheese]

@SethTisue I tried to call that out in the reproduction repo:

3.0 does not immediately present an alternative to -Xlint:infer-any (the migration notes just say X), but included in the output here for completeness.

though I was hoping that I just overlooked the omission of those warnings. Without attempting to dump more work on the core Scala team, was the expectation that SemanticDB or some other functionality would take the responsibility of raising this category of error?

[SethTisue]

I'm not sure what the Scala 3 team's plans on that are, tbh. (I do some Scala 3 stuff, but my primary responsibility remains Scala 2.) Could be a good thread on https://contributors.scala-lang.org? (I'm not sure if there are prior threads and/or tickets.)

For a long time a lot of stuff went in a "let's get 3.0 out the door and wait for the dust to settle" bucket, but that dust is now starting to settle.

[blast-hardcheese]

(for completeness, closing the loop)

[som-snytt]

Actually, quite a lot of warnings are suppressed by silent typing.

  val p = (42, 27)
  def pesky = p == (42, 17)

doesn't warn because autotupling happens in silent mode.

scala> p == (42, List(17,""))
val res0: Boolean = false

scala> List(17,"")
       ^
       warning: a type was inferred to be `Any`; this may indicate a programming error.
val res1: List[Any] = List(17, "")

As shown above, everything to the left in a chain of applies is suppressed.