Improvements in checking for references during ...

Improvements in checking for references during dependency analysis. For
example more carefully analysis of abstract type members, typerefs etc.
References #2793. review by dragos.

1 files changed, 33 insertions, 10 deletions

diff --git a/src/compiler/scala/tools/nsc/dependencies/DependencyAnalysis.scala b/src/compiler/scala/tools/nsc/dependencies/DependencyAnalysis.scala
index 43602aa3dd..5ce0cfdb1c 100644
--- a/src/compiler/scala/tools/nsc/dependencies/DependencyAnalysis.scala
+++ b/src/compiler/scala/tools/nsc/dependencies/DependencyAnalysis.scala
@@ -149,29 +149,52 @@ trait DependencyAnalysis extends SubComponent with Files {
               && (!tree.symbol.isPackage)
               && (!tree.symbol.hasFlag(Flags.JAVA))
               && ((tree.symbol.sourceFile eq null)
-                  || (tree.symbol.sourceFile.path != file.path))) {
-            references += file -> (references(file) + tree.symbol.fullNameString)
+                  || (tree.symbol.sourceFile.path != file.path))
+              && (!tree.symbol.isClassConstructor)) {
+            updateReferences(tree.symbol.fullNameString)
           }
+
           tree match {
             case cdef: ClassDef if !cdef.symbol.hasFlag(Flags.PACKAGE) =>
               buf += cdef.symbol
+              atPhase(currentRun.erasurePhase.prev) {
+                for (s <- cdef.symbol.info.decls)
+                  s match {
+                    case ts: TypeSymbol if !ts.isClass =>
+                      checkType(s.tpe)
+                    case _ =>
+                  }
+              }
               super.traverse(tree)
 
             case ddef: DefDef =>
-              atPhase(currentRun.erasurePhase.prev) {
-                val resTpeSym = ddef.symbol.tpe.resultType.typeSymbol
-                  if (resTpeSym.isAbstractType)
-                    references += file -> (references(file) + resTpeSym.fullNameString)
-                  for (s <- ddef.symbol.tpe.params)
-                    if (s.isAbstractType)
-                      references += file -> (references(file) + resTpeSym.fullNameString)
+              atPhase(currentRun.typerPhase.prev) {
+                checkType(ddef.symbol.tpe)
               }
               super.traverse(tree)
 
-            case _ =>
+            case _            =>
               super.traverse(tree)
           }
         }
+
+        def checkType(tpe: Type): Unit =
+          tpe match {
+            case t: MethodType =>
+              checkType(t.resultType)
+              for (s <- t.params) checkType(s.tpe)
+
+            case t: TypeRef    =>
+              updateReferences(t.typeSymbol.fullNameString)
+              for (tp <- t.args) checkType(tp)
+
+            case t             =>
+              updateReferences(t.typeSymbol.fullNameString)
+          }
+
+        def updateReferences(s: String): Unit =
+          references += file -> (references(file) + s)
+
       }).apply(unit.body)
 
       definitions(unit.source.file) = buf.toList