@@ -699,7 +699,7 @@ object SymDenotations {
699
699
| is not a subclass of ${owner.showLocated} where target is defined """ )
700
700
else if (
701
701
! ( isType // allow accesses to types from arbitrary subclasses fixes #4737
702
- || pre.baseTypeRef (cls).exists // ??? why not use derivesFrom ???
702
+ || pre.derivesFrom (cls)
703
703
|| isConstructor
704
704
|| (owner is ModuleClass ) // don't perform this check for static members
705
705
))
@@ -1266,10 +1266,10 @@ object SymDenotations {
1266
1266
private [this ] var myMemberCache : LRUCache [Name , PreDenotation ] = null
1267
1267
private [this ] var myMemberCachePeriod : Period = Nowhere
1268
1268
1269
- /** A cache from types T to baseTypeRef (T, C) */
1270
- type BaseTypeRefMap = java.util.HashMap [CachedType , Type ]
1271
- private [this ] var myBaseTypeRefCache : BaseTypeRefMap = null
1272
- private [this ] var myBaseTypeRefCachePeriod : Period = Nowhere
1269
+ /** A cache from types T to baseType (T, C) */
1270
+ type BaseTypeMap = java.util.HashMap [CachedType , Type ]
1271
+ private [this ] var myBaseTypeCache : BaseTypeMap = null
1272
+ private [this ] var myBaseTypeCachePeriod : Period = Nowhere
1273
1273
1274
1274
private var baseDataCache : BaseData = BaseData .None
1275
1275
private var memberNamesCache : MemberNames = MemberNames .None
@@ -1282,14 +1282,14 @@ object SymDenotations {
1282
1282
myMemberCache
1283
1283
}
1284
1284
1285
- private def baseTypeRefCache (implicit ctx : Context ): BaseTypeRefMap = {
1286
- if (myBaseTypeRefCachePeriod != ctx.period &&
1287
- (myBaseTypeRefCachePeriod .runId != ctx.runId ||
1288
- ctx.phases(myBaseTypeRefCachePeriod .phaseId).sameParentsStartId != ctx.phase.sameParentsStartId)) {
1289
- myBaseTypeRefCache = new BaseTypeRefMap
1290
- myBaseTypeRefCachePeriod = ctx.period
1285
+ private def baseTypeCache (implicit ctx : Context ): BaseTypeMap = {
1286
+ if (myBaseTypeCachePeriod != ctx.period &&
1287
+ (myBaseTypeCachePeriod .runId != ctx.runId ||
1288
+ ctx.phases(myBaseTypeCachePeriod .phaseId).sameParentsStartId != ctx.phase.sameParentsStartId)) {
1289
+ myBaseTypeCache = new BaseTypeMap
1290
+ myBaseTypeCachePeriod = ctx.period
1291
1291
}
1292
- myBaseTypeRefCache
1292
+ myBaseTypeCache
1293
1293
}
1294
1294
1295
1295
private def invalidateBaseDataCache () = {
@@ -1302,9 +1302,9 @@ object SymDenotations {
1302
1302
memberNamesCache = MemberNames .None
1303
1303
}
1304
1304
1305
- def invalidateBaseTypeRefCache () = {
1306
- myBaseTypeRefCache = null
1307
- myBaseTypeRefCachePeriod = Nowhere
1305
+ def invalidateBaseTypeCache () = {
1306
+ myBaseTypeCache = null
1307
+ myBaseTypeCachePeriod = Nowhere
1308
1308
}
1309
1309
1310
1310
override def copyCaches (from : SymDenotation , phase : Phase )(implicit ctx : Context ): this .type = {
@@ -1313,7 +1313,7 @@ object SymDenotations {
1313
1313
if (from.memberNamesCache.isValidAt(phase)) memberNamesCache = from.memberNamesCache
1314
1314
if (from.baseDataCache.isValidAt(phase)) {
1315
1315
baseDataCache = from.baseDataCache
1316
- myBaseTypeRefCache = from.baseTypeRefCache
1316
+ myBaseTypeCache = from.baseTypeCache
1317
1317
}
1318
1318
case _ =>
1319
1319
}
@@ -1581,11 +1581,11 @@ object SymDenotations {
1581
1581
raw.filterExcluded(excluded).asSeenFrom(pre).toDenot(pre)
1582
1582
}
1583
1583
1584
- /** Compute tp.baseTypeRef (this) */
1585
- final def baseTypeRefOf (tp : Type )(implicit ctx : Context ): Type = {
1584
+ /** Compute tp.baseType (this) */
1585
+ final def baseTypeOf (tp : Type )(implicit ctx : Context ): Type = {
1586
1586
1587
1587
def foldGlb (bt : Type , ps : List [Type ]): Type = ps match {
1588
- case p :: ps1 => foldGlb(bt & baseTypeRefOf (p), ps1)
1588
+ case p :: ps1 => foldGlb(bt & baseTypeOf (p), ps1)
1589
1589
case _ => bt
1590
1590
}
1591
1591
@@ -1597,7 +1597,7 @@ object SymDenotations {
1597
1597
* and this changes subtyping relations. As a shortcut, we do not
1598
1598
* cache ErasedValueType at all.
1599
1599
*/
1600
- def isCachable (tp : Type , btrCache : BaseTypeRefMap ): Boolean = {
1600
+ def isCachable (tp : Type , btrCache : BaseTypeMap ): Boolean = {
1601
1601
def inCache (tp : Type ) = btrCache.containsKey(tp)
1602
1602
tp match {
1603
1603
case _ : TypeErasure .ErasedValueType => false
@@ -1609,12 +1609,12 @@ object SymDenotations {
1609
1609
}
1610
1610
}
1611
1611
1612
- def computeBaseTypeRefOf (tp : Type ): Type = {
1612
+ def computeBaseTypeOf (tp : Type ): Type = {
1613
1613
Stats .record(" computeBaseTypeOf" )
1614
- if (symbol.isStatic && tp.derivesFrom(symbol))
1614
+ if (symbol.isStatic && tp.derivesFrom(symbol) && symbol.typeParams.isEmpty )
1615
1615
symbol.typeRef
1616
1616
else tp match {
1617
- case tp : TypeRef =>
1617
+ case tp : RefType =>
1618
1618
val subcls = tp.symbol
1619
1619
if (subcls eq symbol)
1620
1620
tp
@@ -1623,31 +1623,31 @@ object SymDenotations {
1623
1623
if (cdenot.baseClassSet contains symbol) foldGlb(NoType , tp.parents)
1624
1624
else NoType
1625
1625
case _ =>
1626
- baseTypeRefOf (tp.superType)
1626
+ baseTypeOf (tp.superType)
1627
1627
}
1628
1628
case tp : TypeProxy =>
1629
- baseTypeRefOf (tp.superType)
1629
+ baseTypeOf (tp.superType)
1630
1630
case AndType (tp1, tp2) =>
1631
- baseTypeRefOf (tp1) & baseTypeRefOf (tp2)
1631
+ baseTypeOf (tp1) & baseTypeOf (tp2)
1632
1632
case OrType (tp1, tp2) =>
1633
- baseTypeRefOf (tp1) | baseTypeRefOf (tp2)
1633
+ baseTypeOf (tp1) | baseTypeOf (tp2)
1634
1634
case JavaArrayType (_) if symbol == defn.ObjectClass =>
1635
1635
this .typeRef
1636
1636
case _ =>
1637
1637
NoType
1638
1638
}
1639
1639
}
1640
1640
1641
- /* >|>*/ ctx.debugTraceIndented(s " $tp.baseTypeRef ( $this) " ) /* <|<*/ {
1641
+ /* >|>*/ ctx.debugTraceIndented(s " $tp.baseType ( $this) " ) /* <|<*/ {
1642
1642
tp match {
1643
1643
case tp : CachedType =>
1644
- val btrCache = baseTypeRefCache
1644
+ val btrCache = baseTypeCache
1645
1645
try {
1646
1646
var basetp = btrCache get tp
1647
1647
if (basetp == null ) {
1648
1648
btrCache.put(tp, NoPrefix )
1649
- basetp = computeBaseTypeRefOf (tp)
1650
- if (isCachable(tp, baseTypeRefCache )) btrCache.put(tp, basetp)
1649
+ basetp = computeBaseTypeOf (tp)
1650
+ if (isCachable(tp, baseTypeCache )) btrCache.put(tp, basetp)
1651
1651
else btrCache.remove(tp)
1652
1652
} else if (basetp == NoPrefix )
1653
1653
throw CyclicReference (this )
@@ -1659,7 +1659,7 @@ object SymDenotations {
1659
1659
throw ex
1660
1660
}
1661
1661
case _ =>
1662
- computeBaseTypeRefOf (tp)
1662
+ computeBaseTypeOf (tp)
1663
1663
}
1664
1664
}
1665
1665
}
0 commit comments