Streamline dropUnusedDefs

The previous treatment could go wrong by confusing `bindings` and `termBindings`
in a recursive step.

test case: run/typeclass-derivation2c.scala

Author: odersky

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

@@ -81,7 +81,7 @@ object ErrorReporting {
       if (tree.tpe.widen.exists)
         i"${exprStr(tree)} does not take ${kind}parameters"
       else {
-        new FatalError("").printStackTrace()
+        //new FatalError("").printStackTrace()  //DEBUG
         i"undefined: $tree # ${tree.uniqueId}: ${tree.tpe.toString} at ${ctx.phase}"
       }
 

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

@@ -1056,8 +1056,29 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
    */
   def dropUnusedDefs(bindings: List[MemberDef], tree: Tree)(implicit ctx: Context): (List[MemberDef], Tree) = {
     // inlining.println(i"drop unused $bindings%, % in $tree")
-
-    def inlineTermBindings(termBindings: List[MemberDef], tree: Tree)(implicit ctx: Context): (List[MemberDef], Tree) = {
+    val (termBindings, typeBindings) = bindings.partition(_.symbol.isTerm)
+    if (typeBindings.nonEmpty) {
+      val typeBindingsSet = typeBindings.foldLeft[SimpleIdentitySet[Symbol]](SimpleIdentitySet.empty)(_ + _.symbol)
+      val inlineTypeBindings = new TreeTypeMap(
+        typeMap = new TypeMap() {
+          override def apply(tp: Type): Type = tp match {
+            case tr: TypeRef if tr.prefix.eq(NoPrefix) && typeBindingsSet.contains(tr.symbol) =>
+              val TypeAlias(res) = tr.info
+              res
+            case tp => mapOver(tp)
+          }
+        },
+        treeMap = {
+          case ident: Ident if ident.isType && typeBindingsSet.contains(ident.symbol) =>
+            val TypeAlias(r) = ident.symbol.info
+            TypeTree(r).withSpan(ident.span)
+          case tree => tree
+        }
+      )
+      val Block(termBindings1, tree1) = inlineTypeBindings(Block(termBindings, tree))
+      dropUnusedDefs(termBindings1.asInstanceOf[List[ValOrDefDef]], tree1)
+    }
+    else {
       val refCount = newMutableSymbolMap[Int]
       val bindingOfSym = newMutableSymbolMap[MemberDef]
 
@@ -1066,7 +1087,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
         case vdef @ ValDef(_, _, _) => isPureExpr(vdef.rhs)
         case _ => false
       }
-      for (binding <- termBindings if isInlineable(binding)) {
+      for (binding <- bindings if isInlineable(binding)) {
         refCount(binding.symbol) = 0
         bindingOfSym(binding.symbol) = binding
       }
@@ -1124,40 +1145,15 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
         }
       }
 
-      val retained = termBindings.filterConserve(binding => retain(binding.symbol))
-      if (retained `eq` termBindings) {
-        (termBindings, tree)
+      val retained = bindings.filterConserve(binding => retain(binding.symbol))
+      if (retained `eq` bindings) {
+        (bindings, tree)
       }
       else {
         val expanded = inlineBindings.transform(tree)
         dropUnusedDefs(retained, expanded)
       }
     }
-
-    val (termBindings, typeBindings) = bindings.partition(_.symbol.isTerm)
-    if (typeBindings.isEmpty) inlineTermBindings(termBindings, tree)
-    else {
-      val typeBindingsSet = typeBindings.foldLeft[SimpleIdentitySet[Symbol]](SimpleIdentitySet.empty)(_ + _.symbol)
-      val inlineTypeBindings = new TreeTypeMap(
-        typeMap = new TypeMap() {
-          override def apply(tp: Type): Type = tp match {
-            case tr: TypeRef if tr.prefix.eq(NoPrefix) && typeBindingsSet.contains(tr.symbol) =>
-              val TypeAlias(res) = tr.info
-              res
-            case tp => mapOver(tp)
-          }
-        },
-        treeMap = {
-          case ident: Ident if ident.isType && typeBindingsSet.contains(ident.symbol) =>
-            val TypeAlias(r) = ident.symbol.info
-            TypeTree(r).withSpan(ident.span)
-          case tree => tree
-        }
-      )
-
-      val Block(termBindings1, tree1) = inlineTypeBindings(Block(termBindings, tree))
-      inlineTermBindings(termBindings1.asInstanceOf[List[ValOrDefDef]], tree1)
-    }
   }
 
   private def expandMacro(body: Tree, span: Span)(implicit ctx: Context) = {

tests/run/typeclass-derivation2c.check

@@ -0,0 +1,6 @@
+ListBuffer(0, 11, 0, 22, 0, 33, 1)
+Cons(11,Cons(22,Cons(33,Nil)))
+ListBuffer(0, 0, 11, 0, 22, 0, 33, 1, 0, 0, 11, 0, 22, 1, 1)
+Cons(Cons(11,Cons(22,Cons(33,Nil))),Cons(Cons(11,Cons(22,Nil)),Nil))
+ListBuffer(1, 2)
+Pair(1,2)