Remove unused params in erasure

With path dependent types on parameters it is not possible to remove them
before erasure because there is no type that can be put in their place
without messing with typing (Ychecks will fail).

Author: nicolasstucki

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -64,15 +64,14 @@ class Compiler {
            new HoistSuperArgs,      // Hoist complex arguments of supercalls to enclosing scope
            new ClassOf,             // Expand `Predef.classOf` calls.
            new RefChecks),          // Various checks mostly related to abstract members and overriding
-      List(new UnusedParams),       // Removes all unused parameters and arguments
       List(new TryCatchPatterns,    // Compile cases in try/catch
            new PatternMatcher,      // Compile pattern matches
            new ExplicitOuter,       // Add accessors to outer classes from nested ones.
            new ExplicitSelf,        // Make references to non-trivial self types explicit as casts
            new ShortcutImplicits,   // Allow implicit functions without creating closures
            new CrossCastAnd,        // Normalize selections involving intersection types.
            new Splitter),           // Expand selections involving union types into conditionals
-      List(new UnusedDecls,         // Removes all unused defs and vals decls
+      List(new UnusedDecls,         // Removes all unused defs and vals decls (except for parameters)
            new VCInlineMethods,     // Inlines calls to value class methods
            new SeqLiterals,         // Express vararg arguments as arrays
            new InterceptedMethods,  // Special handling of `==`, `|=`, `getClass` methods

compiler/src/dotty/tools/dotc/core/TypeErasure.scala

@@ -400,7 +400,8 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
       def paramErasure(tpToErase: Type) =
         erasureFn(tp.isJavaMethod, semiEraseVCs, isConstructor, wildcardOK)(tpToErase)
       val (names, formals0) =
-        if (tp.paramInfos.exists(_.isPhantom)) tp.paramNames.zip(tp.paramInfos).filterNot(_._2.isPhantom).unzip
+        if (tp.isUnusedMethod) (Nil, Nil)
+        else if (tp.paramInfos.exists(_.isPhantom)) tp.paramNames.zip(tp.paramInfos).filterNot(_._2.isPhantom).unzip
         else (tp.paramNames, tp.paramInfos)
       val formals = formals0.mapConserve(paramErasure)
       eraseResult(tp.resultType) match {

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

@@ -456,6 +456,15 @@ object Erasure {
       case _ => Nil
     }
 
+    // TODO: merge this whit protoArgs if it is actually needed
+    private def protoArgs2(pt: Type, tp: Type): List[untpd.Tree] = (pt, tp) match {
+      case (pt: FunProto, tp: MethodType) if tp.isUnusedMethod => protoArgs2(pt.resType, tp.resType)
+      case (pt: FunProto, tp: MethodType) => pt.args ++ protoArgs2(pt.resType, tp.resType)
+      case _ =>
+        assert(!tp.isInstanceOf[MethodOrPoly], tp)
+        Nil
+    }
+
     override def typedTypeApply(tree: untpd.TypeApply, pt: Type)(implicit ctx: Context) = {
       val ntree = interceptTypeApply(tree.asInstanceOf[TypeApply])(ctx.withPhase(ctx.erasurePhase))
 
@@ -486,7 +495,10 @@ object Erasure {
           fun1.tpe.widen match {
             case mt: MethodType =>
               val outers = outer.args(fun.asInstanceOf[tpd.Tree]) // can't use fun1 here because its type is already erased
-              var args0 = outers ::: args ++ protoArgs(pt)
+              var args0 = protoArgs2(pt, tree.typeOpt)
+              if (!mt.isUnusedMethod) args0 = args ::: args0
+              args0 = outers ::: args0
+
               if (args0.length > MaxImplementedFunctionArity && mt.paramInfos.length == 1) {
                 val bunchedArgs = untpd.JavaSeqLiteral(args0, TypeTree(defn.ObjectType))
                   .withType(defn.ArrayOf(defn.ObjectType))
@@ -554,6 +566,7 @@ object Erasure {
         vparamss1 = (tpd.ValDef(bunchedParam) :: Nil) :: Nil
         rhs1 = untpd.Block(paramDefs, rhs1)
       }
+      vparamss1 = vparamss1.mapConserve(_.filterConserve(!_.symbol.is(Flags.Unused)))
       vparamss1 = vparamss1.mapConserve(_.filterConserve(vparam => !wasPhantom(vparam.tpe)))
       if (sym.is(Flags.ParamAccessor) && wasPhantom(ddef.tpt.tpe)) {
         sym.resetFlag(Flags.ParamAccessor)

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

@@ -24,7 +24,7 @@ class UnusedDecls extends MiniPhase with InfoTransformer {
 
   /** 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 tree: ValOrDefDef => assert(!tree.symbol.is(Unused))
+    case tree: ValOrDefDef if !tree.symbol.is(Param) => assert(!tree.symbol.is(Unused, butNot = Param))
     case _ =>
   }
 
@@ -35,7 +35,7 @@ class UnusedDecls extends MiniPhase with InfoTransformer {
   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) EmptyTree else tree
+    if (tree.symbol.is(Unused, butNot = Param)) EmptyTree else tree
 
 
   /* Info transform */

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

@@ -3,7 +3,6 @@ package dotty.tools.dotc.transform
 import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.ast.Trees._
 import dotty.tools.dotc.core.Contexts._
-import dotty.tools.dotc.core.DenotTransformers.InfoTransformer
 import dotty.tools.dotc.core.Flags._
 import dotty.tools.dotc.core.Phases
 import dotty.tools.dotc.core.Symbols._
@@ -17,9 +16,8 @@ import dotty.tools.dotc.transform.MegaPhase.MiniPhase
  *
  *   if   `unused val x: T = ...` including parameters
  *   then `x` --> `(default value for T)`
- *        `x.Y`  -->  `T#Y`
  */
-class UnusedRefs extends MiniPhase with InfoTransformer {
+class UnusedRefs extends MiniPhase {
   import tpd._
 
   override def phaseName: String = "unusedRefs"
@@ -29,22 +27,9 @@ class UnusedRefs extends MiniPhase with InfoTransformer {
   )
 
   /** Check what the phase achieves, to be called at any point after it is finished. */
-  override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = {
-    val checker = new TypeMap {
-      override def apply(tp: Type): Type = tp match {
-        case tp: TermParamRef => assert(!tp.binder.isUnusedMethod); tp
-        case tp: TermRef if !tp.symbol.is(Method) => assert(!tp.symbol.is(Unused)); tp
-        case _ => mapOver(tp)
-      }
-    }
-    tree match {
-      case _: ValDef =>
-      case _: Apply | _: RefTree =>
-        assert(!tree.symbol.is(Unused))
-        checker.apply(tree.tpe)
-      case _ =>
-        checker.apply(tree.tpe)
-    }
+  override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = tree match {
+    case _: Apply | _: RefTree => assert(!tree.symbol.is(Unused))
+    case _ =>
   }
 
   /* Tree transform */
@@ -70,26 +55,4 @@ class UnusedRefs extends MiniPhase with InfoTransformer {
       }
     }
   }
-
-  override def transformTypeTree(tree: TypeTree)(implicit ctx: Context): Tree = {
-    val newType = removeUnusedPaths(tree.tpe)
-    if (tree.tpe == newType) tree
-    else TypeTree(newType)
-  }
-
-
-  /* Tree info */
-
-  override def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context): Type = removeUnusedPaths(tp)
-
-  private def removeUnusedPaths(tp: Type)(implicit ctx: Context): Type = {
-    // TODO: handle variance
-    new TypeMap {
-      override def apply(tp: Type): Type = tp match {
-        case tp: TermParamRef if tp.binder.isUnusedMethod => tp.classSymbol.typeRef
-        case tp: TermRef if tp.symbol.is(Unused) => tp.widen
-        case _ => mapOver(tp)
-      }
-    }.apply(tp)
-  }
 }

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

@@ -1,3 +1,3 @@
-foo
-foo
+foo1
+foo2
 fun

tests/run/unused-3.check

@@ -1,15 +1,20 @@
 object Test {
 
   def main(args: Array[String]): Unit = {
-    fun(foo)(foo)
+    fun(foo1)(foo2)
   }
 
-  def foo: Int = {
-    println("foo")
+  def foo1: Int = {
+    println("foo1")
     42
   }
 
-  def fun(unused a: Int)(unused b: Int): Unit = {
+  def foo2: String = {
+    println("foo2")
+    "abc"
+  }
+
+  def fun(unused a: Int)(unused b: String): Unit = {
     println("fun")
   }