Skip to content

Commit acb8236

Browse files
jvicanjvican
committed
Fix scala#174: Register names for types and symbols
The following commit fixes the issues with as seen from that are explained in this fantastic issue by Greg: scala#174, as well as scala#239 that handles structural types. These issues are related to the fact that our previous approach was only inspecting types, when some type information like type bounds is only present in symbols. To get that information, we need a more precise search that looks into the core of the Scalac types for the required information. Of course, type bounds is not all we're interested about. The issue is that type members, method parameters and type parameters can have type information in its definition that is necessary at the use site to detect and propagate changes. This information is also tied to the fact that type members can have different materializations depending on the prefix (both because of type members and path-dependent types). `types-in-used-names-b` and `as-seen-from-b` are a perfect example of this. This commit turns them into passing tests. Having more in-depth look at the algorithm behind it will help us understand what it does. In essence, the new type traverser is the responsible of adding dependencies on every `TypeRef` and `SingleType`. They contain concrete information about types (they are materialized), so their presence must be recorded. We also have the presence of other types like `PolyType` and `MethodType`. These types are used for defining type parameters for classes (think List[A]) and method type parameters (think def foo[T](t: T)). They are nested, meaning that their return type can also be a `PolyType` or a `MethodType`. To handle them, we traverse the symbols in their definition -- for method types we traverse the types of the parameters, while for poly types we add directly the dependency on the symbol --so that the name of the type parameters are also recorded-- and then we continue checking for their information if they are not a class, that is, if they are an abstract type with a definition that we may need to traverse (existential type, refined type, bounds, etc). In the case of `TypeBounds`, we traverse them if they are not the default specified by the SLS (`Nothing` for low bound, `Any` for high). Refined types need special handling since we need to check their declarations, that can introduce new type members or vals. If they do have them, we add a dependency right away on those definitions. As usual, `ThisType` and `ConstantType` need to be inspected by checking their underlying representation (`C` in `C.this` and `12` in `Int(12)`). `ExistentialType`, the last type on the traverser before falling back to `mapOver`, has a list of symbols called `quantified` that needs to be traversed since they are the symbol information that constrain the existential type. As in the case of `TypeBounds`, we guard against the default types `Nothing` for low bound and `Any` for high bound, so that unnecessary names that are always present in source files don't appear. This change triggers a very weird behaviour in 2.10, in which for some reason the names `Nothing` and `Any` appear. This does not seem to come from the new TypeDependencyTraverser and I've been able to track its appearance to the case in the traverser where we check for `hasSymbol` and add with `addSymbol`. I've added a TODO, which is not urgent, to find out what's happening, since this only affect one concrete snippet of the whole test code. Benchmark: ``` [info] # Run complete. Total time: 00:25:51 [info] [info] Benchmark (_tempDir) Mode Cnt Score Error Units [info] HotScalacBenchmark.compile /tmp/sbt_abdb5ed2 sample 18 20893.226 ± 625.622 ms/op [info] HotScalacBenchmark.compile:compile·p0.00 /tmp/sbt_abdb5ed2 sample 19797.115 ms/op [info] HotScalacBenchmark.compile:compile·p0.50 /tmp/sbt_abdb5ed2 sample 21005.074 ms/op [info] HotScalacBenchmark.compile:compile·p0.90 /tmp/sbt_abdb5ed2 sample 21894.267 ms/op [info] HotScalacBenchmark.compile:compile·p0.95 /tmp/sbt_abdb5ed2 sample 22045.262 ms/op [info] HotScalacBenchmark.compile:compile·p0.99 /tmp/sbt_abdb5ed2 sample 22045.262 ms/op [info] HotScalacBenchmark.compile:compile·p0.999 /tmp/sbt_abdb5ed2 sample 22045.262 ms/op [info] HotScalacBenchmark.compile:compile·p0.9999 /tmp/sbt_abdb5ed2 sample 22045.262 ms/op [info] HotScalacBenchmark.compile:compile·p1.00 /tmp/sbt_abdb5ed2 sample 22045.262 ms/op [info] HotScalacBenchmark.compile:·gc.alloc.rate /tmp/sbt_abdb5ed2 sample 18 289.838 ± 8.669 MB/sec [info] HotScalacBenchmark.compile:·gc.alloc.rate.norm /tmp/sbt_abdb5ed2 sample 18 6500730176.000 ± 13633760.029 B/op [info] HotScalacBenchmark.compile:·gc.churn.PS_Eden_Space /tmp/sbt_abdb5ed2 sample 18 289.082 ± 24.260 MB/sec [info] HotScalacBenchmark.compile:·gc.churn.PS_Eden_Space.norm /tmp/sbt_abdb5ed2 sample 18 6480403569.778 ± 464987965.594 B/op [info] HotScalacBenchmark.compile:·gc.churn.PS_Old_Gen /tmp/sbt_abdb5ed2 sample 18 12.679 ± 12.697 MB/sec [info] HotScalacBenchmark.compile:·gc.churn.PS_Old_Gen.norm /tmp/sbt_abdb5ed2 sample 18 290767194.667 ± 290528363.065 B/op [info] HotScalacBenchmark.compile:·gc.churn.PS_Survivor_Space /tmp/sbt_abdb5ed2 sample 18 7.321 ± 2.865 MB/sec [info] HotScalacBenchmark.compile:·gc.churn.PS_Survivor_Space.norm /tmp/sbt_abdb5ed2 sample 18 165547052.444 ± 66661097.019 B/op [info] HotScalacBenchmark.compile:·gc.count /tmp/sbt_abdb5ed2 sample 18 101.000 counts [info] HotScalacBenchmark.compile:·gc.time /tmp/sbt_abdb5ed2 sample 18 21332.000 ms [info] WarmScalacBenchmark.compile /tmp/sbt_abdb5ed2 sample 3 52769.937 ± 6743.004 ms/op [info] WarmScalacBenchmark.compile:compile·p0.00 /tmp/sbt_abdb5ed2 sample 52412.023 ms/op [info] WarmScalacBenchmark.compile:compile·p0.50 /tmp/sbt_abdb5ed2 sample 52747.567 ms/op [info] WarmScalacBenchmark.compile:compile·p0.90 /tmp/sbt_abdb5ed2 sample 53150.220 ms/op [info] WarmScalacBenchmark.compile:compile·p0.95 /tmp/sbt_abdb5ed2 sample 53150.220 ms/op [info] WarmScalacBenchmark.compile:compile·p0.99 /tmp/sbt_abdb5ed2 sample 53150.220 ms/op [info] WarmScalacBenchmark.compile:compile·p0.999 /tmp/sbt_abdb5ed2 sample 53150.220 ms/op [info] WarmScalacBenchmark.compile:compile·p0.9999 /tmp/sbt_abdb5ed2 sample 53150.220 ms/op [info] WarmScalacBenchmark.compile:compile·p1.00 /tmp/sbt_abdb5ed2 sample 53150.220 ms/op [info] WarmScalacBenchmark.compile:·gc.alloc.rate /tmp/sbt_abdb5ed2 sample 3 125.382 ± 13.840 MB/sec [info] WarmScalacBenchmark.compile:·gc.alloc.rate.norm /tmp/sbt_abdb5ed2 sample 3 7055970890.667 ± 1078954896.900 B/op [info] WarmScalacBenchmark.compile:·gc.churn.PS_Eden_Space /tmp/sbt_abdb5ed2 sample 3 117.215 ± 73.864 MB/sec [info] WarmScalacBenchmark.compile:·gc.churn.PS_Eden_Space.norm /tmp/sbt_abdb5ed2 sample 3 6596470733.333 ± 4281843293.325 B/op [info] WarmScalacBenchmark.compile:·gc.churn.PS_Survivor_Space /tmp/sbt_abdb5ed2 sample 3 2.279 ± 1.015 MB/sec [info] WarmScalacBenchmark.compile:·gc.churn.PS_Survivor_Space.norm /tmp/sbt_abdb5ed2 sample 3 128269752.000 ± 72721263.065 B/op [info] WarmScalacBenchmark.compile:·gc.count /tmp/sbt_abdb5ed2 sample 3 73.000 counts [info] WarmScalacBenchmark.compile:·gc.time /tmp/sbt_abdb5ed2 sample 3 8746.000 ms [info] ColdScalacBenchmark.compile /tmp/sbt_abdb5ed2 ss 10 44611.286 ± 963.131 ms/op [info] ColdScalacBenchmark.compile:·gc.alloc.rate /tmp/sbt_abdb5ed2 ss 10 152.054 ± 2.753 MB/sec [info] ColdScalacBenchmark.compile:·gc.alloc.rate.norm /tmp/sbt_abdb5ed2 ss 10 7249761568.800 ± 95126804.264 B/op [info] ColdScalacBenchmark.compile:·gc.churn.PS_Eden_Space /tmp/sbt_abdb5ed2 ss 10 144.481 ± 9.964 MB/sec [info] ColdScalacBenchmark.compile:·gc.churn.PS_Eden_Space.norm /tmp/sbt_abdb5ed2 ss 10 6889406191.200 ± 490961958.245 B/op [info] ColdScalacBenchmark.compile:·gc.churn.PS_Old_Gen /tmp/sbt_abdb5ed2 ss 10 ≈ 10⁻³ MB/sec [info] ColdScalacBenchmark.compile:·gc.churn.PS_Old_Gen.norm /tmp/sbt_abdb5ed2 ss 10 21136.000 ± 101049.368 B/op [info] ColdScalacBenchmark.compile:·gc.churn.PS_Survivor_Space /tmp/sbt_abdb5ed2 ss 10 2.848 ± 0.335 MB/sec [info] ColdScalacBenchmark.compile:·gc.churn.PS_Survivor_Space.norm /tmp/sbt_abdb5ed2 ss 10 135792956.800 ± 16291050.509 B/op [info] ColdScalacBenchmark.compile:·gc.count /tmp/sbt_abdb5ed2 ss 10 248.000 counts [info] ColdScalacBenchmark.compile:·gc.time /tmp/sbt_abdb5ed2 ss 10 29901.000 ms [success] Total time: 1553 s, completed Feb 26, 2017 3:06:29 AM [success] Total time: 0 s, completed Feb 26, 2017 3:06:29 AM ``` Rewritten from sbt/zinc@929b758
1 parent 57d2439 commit acb8236

10 files changed

+311
-45
lines changed

‎src-2.10/main/scala/xsbt/Dependency.scala

Lines changed: 18 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -228,11 +228,19 @@ final class Dependency(val global: CallbackGlobal) extends LocateClassFile with
228228
private def addTreeDependency(tree: Tree): Unit = {
229229
addDependency(tree.symbol)
230230
val tpe = tree.tpe
231-
if (!ignoredType(tpe))
232-
foreachNotPackageSymbolInType(tpe)(addDependency)
231+
if (!ignoredType(tpe)) {
232+
addTypeDependencies(tpe)
233+
}
233234
()
234235
}
235236

237+
def addTypeDependencies(tpe: Type): Unit = {
238+
// Defined in GlobalHelpers.scala
239+
object TypeDependencyTraverser extends TypeDependencyTraverser(addDependency)
240+
TypeDependencyTraverser.traverse(tpe)
241+
TypeDependencyTraverser.reinitializeVisited()
242+
}
243+
236244
private def addDependency(dep: Symbol): Unit = {
237245
val fromClass = resolveDependencySource().fromClass
238246
if (ignoredSymbol(fromClass) || fromClass.hasPackageFlag) {
@@ -305,15 +313,19 @@ final class Dependency(val global: CallbackGlobal) extends LocateClassFile with
305313

306314
debuglog("Parent types for " + tree.symbol + " (self: " + self.tpt.tpe + "): " + inheritanceTypes + " with symbols " + inheritanceSymbols.map(_.fullName))
307315

308-
inheritanceSymbols.foreach(addSymbolFromParent)
309-
inheritanceTypes.foreach(addSymbolsFromType)
310-
addSymbolsFromType(self.tpt.tpe)
316+
inheritanceSymbols.foreach { symbol =>
317+
addInheritanceDependency(symbol)
318+
addDependency(symbol)
319+
}
320+
321+
inheritanceTypes.foreach(addTypeDependencies)
322+
addTypeDependencies(self.tpt.tpe)
311323

312324
traverseTrees(body)
313325

314326
// In some cases (eg. macro annotations), `typeTree.tpe` may be null. See sbt/sbt#1593 and sbt/sbt#1655.
315327
case typeTree: TypeTree if !ignoredType(typeTree.tpe) =>
316-
foreachNotPackageSymbolInType(typeTree.tpe)(addDependency)
328+
addTypeDependencies(typeTree.tpe)
317329
case m @ MacroExpansionOf(original) if inspectedOriginalTrees.add(original) =>
318330
traverse(original)
319331
super.traverse(m)
@@ -325,13 +337,5 @@ final class Dependency(val global: CallbackGlobal) extends LocateClassFile with
325337
super.traverse(tree)
326338
case other => super.traverse(other)
327339
}
328-
329-
val addSymbolFromParent: Symbol => Unit = { symbol =>
330-
addInheritanceDependency(symbol)
331-
addDependency(symbol)
332-
}
333-
val addSymbolsFromType: Type => Unit = { tpe =>
334-
foreachNotPackageSymbolInType(tpe)(addDependency)
335-
}
336340
}
337341
}

‎src-2.10/main/scala/xsbt/ExtractUsedNames.scala

Lines changed: 11 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -92,6 +92,7 @@ class ExtractUsedNames[GlobalType <: CallbackGlobal](val global: GlobalType) ext
9292
// Synthetic names are no longer included. See https://github.com/sbt/sbt/issues/2537
9393
if (!isEmptyName(name) && !enclosingNonLocalClass.containsName(name))
9494
enclosingNonLocalClass.addName(name)
95+
()
9596
}
9697
}
9798

@@ -123,6 +124,8 @@ class ExtractUsedNames[GlobalType <: CallbackGlobal](val global: GlobalType) ext
123124
}
124125
}
125126

127+
object TypeDependencyTraverser extends TypeDependencyTraverser(addSymbol)
128+
126129
private def handleClassicTreeNode(tree: Tree): Unit = tree match {
127130
case _: DefTree | _: Template => ()
128131
case Import(_, selectors: List[ImportSelector]) =>
@@ -149,9 +152,14 @@ class ExtractUsedNames[GlobalType <: CallbackGlobal](val global: GlobalType) ext
149152
original.foreach(traverse)
150153
}
151154
case t if t.hasSymbol =>
152-
addSymbol(t.symbol)
153-
if (t.tpe != null)
154-
foreachNotPackageSymbolInType(t.tpe)(addSymbol)
155+
val symbol = t.symbol
156+
if (symbol != rootMirror.RootPackage)
157+
addSymbol(t.symbol)
158+
val tpe = t.tpe
159+
if (!ignoredType(tpe)) {
160+
TypeDependencyTraverser.traverse(tpe)
161+
TypeDependencyTraverser.reinitializeVisited()
162+
}
155163
case _ =>
156164
}
157165

‎src-2.10/main/scala/xsbt/GlobalHelpers.scala

Lines changed: 88 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -40,6 +40,94 @@ trait GlobalHelpers {
4040
}).traverse(tpe)
4141
}
4242

43+
private[xsbt] class TypeDependencyTraverser(addDependency: Symbol => Unit)
44+
extends TypeTraverser {
45+
46+
/** Add type dependency ignoring packages and inheritance info from classes. */
47+
@inline private def addTypeSymbolDependency(symbol: Symbol): Unit = {
48+
addDependency(symbol)
49+
if (!symbol.isClass) {
50+
traverse(symbol.info)
51+
}
52+
}
53+
54+
/** Add type dependency *AND* traverse prefix iff is not a package. */
55+
@inline private def addTypeDependency(tpe: Type): Unit = {
56+
val symbol = tpe.typeSymbolDirect
57+
if (!symbol.hasPackageFlag) {
58+
addTypeSymbolDependency(symbol)
59+
traverse(tpe.prefix)
60+
}
61+
}
62+
63+
// Define cache and populate it with known types at initialization time
64+
private val visited = scala.collection.mutable.HashSet.empty[Type]
65+
66+
/** Clear the cache after every `traverse` invocation at the call-site. */
67+
private[xsbt] def reinitializeVisited(): Unit = visited.clear()
68+
69+
/**
70+
* Traverse the type and its info to track all type dependencies.
71+
*
72+
* Note that tpe cannot be either `NoSymbol` or `null`.
73+
* Check that you don't pass those types at the call-site.
74+
*/
75+
override def traverse(tpe: Type): Unit = {
76+
if ((tpe ne NoType) && !visited.contains(tpe)) {
77+
visited += tpe
78+
tpe match {
79+
case singleRef: SingleType =>
80+
addTypeDependency(singleRef)
81+
82+
case typeRef: TypeRef =>
83+
// Traverse materialized type arguments
84+
typeRef.typeArguments.foreach(traverse)
85+
addTypeDependency(typeRef)
86+
87+
case MethodType(_, _) =>
88+
// Traverse the types of method parameters definitions
89+
tpe.params.foreach(param => traverse(param.tpe))
90+
// Traverse return type
91+
traverse(tpe.resultType)
92+
93+
case PolyType(_, _) =>
94+
// Traverse the symbols of poly types and their prefixes
95+
tpe.typeParams.foreach { typeParam =>
96+
addTypeSymbolDependency(typeParam)
97+
val prefix = typeParam.info.prefix
98+
if (!prefix.typeSymbolDirect.hasPackageFlag)
99+
traverse(prefix)
100+
}
101+
// Traverse return type
102+
traverse(tpe.resultType)
103+
104+
case TypeBounds(lo, hi) =>
105+
// Ignore default types for lo and hi bounds
106+
if (!(lo == definitions.NothingTpe)) traverse(lo)
107+
if (!(hi == definitions.AnyTpe)) traverse(hi)
108+
109+
case RefinedType(parents, decls) =>
110+
parents.foreach(traverse)
111+
decls.toIterator.foreach { decl =>
112+
if (decl.isType) addTypeSymbolDependency(decl)
113+
else addDependency(decl)
114+
}
115+
116+
case ExistentialType(quantified, underlying) =>
117+
quantified.foreach(quantified => traverse(quantified.tpe))
118+
traverse(underlying)
119+
120+
case ThisType(_) | ConstantType(_) =>
121+
traverse(tpe.underlying)
122+
123+
case _ =>
124+
mapOver(tpe)
125+
()
126+
}
127+
}
128+
}
129+
}
130+
43131
/** Returns true if given tree contains macro attchment. In such case calls func on tree from attachment. */
44132
def processMacroExpansion(in: Tree)(func: Tree => Unit): Boolean = {
45133
// Hotspot

‎src/main/scala/xsbt/Dependency.scala

Lines changed: 18 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -249,11 +249,19 @@ final class Dependency(val global: CallbackGlobal) extends LocateClassFile with
249249
private def addTreeDependency(tree: Tree): Unit = {
250250
addDependency(tree.symbol)
251251
val tpe = tree.tpe
252-
if (!ignoredType(tpe))
253-
foreachNotPackageSymbolInType(tpe)(addDependency)
252+
if (!ignoredType(tpe)) {
253+
addTypeDependencies(tpe)
254+
}
254255
()
255256
}
256257

258+
def addTypeDependencies(tpe: Type): Unit = {
259+
// Defined in GlobalHelpers.scala
260+
object TypeDependencyTraverser extends TypeDependencyTraverser(addDependency)
261+
TypeDependencyTraverser.traverse(tpe)
262+
TypeDependencyTraverser.reinitializeVisited()
263+
}
264+
257265
private def addDependency(dep: Symbol): Unit = {
258266
val fromClass = resolveDependencySource
259267
if (ignoredSymbol(fromClass) || fromClass.hasPackageFlag) {
@@ -325,15 +333,19 @@ final class Dependency(val global: CallbackGlobal) extends LocateClassFile with
325333

326334
debuglog("Parent types for " + tree.symbol + " (self: " + self.tpt.tpe + "): " + inheritanceTypes + " with symbols " + inheritanceSymbols.map(_.fullName))
327335

328-
inheritanceSymbols.foreach(addSymbolFromParent)
329-
inheritanceTypes.foreach(addSymbolsFromType)
330-
addSymbolsFromType(self.tpt.tpe)
336+
inheritanceSymbols.foreach { symbol =>
337+
addInheritanceDependency(symbol)
338+
addDependency(symbol)
339+
}
340+
341+
inheritanceTypes.foreach(addTypeDependencies)
342+
addTypeDependencies(self.tpt.tpe)
331343

332344
traverseTrees(body)
333345

334346
// In some cases (eg. macro annotations), `typeTree.tpe` may be null. See sbt/sbt#1593 and sbt/sbt#1655.
335347
case typeTree: TypeTree if !ignoredType(typeTree.tpe) =>
336-
foreachNotPackageSymbolInType(typeTree.tpe)(addDependency)
348+
addTypeDependencies(typeTree.tpe)
337349
case m @ MacroExpansionOf(original) if inspectedOriginalTrees.add(original) =>
338350
traverse(original)
339351
super.traverse(m)
@@ -345,13 +357,5 @@ final class Dependency(val global: CallbackGlobal) extends LocateClassFile with
345357
super.traverse(tree)
346358
case other => super.traverse(other)
347359
}
348-
349-
val addSymbolFromParent: Symbol => Unit = { symbol =>
350-
addInheritanceDependency(symbol)
351-
addDependency(symbol)
352-
}
353-
val addSymbolsFromType: Type => Unit = { tpe =>
354-
foreachNotPackageSymbolInType(tpe)(addDependency)
355-
}
356360
}
357361
}

‎src/main/scala/xsbt/ExtractUsedNames.scala

Lines changed: 8 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -99,6 +99,7 @@ class ExtractUsedNames[GlobalType <: CallbackGlobal](val global: GlobalType) ext
9999
// Synthetic names are no longer included. See https://github.com/sbt/sbt/issues/2537
100100
if (!isEmptyName(name) && !names.contains(name))
101101
names += name
102+
()
102103
}
103104
}
104105

@@ -130,6 +131,8 @@ class ExtractUsedNames[GlobalType <: CallbackGlobal](val global: GlobalType) ext
130131
}
131132
}
132133

134+
object TypeDependencyTraverser extends TypeDependencyTraverser(addSymbol)
135+
133136
private def handleClassicTreeNode(tree: Tree): Unit = tree match {
134137
case _: DefTree | _: Template => ()
135138
case Import(_, selectors: List[ImportSelector]) =>
@@ -156,8 +159,11 @@ class ExtractUsedNames[GlobalType <: CallbackGlobal](val global: GlobalType) ext
156159
}
157160
case t if t.hasSymbolField =>
158161
addSymbol(t.symbol)
159-
if (t.tpe != null)
160-
foreachNotPackageSymbolInType(t.tpe)(addSymbol)
162+
val tpe = t.tpe
163+
if (!ignoredType(tpe)) {
164+
TypeDependencyTraverser.traverse(tpe)
165+
TypeDependencyTraverser.reinitializeVisited()
166+
}
161167
case _ =>
162168
}
163169

‎src/main/scala/xsbt/GlobalHelpers.scala

Lines changed: 88 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -46,6 +46,94 @@ trait GlobalHelpers {
4646
}).traverse(tpe)
4747
}
4848

49+
private[xsbt] class TypeDependencyTraverser(addDependency: Symbol => Unit)
50+
extends TypeTraverser {
51+
52+
/** Add type dependency ignoring packages and inheritance info from classes. */
53+
@inline private def addTypeSymbolDependency(symbol: Symbol): Unit = {
54+
addDependency(symbol)
55+
if (!symbol.isClass) {
56+
traverse(symbol.info)
57+
}
58+
}
59+
60+
/** Add type dependency *AND* traverse prefix iff is not a package. */
61+
@inline private def addTypeDependency(tpe: Type): Unit = {
62+
val symbol = tpe.typeSymbolDirect
63+
if (!symbol.hasPackageFlag) {
64+
addTypeSymbolDependency(symbol)
65+
traverse(tpe.prefix)
66+
}
67+
}
68+
69+
// Define cache and populate it with known types at initialization time
70+
private val visited = scala.collection.mutable.HashSet.empty[Type]
71+
72+
/** Clear the cache after every `traverse` invocation at the call-site. */
73+
private[xsbt] def reinitializeVisited(): Unit = visited.clear()
74+
75+
/**
76+
* Traverse the type and its info to track all type dependencies.
77+
*
78+
* Note that tpe cannot be either `NoSymbol` or `null`.
79+
* Check that you don't pass those types at the call-site.
80+
*/
81+
override def traverse(tpe: Type): Unit = {
82+
if ((tpe ne NoType) && !visited.contains(tpe)) {
83+
visited += tpe
84+
tpe match {
85+
case singleRef: SingleType =>
86+
addTypeDependency(singleRef)
87+
88+
case typeRef: TypeRef =>
89+
// Traverse materialized type arguments
90+
typeRef.typeArguments.foreach(traverse)
91+
addTypeDependency(typeRef)
92+
93+
case MethodType(_, _) =>
94+
// Traverse the types of method parameters definitions
95+
tpe.params.foreach(param => traverse(param.tpe))
96+
// Traverse return type
97+
traverse(tpe.resultType)
98+
99+
case PolyType(_, _) =>
100+
// Traverse the symbols of poly types and their prefixes
101+
tpe.typeParams.foreach { typeParam =>
102+
addTypeSymbolDependency(typeParam)
103+
val prefix = typeParam.info.prefix
104+
if (!prefix.typeSymbolDirect.hasPackageFlag)
105+
traverse(prefix)
106+
}
107+
// Traverse return type
108+
traverse(tpe.resultType)
109+
110+
case TypeBounds(lo, hi) =>
111+
// Ignore default types for lo and hi bounds
112+
if (!(lo == definitions.NothingTpe)) traverse(lo)
113+
if (!(hi == definitions.AnyTpe)) traverse(hi)
114+
115+
case RefinedType(parents, decls) =>
116+
parents.foreach(traverse)
117+
decls.toIterator.foreach { decl =>
118+
if (decl.isType) addTypeSymbolDependency(decl)
119+
else addDependency(decl)
120+
}
121+
122+
case ExistentialType(quantified, underlying) =>
123+
quantified.foreach(quantified => traverse(quantified.tpe))
124+
traverse(underlying)
125+
126+
case ThisType(_) | ConstantType(_) =>
127+
traverse(tpe.underlying)
128+
129+
case _ =>
130+
mapOver(tpe)
131+
()
132+
}
133+
}
134+
}
135+
}
136+
49137
/** Returns true if given tree contains macro attchment. In such case calls func on tree from attachment. */
50138
def processMacroExpansion(in: Tree)(func: Tree => Unit): Boolean = {
51139
// Hotspot

‎src/test/scala/xsbt/DependencySpecification.scala

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -19,7 +19,7 @@ class DependencySpecification extends UnitSpec {
1919
assert(inheritance("D") === Set.empty)
2020
assert(memberRef("E") === Set.empty)
2121
assert(inheritance("E") === Set.empty)
22-
assert(memberRef("F") === Set("A", "B", "D", "E", "G"))
22+
assert(memberRef("F") === Set("A", "B", "D", "E", "G", "C")) // C is the underlying type of MyC
2323
assert(inheritance("F") === Set("A", "E"))
2424
assert(memberRef("H") === Set("B", "E", "G"))
2525
// aliases and applied type constructors are expanded so we have inheritance dependency on B
@@ -88,7 +88,7 @@ class DependencySpecification extends UnitSpec {
8888
val inheritance = classDependencies.inheritance
8989
assert(memberRef("Outer") === Set.empty)
9090
assert(inheritance("Outer") === Set.empty)
91-
assert(memberRef("Bar") === Set("Outer"))
91+
assert(memberRef("Bar") === Set("Outer", "Outer.Inner"))
9292
assert(inheritance("Bar") === Set.empty)
9393
}
9494

0 commit comments

Comments
 (0)