Include used types in the set of used names

This is a backport of sbt/zinc#87

When `B2.scala` replaces `B.scala` in the new test
`source-dependencies/types-in-used-names`, the name hash of `listb` does
not change because the signature of `C.listb` is still `List[B]`,
however users of `C.listb` have to be recompiled since the subtyping
relationships of its type have changed.

This commit does this by extending the definition of "used names" to
also include the names of the types of trees, even if these types
do not appear in the source like `List[B]` in `D.scala` (since `B` has
been invalidated, this will force the recompilation of `D.scala`).

Author: smarter

compile/interface/src/main/scala/xsbt/Compat.scala

@@ -51,6 +51,22 @@ abstract class Compat {
     def transformedType(tpe: Type): Type = tpe
   }
 
+  /**
+   * Traverses given type and collects result of applying a partial function `pf`.
+   *
+   * NOTE: This class exists in Scala 2.10 as CollectTypeCollector but does not in earlier
+   * versions (like 2.9) of Scala compiler that incremental cmpiler supports so we had to
+   * reimplement that class here.
+   */
+  class CollectTypeTraverser[T](pf: PartialFunction[Type, T]) extends TypeTraverser {
+    var collected: List[T] = Nil
+    def traverse(tpe: Type): Unit = {
+      if (pf.isDefinedAt(tpe))
+        collected = pf(tpe) :: collected
+      mapOver(tpe)
+    }
+  }
+
   private[this] final class MiscCompat {
     // in 2.9, nme.LOCALCHILD was renamed to tpnme.LOCAL_CHILD
     def tpnme = nme

compile/interface/src/main/scala/xsbt/Dependency.scala

@@ -29,7 +29,7 @@ object Dependency {
  * where it originates from. The Symbol->Classfile mapping is implemented by
  * LocateClassFile that we inherit from.
  */
-final class Dependency(val global: CallbackGlobal) extends LocateClassFile {
+final class Dependency(val global: CallbackGlobal) extends LocateClassFile with GlobalHelpers {
   import global._
 
   def newPhase(prev: Phase): Phase = new DependencyPhase(prev)
@@ -79,6 +79,12 @@ final class Dependency(val global: CallbackGlobal) extends LocateClassFile {
   private class ExtractDependenciesTraverser extends Traverser {
     private val _dependencies = collection.mutable.HashSet.empty[Symbol]
     protected def addDependency(dep: Symbol): Unit = if (dep ne NoSymbol) _dependencies += dep
+    protected def addTreeDependency(tree: Tree): Unit = {
+      addDependency(tree.symbol)
+      if (tree.tpe != null)
+        symbolsInType(tree.tpe).foreach(addDependency)
+      ()
+    }
     def dependencies: Iterator[Symbol] = _dependencies.iterator
     def topLevelDependencies: Iterator[Symbol] = _dependencies.map(enclosingTopLevelClass).iterator
 
@@ -118,11 +124,11 @@ final class Dependency(val global: CallbackGlobal) extends LocateClassFile {
        *    this looks fishy, see this thread:
        *    https://groups.google.com/d/topic/scala-internals/Ms9WUAtokLo/discussion
        */
-      case id: Ident => addDependency(id.symbol)
+      case id: Ident => addTreeDependency(id)
       case sel @ Select(qual, _) =>
-        traverse(qual); addDependency(sel.symbol)
+        traverse(qual); addTreeDependency(sel)
       case sel @ SelectFromTypeTree(qual, _) =>
-        traverse(qual); addDependency(sel.symbol)
+        traverse(qual); addTreeDependency(sel)
 
       case Template(parents, self, body) =>
         // use typeSymbol to dealias type aliases -- we want to track the dependency on the real class in the alias's RHS
@@ -149,32 +155,6 @@ final class Dependency(val global: CallbackGlobal) extends LocateClassFile {
       case MacroExpansionOf(original) if inspectedOriginalTrees.add(original) => traverse(original)
       case other => super.traverse(other)
     }
-
-    private def symbolsInType(tp: Type): Set[Symbol] = {
-      val typeSymbolCollector =
-        new CollectTypeTraverser({
-          case tpe if (tpe != null) && !tpe.typeSymbolDirect.isPackage => tpe.typeSymbolDirect
-        })
-
-      typeSymbolCollector.traverse(tp)
-      typeSymbolCollector.collected.toSet
-    }
-  }
-
-  /**
-   * Traverses given type and collects result of applying a partial function `pf`.
-   *
-   * NOTE: This class exists in Scala 2.10 as CollectTypeCollector but does not in earlier
-   * versions (like 2.9) of Scala compiler that incremental cmpiler supports so we had to
-   * reimplement that class here.
-   */
-  private final class CollectTypeTraverser[T](pf: PartialFunction[Type, T]) extends TypeTraverser {
-    var collected: List[T] = Nil
-    def traverse(tpe: Type): Unit = {
-      if (pf.isDefinedAt(tpe))
-        collected = pf(tpe) :: collected
-      mapOver(tpe)
-    }
   }
 
   /** Copied straight from Scala 2.10 as it does not exist in Scala 2.9 compiler */

compile/interface/src/main/scala/xsbt/ExtractUsedNames.scala

@@ -7,6 +7,8 @@ import scala.tools.nsc._
  *
  * Extracts simple (unqualified) names mentioned in given in non-definition position by collecting
  * all symbols associated with non-definition trees and extracting names from all collected symbols.
+ * Also extract the names of the types of non-definition trees (see source-dependencies/types-in-used-names
+ * for an example where this is required).
  *
  * If given symbol is mentioned both in definition and in non-definition position (e.g. in member
  * selection) then that symbol is collected. It means that names of symbols defined and used in the
@@ -38,7 +40,7 @@ import scala.tools.nsc._
  * The tree walking algorithm walks into TypeTree.original explicitly.
  *
  */
-class ExtractUsedNames[GlobalType <: CallbackGlobal](val global: GlobalType) extends Compat {
+class ExtractUsedNames[GlobalType <: CallbackGlobal](val global: GlobalType) extends Compat with GlobalHelpers {
   import global._
 
   def extract(unit: CompilationUnit): Set[String] = {
@@ -59,10 +61,12 @@ class ExtractUsedNames[GlobalType <: CallbackGlobal](val global: GlobalType) ext
      */
     val inspectedOriginalTrees = collection.mutable.Set.empty[Tree]
 
-    def addSymbol(symbol: Symbol): Unit = {
-      val symbolNameAsString = symbol.name.decode.trim
-      namesBuffer += symbolNameAsString
-    }
+    def addSymbol(symbol: Symbol): Unit =
+      if (eligibleAsUsedName(symbol)) {
+        val symbolNameAsString = symbol.name.decode.trim
+        namesBuffer += symbolNameAsString
+        ()
+      }
 
     def handleTreeNode(node: Tree): Unit = {
       def handleMacroExpansion(original: Tree): Unit = {
@@ -89,8 +93,10 @@ class ExtractUsedNames[GlobalType <: CallbackGlobal](val global: GlobalType) ext
         // not what we need
         case t: TypeTree if t.original != null =>
           t.original.foreach(handleTreeNode)
-        case t if t.hasSymbol && eligibleAsUsedName(t.symbol) =>
+        case t if t.hasSymbol =>
           addSymbol(t.symbol)
+          if (t.tpe != null)
+            symbolsInType(t.tpe).foreach(addSymbol)
         case _ => ()
       }
 

compile/interface/src/main/scala/xsbt/GlobalHelpers.scala

@@ -0,0 +1,18 @@
+package xsbt
+
+import scala.tools.nsc.Global
+
+trait GlobalHelpers extends Compat {
+  val global: CallbackGlobal
+  import global.{ Tree, Type, Symbol, TypeTraverser }
+
+  def symbolsInType(tp: Type): Set[Symbol] = {
+    val typeSymbolCollector =
+      new CollectTypeTraverser({
+        case tpe if (tpe != null) && !tpe.typeSymbolDirect.isPackage => tpe.typeSymbolDirect
+      })
+
+    typeSymbolCollector.traverse(tp)
+    typeSymbolCollector.collected.toSet
+  }
+}

compile/interface/src/test/scala/xsbt/ExtractUsedNamesSpecification.scala

@@ -17,8 +17,9 @@ class ExtractUsedNamesSpecification extends Specification {
    * definition.
    */
   private val standardNames = Set(
-    // AnyRef is added as default parent of a class
-    "scala", "AnyRef",
+    "scala",
+    // The default parent of a class is "AnyRef" which is an alias for "Object"
+    "AnyRef", "Object",
     // class receives a default constructor which is internally called "<init>"
     "<init>")
 
@@ -69,7 +70,45 @@ class ExtractUsedNamesSpecification extends Specification {
 			|}""".stripMargin
     val compilerForTesting = new ScalaCompilerForUnitTesting(nameHashing = true)
     val usedNames = compilerForTesting.extractUsedNamesFromSrc(srcA, srcB)
-    val expectedNames = standardNames ++ Set("A", "a", "B", "=")
+    val expectedNames = standardNames ++ Set("A", "a", "B", "=", "Int")
+    usedNames === expectedNames
+  }
+
+  "extract names in the types of trees" in {
+    val src1 = """|class X0
+                  |class X1 extends X0
+                  |class Y
+                  |class A {
+                  |  type T >: X1 <: X0
+                  |}
+                  |class M
+                  |class N
+                  |class P0
+                  |class P1 extends P0
+                  |object B {
+                  |  type S = Y
+                  |  val lista: List[A] = ???
+                  |  val at: A#T = ???
+                  |  val as: S = ???
+                  |  def foo(m: M): N = ???
+                  |  def bar[Param >: P1 <: P0](p: Param): Param = ???
+                  |}""".stripMargin
+    val src2 = """|object Test {
+                  |  val x = B.lista
+                  |  val y = B.at
+                  |  val z = B.as
+                  |  B.foo(???)
+                  |  B.bar(???)
+                  |}""".stripMargin
+    val compilerForTesting = new ScalaCompilerForUnitTesting(nameHashing = true)
+    val usedNames = compilerForTesting.extractUsedNamesFromSrc(src1, src2)
+    val expectedNames = standardNames ++ Set("Test", "B", "x", "y", "z",
+      "Predef", "???", "Nothing",
+      "lista", "package", "List", "A",
+      "at", "T",
+      "as", "S",
+      "foo", "M", "N",
+      "bar", "Param", "P1", "P0")
     usedNames === expectedNames
   }
 

sbt/src/sbt-test/source-dependencies/types-in-used-names/A.scala

@@ -0,0 +1 @@
+class A

sbt/src/sbt-test/source-dependencies/types-in-used-names/B.scala

@@ -0,0 +1 @@
+class B extends A

sbt/src/sbt-test/source-dependencies/types-in-used-names/C.scala

@@ -0,0 +1,3 @@
+object C {
+  val listb: List[B] = List(new B)
+}

sbt/src/sbt-test/source-dependencies/types-in-used-names/D.scala

@@ -0,0 +1,3 @@
+object D {
+  val lista: List[A] = C.listb
+}

sbt/src/sbt-test/source-dependencies/types-in-used-names/changes/B2.scala

@@ -0,0 +1 @@
+class B