diff options
author | Som Snytt <som.snytt@gmail.com> | 2015-07-08 08:27:10 -0700 |
---|---|---|
committer | Som Snytt <som.snytt@gmail.com> | 2015-07-08 20:45:45 -0700 |
commit | 6f795ac3f66cb889ea92324dd40cfc9156e99c90 (patch) | |
tree | 0c0cf9565495040c64d1a774255f7e463caebce7 /test/files/neg/warn-unused-imports | |
parent | b92c3aff1ab8c76c4816bd7b1a82a0f87d787837 (diff) | |
download | scala-6f795ac3f66cb889ea92324dd40cfc9156e99c90.tar.gz scala-6f795ac3f66cb889ea92324dd40cfc9156e99c90.tar.bz2 scala-6f795ac3f66cb889ea92324dd40cfc9156e99c90.zip |
SI-9383 Improved unused import warning
Previously, implicit search would mark every import
it touched as a lookup.
Instead, let subsequent type check perform the lookup.
Diffstat (limited to 'test/files/neg/warn-unused-imports')
-rw-r--r-- | test/files/neg/warn-unused-imports/sample_1.scala | 17 | ||||
-rw-r--r-- | test/files/neg/warn-unused-imports/warn-unused-imports_2.scala | 155 |
2 files changed, 172 insertions, 0 deletions
diff --git a/test/files/neg/warn-unused-imports/sample_1.scala b/test/files/neg/warn-unused-imports/sample_1.scala new file mode 100644 index 0000000000..d2f86239db --- /dev/null +++ b/test/files/neg/warn-unused-imports/sample_1.scala @@ -0,0 +1,17 @@ + +import language._ + +object Sample { + trait X + trait Y + + // import of the non-implicit should be unused + object Implicits { + def `int to X`(i: Int): X = null + implicit def `int to Y`(i: Int): Y = null + implicit def useless(i: Int): String = null + } + + def f(x: X) = ??? + def g(y: Y) = ??? +} diff --git a/test/files/neg/warn-unused-imports/warn-unused-imports_2.scala b/test/files/neg/warn-unused-imports/warn-unused-imports_2.scala new file mode 100644 index 0000000000..ded1186209 --- /dev/null +++ b/test/files/neg/warn-unused-imports/warn-unused-imports_2.scala @@ -0,0 +1,155 @@ +class Bippo { + def length: Int = 123 + class Tree +} + +package object p1 { + class A + implicit class B(val s: String) { def bippy = s } + val c: Bippo = new Bippo + type D = String +} +package object p2 { + class A + implicit class B(val s: String) { def bippy = s } + val c: Bippo = new Bippo + type D = Int +} + +trait NoWarn { + { + import p1._ // no warn + println("abc".bippy) + } + + { + import p1._ // no warn + println(new A) + } + + { + import p1.B // no warn + println("abc".bippy) + } + + { + import p1._ // no warn + import c._ // no warn + println(length) + } + + { + import p1._ // no warn + import c._ // no warn + val x: Tree = null + println(x) + } + + { + import p1.D // no warn + val x: D = null + println(x) + } +} + +trait Warn { + { + import p1.A // warn + println(123) + } + + { + import p1.{ A, B } // warn on A + println("abc".bippy) + } + + { + import p1.{ A, B } // warn on both + println(123) + } + + { + import p1._ // no warn (technically this could warn, but not worth the effort to unroll unusedness transitively) + import c._ // warn + println(123) + } + + { + import p1._ // warn + println(123) + } + + { + class Tree + import p1._ // no warn + import c._ // warn + val x: Tree = null + println(x) + } + + { + import p1.c._ // warn + println(123) + } +} + +trait Nested { + { + import p1._ // warn + trait Warn { // warn about unused local trait for good measure + import p2._ + println(new A) + println("abc".bippy) + } + println("") + } + + { + import p1._ // no warn + trait NoWarn { + import p2.B // no warn + println("abc".bippy) + println(new A) + } + println(new NoWarn { }) + } + + { + import p1.A // warn + trait Warn { + import p2.A + println(new A) + } + println(new Warn { }) + } +} + +// test unusage of imports from other compilation units after implicit search +trait Outsiders { + { + //implicit search should not disable warning + import Sample._ + import Sample.Implicits._ // warn + f(42) // error + } + { + import Sample._ + import Sample.Implicits._ // nowarn + g(42) // ok + } + { + import Sample._ + import Sample.Implicits.`int to Y` // nowarn + import Sample.Implicits.useless // warn + g(42) // ok + } + { + import java.io.File // warn + import scala.concurrent.Future // warn + import scala.concurrent.ExecutionContext.Implicits.global // warn + import p1.A // warn + import p1.B // no warn + println("abc".bippy) + //Future("abc".bippy) + } +} |