Fix unused on poly methods with term no args

Author: nicolasstucki

compiler/src/dotty/tools/dotc/transform/UnusedRefs.scala

@@ -28,12 +28,13 @@ class UnusedRefs extends MiniPhase {
 
   /** Check what the phase achieves, to be called at any point after it is finished. */
   override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = tree match {
-    case _: Apply | _: RefTree => assert(!tree.symbol.is(Unused))
+    case _: Apply | _: TypeApply | _: RefTree => assert(!tree.symbol.is(Unused), tree)
     case _ =>
   }
 
   /* Tree transform */
 
+  override def transformTypeApply(tree: TypeApply)(implicit ctx: Context): Tree = transformUnused(tree)
   override def transformApply(tree: Apply)(implicit ctx: Context): Tree = transformUnused(tree)
   override def transformIdent(tree: Ident)(implicit ctx: Context): Tree = transformUnused(tree)
   override def transformSelect(tree: Select)(implicit ctx: Context): Tree = transformUnused(tree)
@@ -42,11 +43,16 @@ class UnusedRefs extends MiniPhase {
     if (!tree.symbol.is(Unused)) tree
     else {
       tree.tpe.widen match {
-        case _: MethodType => tree // Do the transformation higher in the tree if needed
+        case _: MethodOrPoly => tree // Do the transformation higher in the tree if needed
         case _ =>
           tree match {
-            case _: RefTree => defaultValue(tree.tpe)
-            case Apply(_ , args) => seq(args, defaultValue(tree.tpe))
+            case _: RefTree | _: TypeApply => defaultValue(tree.tpe)
+            case Apply(_ , args) =>
+            def allArgs(t: Tree, acc: List[Tree]): List[Tree] = t match {
+              case Apply(fun, args) => allArgs(fun, args ::: acc)
+              case _ => acc
+            }
+            seq(allArgs(tree, Nil), defaultValue(tree.tpe))
           }
       }
     }

tests/run/unused-frameless.scala

@@ -17,21 +17,6 @@ final case class R[K <: String, V](v: V)
 
 trait Selector[L <: HList, K, V]
 
-object Selector {
-  implicit def caseFound[T <: HList, K <: String, V]
-  : Selector[R[K, V] :: T, K, V] = {
-    println("Selector.caseFound")
-    null
-  }
-
-  implicit def caseRecur[H, T <: HList, K <: String, V]
-  (implicit i: Selector[T, K, V])
-  : Selector[H :: T, K, V] = {
-    println("Selector.caseRecur")
-    null
-  }
-}
-
 // Subset of Frameless
 // ----------------------------------------------------------------------------
 
@@ -83,34 +68,46 @@ case class Column[T, A](label: String)
 @implicitNotFound(msg = "No column ${K} in type ${T}")
 trait Exists[T, K, V]
 
-object Exists {
-  implicit def derive[T, H <: HList, K, V]
-  (implicit
-   g: LabelledGeneric[T] { type Repr = H },
-   s: Selector[H, K, V]
-  ): Exists[T, K, V] = {
+object UsedExists {
+  implicit def derive[T, H <: HList, K, V](implicit g: LabelledGeneric[T] { type Repr = H }, s: Selector[H, K, V]): Exists[T, K, V] = {
     println("Exists.derive")
     null
   }
+
+  implicit def caseFound[T <: HList, K <: String, V]: Selector[R[K, V] :: T, K, V] = {
+    println("Selector.caseFound")
+    null
+  }
+
+  implicit def caseRecur[H, T <: HList, K <: String, V](implicit i: Selector[T, K, V]): Selector[H :: T, K, V] = {
+    println("Selector.caseRecur")
+    null
+  }
 }
 
 object UnusedExists {
-  implicit unused def derive[T, H <: HList, K, V]
-  (implicit
-   g: LabelledGeneric[T] { type Repr = H },
-   s: Selector[H, K, V]
-  ): Exists[T, K, V] = {
+  implicit unused def derive[T, H <: HList, K, V](implicit unused g: LabelledGeneric[T] { type Repr = H }, s: Selector[H, K, V] ): Exists[T, K, V] = {
     println("UnusedExists.derive")
     null
   }
+
+  unused implicit def caseFound[T <: HList, K <: String, V]: Selector[R[K, V] :: T, K, V] = {
+    println("Selector.caseFound")
+    null
+  }
+
+  unused implicit def caseRecur[H, T <: HList, K <: String, V](implicit i: Selector[T, K, V]): Selector[H :: T, K, V] = {
+    println("Selector.caseRecur")
+    null
+  }
 }
 
 // X4 Example
 // ----------------------------------------------------------------------------
 
 case class X4[A, B, C, D](a: A, b: B, c: C, d: D)
 
-object X4 {
+object UsedX4 {
   // Macro generated
   implicit def x4Repr[A, B, C, D]: LabelledGeneric[X4[A, B, C, D]] {
     type Repr = R["a", A] :: R["b", B] :: R["c", C] :: R["d", D] :: HNil
@@ -120,6 +117,16 @@ object X4 {
   }
 }
 
+object UnusedX4 {
+  // Macro generated
+  implicit unused def x4Repr[A, B, C, D]: LabelledGeneric[X4[A, B, C, D]] {
+    type Repr = R["a", A] :: R["b", B] :: R["c", C] :: R["d", D] :: HNil
+  } = {
+    println("X4.x4Repr")
+    null
+  }
+}
+
 object Test {
   def main(args: Array[String]): Unit = {
     val source: Vector[X4[Int, String, Double, Boolean]] =
@@ -131,16 +138,21 @@ object Test {
 
     {
       import UnusedExists._
+      import UnusedX4._
       println("unused")
       val unusedD = ds.col("d")
       val outSpark1: Vector[Boolean] = ds.select(unusedD).collect()
       assert(outSpark1 == outColl)
     }
 
-    println("used")
-    val usedD = ds.col("d")
-    val outSpark2: Vector[Boolean] = ds.select(usedD).collect()
-    assert(outSpark2 == outColl)
+    {
+      import UsedExists._
+      import UsedX4._
+      println("used")
+      val usedD = ds.col("d")
+      val outSpark2: Vector[Boolean] = ds.select(usedD).collect()
+      assert(outSpark2 == outColl)
+    }
 
     println("end")
   }

tests/run/unused-poly-ref.check

@@ -0,0 +1,3 @@
+5
+6
+fun

tests/run/unused-poly-ref.scala

@@ -0,0 +1,15 @@
+object Test {
+
+  def main(args: Array[String]): Unit = {
+    fun(foo(bar(5))(bar(6)))
+  }
+
+  def fun(unused a: Int): Unit = println("fun")
+
+  unused def foo[P](unused x: Int)(unused y: Int): Int = x
+
+  def bar(x: Int) =  {
+    println(x)
+    x
+  }
+}