scala Ywarn-all usage - scala

Question

I'm trying to use scala compiler Y warnings, but I don't think I'm doing it right. In the example below, nums is unused, hence I'd expect -Ywarn-value-discard to print a warning for that.
There are two if conditions, one nested inside the other. The child if's condition is exact opposite of parents', hence anything inside it is dead code. But -Ywarn-dead-code doesn't warn against that.
Could anyone please suggest what I might be doing wrong? Any pointers would be appreciated.
object DeadCodeWarn{
def main( args: Array[ String ] ) {
val nums = 1 to 100
//There should be a warning for squares
//as its a non-unit expression thats not
//used in any computation. Y-warn-value-discard
val squares = nums.map( x => x * x )
if( nums.length == 100 ){
println( "should be printed" )
if( nums.length !=100 )
{
//-Ywarn-dead-code
println( "Dead code, so should be warned against" )
}
}
}
}
$scalac -Xlint -Ywarn-all DeadCodeWarn.scala succeeds silently.

Answer 1

-Ywarn-value-discard
The value isn't discarded, it's assigned to the val!
The problem is that the val is unused
With code:
package foo
case class Foo(x: Int) {
def foo: Int = {
val y = 2;
x
}
}
I get with scalac 2.11.5 and -Ywarn-unused:
[warn] /.../foo.scala:5: local val in method foo is never used
[warn] val y = 2;
-Ywarn-dead-code
It's easy to write the counter-example(s) where the common logic doesn't work:
// Evil mutable class
class Arrayish {
private var x: Int = 100
def length(): Int = {
val res = x
x += 1
res
}
}
def test(nums: Arrayish): Unit =
if (nums.length == 100) {
println( "should be printed" )
if (nums.length != 100) {
println("Dead code, so should be warned against")
}
}
Dead code is run:
scala> test(new Arrayish())
should be printed
Dead code, so should be warned against
Or
class NonEqual {
def ==(x: Int): Boolean = true
def !=(x: Int): Boolean = true
}
class NaNLength {
val length: NonEqual = new NonEqual
}
def test2(nums: NaNLength): Unit =
if (nums.length == 100) {
println("should be printed")
if (nums.length != 100) {
println("Dead code, so should be warned against")
}
}
Dead code is run as well:
scala> test2(new NaNLength)
should be printed
Dead code, so should be warned against
Scalac compiler isn't smart enough to distinguish well behaving and not-so-well behaving cases.
If you are going to submit the bug / feature-request, mention example like:
def test3(nums: Array[Int]): Unit = {
if (true) {
println("should be printed")
if (false) {
println("Dead code, so should be warned against")
}
}
}
def test4(nums: Array[Int]): Unit = {
val hundred = nums.length == 100
if (hundred) {
println("should be printed")
if (!hundred) {
println("Dead code, so should be warned against")
}
}
}
Seems that scalac dead code reporter isn't as polished as e.g. Java. I hope scalac does optimise these examples properly though, it shouldn't be too complicated.

Answer 2

After some toying around with the code, it appears that this is simply not a case where dead code is caught. I will see about continuing to peruse the compiler code itself, however upon review it seems that dead code is eliminated. Upon elimination is when it seems to emit the warning. So, if you review something as simple as
def foo = {return 1; 1}
You will see that the final code is simply to return 1 and not even emit the second 1. However, if you take a look at the final code of this nested if you will see that the second if is not eliminated.
Go ahead and submit a bug, although I'm not sure what kind of priority this would have.