Include used types in the set of used names

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

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

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

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

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

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

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

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

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

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

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

incrementalcompiler/src/sbt-test/source-dependencies/types-in-used-names/test

@@ -0,0 +1,4 @@
+> compile
+$ copy-file changes/B2.scala B.scala
+# Compilation of D.scala should fail because B is no longer a subtype of A
+-> compile

internal/compiler-bridge/src-2.10/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

internal/compiler-bridge/src-2.10/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)
@@ -50,7 +50,7 @@ final class Dependency(val global: CallbackGlobal) extends LocateClassFile {
           unit.depends foreach processDependency(context = DependencyByMemberRef)
           inheritedDependencies.getOrElse(sourceFile, Nil: Iterable[Symbol]) foreach processDependency(context = DependencyByInheritance)
         }
-        /**
+        /*
          * Handles dependency on given symbol by trying to figure out if represents a term
          * that is coming from either source code (not necessarily compiled in this compilation
          * run) or from class file and calls respective callback method.
@@ -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 */

internal/compiler-bridge/src-2.10/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,11 +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 = {
@@ -92,8 +95,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 _ => ()
       }
 

internal/compiler-bridge/src-2.10/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.hasPackageFlag => tpe.typeSymbolDirect
+      })
+
+    typeSymbolCollector.traverse(tp)
+    typeSymbolCollector.collected.toSet
+  }
+}