Re-enable unused vals and defs

Author: nicolasstucki

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

@@ -31,7 +31,10 @@ class UnusedDecls extends MiniPhase with InfoTransformer {
 
   /* Tree transform */
 
-  override def transformValDef(tree: ValDef)(implicit ctx: Context): Tree =
+  override def transformDefDef(tree: DefDef)(implicit ctx: Context): Tree = transformValOrDefDef(tree)
+  override def transformValDef(tree: ValDef)(implicit ctx: Context): Tree = transformValOrDefDef(tree)
+
+  private def transformValOrDefDef(tree: ValOrDefDef)(implicit ctx: Context): Tree =
     if (tree.symbol.is(Unused, butNot = Param)) EmptyTree else tree
 
 

compiler/src/dotty/tools/dotc/typer/Applications.scala

@@ -24,6 +24,7 @@ import NameKinds.DefaultGetterName
 import ProtoTypes._
 import EtaExpansion._
 import Inferencing._
+import UnusedUtil._
 
 import collection.mutable
 import config.Printers.{typr, unapp, overload}
@@ -773,12 +774,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
       }
       app match {
         case Apply(fun, args) if fun.tpe.widen.isUnusedMethod =>
-          val erasedArgs = args.map { arg =>
-            if (!isPureExpr(arg))
-              ctx.warning("This argument is given to an unused parameter. This expression will not be evaluated.", arg.pos)
-            defaultValue(arg.tpe)
-          }
-          tpd.cpy.Apply(app)(fun = fun, args = erasedArgs)
+          tpd.cpy.Apply(app)(fun = fun, args = args.map(arg => normalizeUnusedExpr(arg, "This argument is given to an unused parameter. ")))
         case _ => app
       }
     }

compiler/src/dotty/tools/dotc/typer/Checking.scala

@@ -379,7 +379,7 @@ object Checking {
       }
     checkApplicable(UnusedType, !sym.is(UnusedType))
     if (sym.is(Unused)) {
-      checkApplicable(Unused, sym.is(Param) || sym.is(ParamAccessor))
+      checkApplicable(Unused, !sym.is(MutableOrLazy))
       if (sym.info.widen.finalResultType.isBottomType)
         fail("unused " + sym.showKind + " cannot have type Nothing")
     }

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -29,6 +29,7 @@ import dotty.tools.dotc.transform.Erasure.Boxing
 import util.Positions._
 import util.common._
 import util.{Property, SourcePosition}
+import UnusedUtil._
 
 import collection.mutable
 import annotation.tailrec
@@ -1255,7 +1256,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     val tpt1 = checkSimpleKinded(typedType(tpt))
     val rhs1 = vdef.rhs match {
       case rhs @ Ident(nme.WILDCARD) => rhs withType tpt1.tpe
-      case rhs => typedExpr(rhs, tpt1.tpe)
+      case rhs => normalizeUnusedRhs(typedExpr(rhs, tpt1.tpe), sym)
     }
     val vdef1 = assignType(cpy.ValDef(vdef)(name, tpt1, rhs1), sym)
     if (sym.is(Inline, butNot = DeferredOrParamAccessor))
@@ -1313,7 +1314,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       (tparams1, sym.owner.typeParams).zipped.foreach ((tdef, tparam) =>
         rhsCtx.gadt.setBounds(tdef.symbol, TypeAlias(tparam.typeRef)))
     }
-    val rhs1 = typedExpr(ddef.rhs, tpt1.tpe)(rhsCtx)
+    val rhs1 = normalizeUnusedRhs(typedExpr(ddef.rhs, tpt1.tpe)(rhsCtx), sym)
 
     // Overwrite inline body to make sure it is not evaluated twice
     if (sym.isInlineMethod) Inliner.registerInlineInfo(sym, _ => rhs1)

compiler/src/dotty/tools/dotc/typer/UnusedUtil.scala

@@ -0,0 +1,26 @@
+package dotty.tools.dotc.typer
+
+import dotty.tools.dotc.ast.tpd._
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Decorators._
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Flags._
+
+/** Util methods for transformation of `unused` expressions
+ *
+ *  @author Nicolas Stucki
+ */
+object UnusedUtil {
+
+  def normalizeUnusedExpr(tree: Tree, msg: String)(implicit ctx: Context): Tree = {
+    if (!isPureExpr(tree))
+      ctx.warning(msg + "This expression will not be evaluated.", tree.pos)
+    defaultValue(tree.tpe)
+  }
+
+  def normalizeUnusedRhs(tree: Tree, sym: Symbol)(implicit ctx: Context) = {
+    if (sym.is(Unused) && tree.tpe.exists) normalizeUnusedExpr(tree, "Expression is on the RHS of an `unused` " + sym.showKind + ". ")
+    else tree
+  }
+
+}

docs/docs/reference/unused-terms.md

@@ -66,7 +66,6 @@ unused val unusedEvidence: Ev = ...
 methodWithUnusedEv(unusedEvidence)
 ```
 
-
 What happens with unused values at runtime?
 -------------------------------------------
 As `unused` are guaranteed not to be used in computations, they can and will be erased.
@@ -79,11 +78,8 @@ def evidence1: Ev = ...
 unused def unusedEvidence2: Ev = ... // does not exist at runtime
 unused val unusedEvidence3: Ev = ... // does not exist at runtime
 
-// evidence1 is evaluated but the result is not passed to methodWithUnusedEv
+// evidence1 is not evaluated and no value is passed to methodWithUnusedEv
 methodWithUnusedEv(evidence1)
-
-// unusedEvidence2 is not evaluated and its result is not passed to methodWithUnusedEv
-methodWithUnusedEv(unusedEvidence2)
 ```
 
 State machine with unused evidence example
@@ -111,14 +107,14 @@ final class Off extends State
 @implicitNotFound("State is must be Off")
 class IsOff[S <: State]
 object IsOff {
-  // def isOff will not exist at runtime
-  unused implicit def isOff: IsOff[Off] = new IsOff[Off]
+  // def isOff will not be called at runtime for turnedOn, the compiler will only require that this evidence exists
+  implicit def isOff: IsOff[Off] = new IsOff[Off]
 }
 
 @implicitNotFound("State is must be On")
 class IsOn[S <: State]
 object IsOn {
-  // val isOn will not exist at runtime
+  // def isOn will not exist at runtime, the compiler will only require that this evidence exists at compile time
   unused implicit val isOn: IsOn[On] = new IsOn[On]
 }
 

tests/neg/unused-1.scala

@@ -1,13 +1,34 @@
 object Test {
   def foo0(a: Int): Int = a
   def foo1(unused a: Int): Int = {
-    foo0(a) // error
+    foo0(
+      a // error
+    )
     foo0({
       println()
       a // error
     })
     foo1(a) // OK
+    foo2( // error
+      a // error
+    )
+    foo3( // error
+      a
+    )
     a // error
-    a // error
+  }
+  unused def foo2(a: Int): Int = {
+    foo0(a) // OK
+    foo1(a) // OK
+    foo2(a) // OK
+    foo3(a) // OK
+    a // OK
+  }
+  unused def foo3(unused a: Int): Int = {
+    foo0(a) // OK
+    foo1(a) // OK
+    foo2(a) // OK
+    foo3(a) // OK
+    a // OK
   }
 }

tests/neg/unused-2.scala

@@ -0,0 +1,44 @@
+object Test {
+  def foo0(a: Int): Int = a
+  def foo1(unused a: Int): Int = {
+    foo0(
+      u // error
+    )
+    foo1(u) // OK
+    foo2( // error
+      u // error
+    )
+    foo3( // error
+      u
+    )
+    u // error
+    u // error
+  }
+  unused def foo2(a: Int): Int = {
+    foo0(u) // OK
+    foo1(u) // OK
+    foo2(u) // OK
+    foo3(u) // OK
+    u // warn
+    u // OK
+  }
+  unused def foo3(unused  a: Int): Int = {
+    foo0(u) // OK
+    foo1(u) // OK
+    foo2(u) // OK
+    foo3(u) // OK
+    u // warn
+    u // OK
+  }
+
+  unused val foo4: Int = {
+    foo0(u) // OK
+    foo1(u) // OK
+    foo2(u) // OK
+    foo3(u) // OK
+    u // warn
+    u // OK
+  }
+
+  unused def u: Int = 42
+}

tests/neg/unused-3.scala

@@ -0,0 +1,45 @@
+object Test {
+  def foo0(a: Int): Int = a
+  def foo1(unused a: Int): Int = {
+    foo0(
+      u() // error
+    )
+    foo1(u()) // OK
+    foo2( // error
+      u() // error
+    )
+    foo3( // error
+      u()
+    )
+    u() // error
+    u() // error
+  }
+  unused def foo2(a: Int): Int = {
+    foo0(u()) // OK
+    foo1(u()) // OK
+    foo2(u()) // OK
+    foo3(u()) // OK
+    u() // warn
+    u() // OK
+  }
+  unused def foo3(unused  a: Int): Int = {
+    foo0(u()) // OK
+    foo1(u()) // OK
+    foo2(u()) // OK
+    foo3(u()) // OK
+    u() // warn
+    u() // OK
+  }
+
+  unused val foo4: Int = {
+    foo0(u()) // OK
+    foo1(u()) // OK
+    foo2(u()) // OK
+    foo3(u()) // OK
+    println()
+    u() // warn
+    u() // OK
+  }
+
+  unused def u(): Int = 42
+}

tests/neg/unused-6.scala

@@ -1,13 +1,12 @@
 object Test {
-  def f(unused foo: Foo) = {
-    foo.x() // error
-    foo.y // error
-    foo.z // error
-  }
+  unused def foo: Foo = new Foo
+  foo.x() // error
+  foo.y // error
+  foo.z // error
 }
 
 class Foo {
   def x(): String = "abc"
   def y: String = "abc"
   val z: String = "abc"
-}
+}

tests/neg/unused-args-lifted.scala

@@ -1,16 +1,16 @@
 object Test {
-  def f(unused bar: Int => Int) = {
-    def foo(a: Int)(b: Int, c: Int) = 42
-
-    def baz: Int = {
-      println(1)
-      2
-    }
-
-    foo(
-      bar(baz) // error
-    )(
-      c = baz, b = baz // force all args to be lifted in vals befor the call
-    )
+  def foo(a: Int)(b: Int, c: Int) = 42
+  unused def bar(i: Int): Int = {
+    println(1)
+    42
   }
+  def baz: Int = {
+    println(1)
+    2
+  }
+  foo(
+    bar(baz) // error
+  )(
+    c = baz, b = baz  // force all args to be lifted in vals befor the call
+  )
 }

tests/neg/unused-assign.scala

@@ -2,6 +2,10 @@ object Test {
   var i: Int = 1
   def foo(unused a: Int): Int = {
     i = a // error
+    unused def r = {
+      i = a
+      ()
+    }
     42
   }
 }

tests/neg/unused-implicit.scala

@@ -0,0 +1,8 @@
+object Test {
+
+  fun // error
+
+  def fun(implicit a: Double): Int = 42
+
+  unused implicit def doubleImplicit: Double = 42.0
+}

tests/run/unused-10.scala

@@ -8,8 +8,8 @@ object Test {
     println("pacFun4")
   }
 
-  def inky: Int = {
-    println("inky")
+  unused def inky: Int = {
+    println("inky") // in erased function
     42
   }
 

tests/run/unused-13.scala

@@ -1,7 +1,7 @@
 object Test {
 
   def main(args: Array[String]): Unit = {
-    lazy val x = {
+    unused val x = {
       println("x")
       42
     }

tests/run/unused-14.check

@@ -0,0 +1 @@
+Foo

tests/run/unused-14.scala

@@ -0,0 +1,15 @@
+object Test {
+
+  def main(args: Array[String]): Unit = {
+    new Foo
+  }
+
+}
+
+class Foo {
+  unused val x: Int = {
+    println("x")
+    42
+  }
+  println("Foo")
+}

tests/run/unused-2.scala

@@ -2,7 +2,7 @@ object Test {
 
   def main(args: Array[String]): Unit = {
 
-    def !!! : Null = ???
+    unused def !!! : Null = ???
 
     try {
       fun(!!!)