diff options
Diffstat (limited to 'src')
-rw-r--r-- | src/dotty/tools/dotc/ast/tpd.scala | 2 | ||||
-rw-r--r-- | src/dotty/tools/dotc/core/Substituters.scala | 18 | ||||
-rw-r--r-- | src/dotty/tools/dotc/core/TypeApplications.scala | 34 | ||||
-rw-r--r-- | src/dotty/tools/dotc/core/TypeComparer.scala | 44 | ||||
-rw-r--r-- | src/dotty/tools/dotc/core/TypeOps.scala | 4 | ||||
-rw-r--r-- | src/dotty/tools/dotc/core/Types.scala | 119 | ||||
-rw-r--r-- | src/dotty/tools/dotc/core/Uniques.scala | 13 | ||||
-rw-r--r-- | src/dotty/tools/dotc/core/pickling/UnPickler.scala | 15 | ||||
-rw-r--r-- | src/dotty/tools/dotc/core/transform/Erasure.scala | 2 | ||||
-rw-r--r-- | src/dotty/tools/dotc/typer/Inferencing.scala | 2 |
10 files changed, 75 insertions, 178 deletions
diff --git a/src/dotty/tools/dotc/ast/tpd.scala b/src/dotty/tools/dotc/ast/tpd.scala index 911283d5a..8b9e0c12e 100644 --- a/src/dotty/tools/dotc/ast/tpd.scala +++ b/src/dotty/tools/dotc/ast/tpd.scala @@ -116,7 +116,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo { } case tp: RefinedType => val tp1 @ RefinedType(parent1, _) = mapOver(tp) - if (tp1.compactInfo existsPart toAvoid) { + if (tp1.refinedInfo existsPart toAvoid) { typr.println(s"dropping refinement from $tp1") parent1 } diff --git a/src/dotty/tools/dotc/core/Substituters.scala b/src/dotty/tools/dotc/core/Substituters.scala index 2b4b8c167..944931698 100644 --- a/src/dotty/tools/dotc/core/Substituters.scala +++ b/src/dotty/tools/dotc/core/Substituters.scala @@ -17,7 +17,7 @@ trait Substituters { this: Context => case _: ThisType | NoPrefix => tp case tp: RefinedType => - tp.derivedRefinedType(subst(tp.parent, from, to, map), tp.refinedName, subst(tp.compactInfo, from, to, map)) + tp.derivedRefinedType(subst(tp.parent, from, to, map), tp.refinedName, subst(tp.refinedInfo, from, to, map)) case _ => (if (map != null) map else new SubstBindingMap(from, to)) .mapOver(tp) @@ -33,7 +33,7 @@ trait Substituters { this: Context => case _: ThisType | _: BoundType | NoPrefix => tp case tp: RefinedType => - tp.derivedRefinedType(subst1(tp.parent, from, to, map), tp.refinedName, subst1(tp.compactInfo, from, to, map)) + tp.derivedRefinedType(subst1(tp.parent, from, to, map), tp.refinedName, subst1(tp.refinedInfo, from, to, map)) case _ => (if (map != null) map else new Subst1Map(from, to)) .mapOver(tp) @@ -51,7 +51,7 @@ trait Substituters { this: Context => case _: ThisType | _: BoundType | NoPrefix => tp case tp: RefinedType => - tp.derivedRefinedType(subst2(tp.parent, from1, to1, from2, to2, map), tp.refinedName, subst2(tp.compactInfo, from1, to1, from2, to2, map)) + tp.derivedRefinedType(subst2(tp.parent, from1, to1, from2, to2, map), tp.refinedName, subst2(tp.refinedInfo, from1, to1, from2, to2, map)) case _ => (if (map != null) map else new Subst2Map(from1, to1, from2, to2)) .mapOver(tp) @@ -74,7 +74,7 @@ trait Substituters { this: Context => case _: ThisType | _: BoundType | NoPrefix => tp case tp: RefinedType => - tp.derivedRefinedType(subst(tp.parent, from, to, map), tp.refinedName, subst(tp.compactInfo, from, to, map)) + tp.derivedRefinedType(subst(tp.parent, from, to, map), tp.refinedName, subst(tp.refinedInfo, from, to, map)) case _ => (if (map != null) map else new SubstMap(from, to)) .mapOver(tp) @@ -97,7 +97,7 @@ trait Substituters { this: Context => case _: ThisType | _: BoundType | NoPrefix => tp case tp: RefinedType => - tp.derivedRefinedType(substSym(tp.parent, from, to, map), tp.refinedName, substSym(tp.compactInfo, from, to, map)) + tp.derivedRefinedType(substSym(tp.parent, from, to, map), tp.refinedName, substSym(tp.refinedInfo, from, to, map)) case _ => (if (map != null) map else new SubstSymMap(from, to)) .mapOver(tp) @@ -113,7 +113,7 @@ trait Substituters { this: Context => case _: BoundType | NoPrefix => tp case tp: RefinedType => - tp.derivedRefinedType(substThis(tp.parent, from, to, map), tp.refinedName, substThis(tp.compactInfo, from, to, map)) + tp.derivedRefinedType(substThis(tp.parent, from, to, map), tp.refinedName, substThis(tp.refinedInfo, from, to, map)) case _ => (if (map != null) map else new SubstThisMap(from, to)) .mapOver(tp) @@ -129,7 +129,7 @@ trait Substituters { this: Context => case _: ThisType | _: BoundType | NoPrefix => tp case tp: RefinedType => - tp.derivedRefinedType(substThis(tp.parent, from, to, map), tp.refinedName, substThis(tp.compactInfo, from, to, map)) + tp.derivedRefinedType(substThis(tp.parent, from, to, map), tp.refinedName, substThis(tp.refinedInfo, from, to, map)) case _ => (if (map != null) map else new SubstRefinedThisMap(from, to)) .mapOver(tp) @@ -145,7 +145,7 @@ trait Substituters { this: Context => case _: ThisType | NoPrefix => tp case tp: RefinedType => - tp.derivedRefinedType(substParam(tp.parent, from, to, map), tp.refinedName, substParam(tp.compactInfo, from, to, map)) + tp.derivedRefinedType(substParam(tp.parent, from, to, map), tp.refinedName, substParam(tp.refinedInfo, from, to, map)) case _ => (if (map != null) map else new SubstParamMap(from, to)) .mapOver(tp) @@ -161,7 +161,7 @@ trait Substituters { this: Context => case _: ThisType | NoPrefix | _: RefinedThis => tp case tp: RefinedType => - tp.derivedRefinedType(substParams(tp.parent, from, to, map), tp.refinedName, substParams(tp.compactInfo, from, to, map)) + tp.derivedRefinedType(substParams(tp.parent, from, to, map), tp.refinedName, substParams(tp.refinedInfo, from, to, map)) case _ => (if (map != null) map else new SubstParamsMap(from, to)) .mapOver(tp) diff --git a/src/dotty/tools/dotc/core/TypeApplications.scala b/src/dotty/tools/dotc/core/TypeApplications.scala index 7ecabe6f5..9f742fcc2 100644 --- a/src/dotty/tools/dotc/core/TypeApplications.scala +++ b/src/dotty/tools/dotc/core/TypeApplications.scala @@ -92,7 +92,7 @@ class TypeApplications(val self: Type) extends AnyVal { println(s"precomplete decls = ${self.typeSymbol.decls.toList.map(_.denot).mkString("\n ")}") } val tparam = tparams.head - val tp1 = tp.paramRefinement(tparam, arg) + val tp1 = RefinedType(tp, tparam.name, arg.toBounds(tparam)) recur(tp1, tparams.tail, args1) case nil => tp } @@ -122,20 +122,17 @@ class TypeApplications(val self: Type) extends AnyVal { final def appliedTo(arg: Type)(implicit ctx: Context): Type = appliedTo(arg :: Nil) final def appliedTo(arg1: Type, arg2: Type)(implicit ctx: Context): Type = appliedTo(arg1 :: arg2 :: Nil) - /** Add a refinement to this type, which reflects `arg` being used as an argument for - * type parameter `tparam`. + /** Turn this type, which is used as an argument for + * type parameter `tparam`, into a TypeBounds RHS */ - final def paramRefinement(tparam: Symbol, arg: Type)(implicit ctx: Context): RefinedType = arg match { - case arg: TypeBounds => // this can happen for wildcard args - RefinedType(self, tparam.name, arg) + final def toBounds(tparam: Symbol)(implicit ctx: Context): TypeBounds = self match { + case self: TypeBounds => // this can happen for wildcard args + self case _ => val v = tparam.variance - if (v > 0 && !(tparam is Local) && !(tparam is ExpandedTypeParam)) - RefinedType(self, tparam.name, TypeBounds.upper(arg)) - else if (v < 0 && !(tparam is Local) && !(tparam is ExpandedTypeParam)) - RefinedType(self, tparam.name, TypeBounds.lower(arg)) - else - RefinedType.compact(self, tparam.name, arg, v) + if (v > 0 && !(tparam is Local) && !(tparam is ExpandedTypeParam)) TypeBounds.upper(self) + else if (v < 0 && !(tparam is Local) && !(tparam is ExpandedTypeParam)) TypeBounds.lower(self) + else TypeAlias(self, v) } /** The type arguments of the base type instance wrt `base` of this type */ @@ -174,7 +171,7 @@ class TypeApplications(val self: Type) extends AnyVal { if (tparams == null) tparams = tycon.typeParams if (buf.size < tparams.length) { val tparam = tparams(buf.size) - if (name == tparam.name) buf += tp.argTypeOfRefinement(tparam) + if (name == tparam.name) buf += tp.refinedInfo.argType(tparam) else null } else null } @@ -213,17 +210,6 @@ class TypeApplications(val self: Type) extends AnyVal { NoType } - /** If the refinement is the image of a type argument to type parameter `tparam`, - * recover the type argument, otherwise NoType. - */ - final def argTypeOfRefinement(tparam: Symbol)(implicit ctx: Context): Type = self match { - case self: RefinedType => - if (self.isAliasRefinement) self.compactInfo - else self.refinedInfo.argType(tparam) - case _ => - NoType - } - /** The element type of a sequence or array */ def elemType(implicit ctx: Context): Type = firstBaseTypeArg(defn.SeqClass) orElse firstBaseTypeArg(defn.ArrayClass) diff --git a/src/dotty/tools/dotc/core/TypeComparer.scala b/src/dotty/tools/dotc/core/TypeComparer.scala index 467c4993e..537f0ae57 100644 --- a/src/dotty/tools/dotc/core/TypeComparer.scala +++ b/src/dotty/tools/dotc/core/TypeComparer.scala @@ -166,7 +166,7 @@ class TypeComparer(initctx: Context) extends DotClass { override def stopAtStatic = true def apply(tp: Type) = mapOver { tp match { - case tp: RefinedType if param occursIn tp.compactInfo => tp.parent + case tp: RefinedType if param occursIn tp.refinedInfo => tp.parent case _ => tp } } @@ -408,7 +408,7 @@ class TypeComparer(initctx: Context) extends DotClass { case tp1 @ RefinedType(parent1, name1) if !(seen contains name1) => tp2 match { case tp2 @ RefinedType(parent2, name2) if nameMatches(name1, name2, tp1, tp2) => - if (refinementIsSubType(tp1, tp2)) + if (isSubType(tp1.refinedInfo, tp2.refinedInfo)) matchRefinements(parent1, parent2, seen + name1) else NoType case _ => tp2 @@ -418,7 +418,7 @@ class TypeComparer(initctx: Context) extends DotClass { def compareRefined: Boolean = tp1.widen match { case tp1 @ RefinedType(parent1, name1) if nameMatches(name1, name2, tp1, tp2) => // optimized case; all info on tp1.name2 is in refinement tp1.refinedInfo. - refinementIsSubType(tp1, tp2) && { + isSubType(tp1.refinedInfo, tp2.refinedInfo) && { val ancestor2 = matchRefinements(parent1, parent2, Set.empty + name1) ancestor2.exists && isSubType(tp1, ancestor2) } @@ -431,9 +431,15 @@ class TypeComparer(initctx: Context) extends DotClass { def hasMatchingMember(name: Name): Boolean = /*>|>*/ ctx.traceIndented(s"hasMatchingMember($name) ${tp1.member(name)}", subtyping) /*<|<*/ ( memberMatches(tp1 member name) || - // special case for situations like: - // foo <: C { type T = foo.T } - tp2.isAliasRefinement && (tp1 select name) =:= tp2.compactInfo + { // special case for situations like: + // foo <: C { type T = foo.T } + tp2.refinedInfo match { + case TypeBounds(lo, hi) if lo eq hi => + val ref = tp1 select name + isSubType(ref, lo) && isSubType(hi, ref) + case _ => false + } + } || name.isHkParamName && { val idx = name.hkParamIndex @@ -486,7 +492,7 @@ class TypeComparer(initctx: Context) extends DotClass { case tp2 @ TypeBounds(lo2, hi2) => def compareTypeBounds = tp1 match { case tp1 @ TypeBounds(lo1, hi1) => - val v = tp1.variance + tp2.variance // !!! todo: revisit + val v = tp1.variance + tp2.variance ((v > 0) || (lo2 isRef NothingClass) || isSubType(lo2, lo1)) && ((v < 0) || (hi2 isRef AnyClass) || isSubType(hi1, hi2)) case tp1: ClassInfo => @@ -527,19 +533,6 @@ class TypeComparer(initctx: Context) extends DotClass { false } - def refinementIsSubType(rt1: RefinedType, rt2: RefinedType): Boolean = { - if (rt1 eq rt2) return true - if (rt1.isAliasRefinement) - if (rt2.isAliasRefinement) { - if (rt2.boundsVariance > 0 && rt1.boundsVariance >= 0) - return isSubType(rt1.compactInfo, rt2.compactInfo) - else if (rt2.boundsVariance < 0 && rt1.boundsVariance <= 0) - return isSubType(rt2.compactInfo, rt1.compactInfo) - } - // todo: handle case where rt2.compactInfo is a type bounds - isSubType(rt1.refinedInfo, rt2.refinedInfo) - } - /** Like tp1 <:< tp2, but returns false immediately if we know that * the case was covered previouslky during subtyping. */ @@ -927,14 +920,9 @@ class TypeComparer(initctx: Context) extends DotClass { // gives =:= types), but it keeps the type smaller. tp2 match { case tp2: RefinedType if tp1.refinedName == tp2.refinedName => - val commonParent = tp1.parent & tp2.parent - val commonName = tp1.refinedName - if (refinementIsSubType(tp1, tp2)) - tp1.derivedRefinedType(commonParent, commonName, tp1.compactInfo) - else if (refinementIsSubType(tp2, tp1)) - tp1.derivedRefinedType(commonParent, commonName, tp2.compactInfo) - else - RefinedType(commonParent, commonName, tp1.refinedInfo & tp2.refinedInfo) + tp1.derivedRefinedType( + tp1.parent & tp2.parent, tp1.refinedName, + tp1.refinedInfo & tp2.refinedInfo) case _ => NoType } diff --git a/src/dotty/tools/dotc/core/TypeOps.scala b/src/dotty/tools/dotc/core/TypeOps.scala index 96071107f..afa39f2a3 100644 --- a/src/dotty/tools/dotc/core/TypeOps.scala +++ b/src/dotty/tools/dotc/core/TypeOps.scala @@ -35,7 +35,7 @@ trait TypeOps { this: Context => tp.derivedRefinedType( asSeenFrom(tp.parent, pre, cls, theMap), tp.refinedName, - asSeenFrom(tp.compactInfo, pre, cls, theMap)) + asSeenFrom(tp.refinedInfo, pre, cls, theMap)) case _ => (if (theMap != null) theMap else new AsSeenFromMap(pre, cls)) .mapOver(tp) @@ -57,7 +57,7 @@ trait TypeOps { this: Context => case _: ThisType | _: BoundType | NoPrefix => tp case tp: RefinedType => - tp.derivedRefinedType(simplify(tp.parent, theMap), tp.refinedName, simplify(tp.compactInfo, theMap)) + tp.derivedRefinedType(simplify(tp.parent, theMap), tp.refinedName, simplify(tp.refinedInfo, theMap)) case AndType(l, r) => simplify(l, theMap) & simplify(r, theMap) case OrType(l, r) => diff --git a/src/dotty/tools/dotc/core/Types.scala b/src/dotty/tools/dotc/core/Types.scala index 68e79cbb8..aab70a61b 100644 --- a/src/dotty/tools/dotc/core/Types.scala +++ b/src/dotty/tools/dotc/core/Types.scala @@ -620,8 +620,10 @@ object Types { def lookupRefined(pre: Type, name: Name)(implicit ctx: Context): Type = pre.stripTypeVar match { case pre: RefinedType => if (pre.refinedName ne name) lookupRefined(pre.parent, name) - else if (pre.isAliasRefinement) pre.compactInfo - else NoType + else pre.refinedInfo match { + case TypeBounds(lo, hi) if lo eq hi => hi + case _ => NoType + } case pre: WildcardType => WildcardType case _ => @@ -1280,40 +1282,14 @@ object Types { abstract case class RefinedType(parent: Type, refinedName: Name) extends CachedProxyType with BindingType with ValueType { - /** The compact info: avoid having a TypeBounds for aliases. - * The full TypeBounds form is reconstituted in refinedInfo - */ - val compactInfo: Type - - /** If this is an encoded alias type, its variance */ - def boundsVariance: Int - - /** Is the refinement an alias type? */ - def isAliasRefinement = refinedName.isTypeName && !compactInfo.isInstanceOf[TypeType] - - /** The refinement in standardized form (for a type alias or abstract type, - * this is always a TypeBounds - */ - def refinedInfo(implicit ctx: Context): Type = - if (isAliasRefinement) TypeAlias(compactInfo, boundsVariance) - else compactInfo - - if (monitored) - compactInfo match { - case TypeBounds(lo, hi) => assert(lo ne hi) - record("surviving type bounds") - assert(lo ne hi) - case _ => - if (isAliasRefinement) record("alias refinements") - else record("plain refinements") - } + val refinedInfo: Type override def underlying(implicit ctx: Context) = parent /** Derived refined type, with a twist: A refinement with a higher-kinded type param placeholder * is transformed to a refinement of the original type parameter if that one exists. */ - def derivedRefinedType(parent: Type, refinedName: Name, compactInfo: Type)(implicit ctx: Context): RefinedType = { + def derivedRefinedType(parent: Type, refinedName: Name, refinedInfo: Type)(implicit ctx: Context): RefinedType = { lazy val underlyingTypeParams = parent.safeUnderlyingTypeParams lazy val originalTypeParam = underlyingTypeParams(refinedName.hkParamIndex) @@ -1325,95 +1301,50 @@ object Types { else TypeBounds(hkBounds.lo, hkBounds.hi) } - if ((parent eq this.parent) && (refinedName eq this.refinedName) && (compactInfo eq this.compactInfo)) + if ((parent eq this.parent) && (refinedName eq this.refinedName) && (refinedInfo eq this.refinedInfo)) this else if ( refinedName.isHkParamName // && { println(s"deriving $refinedName $parent $underlyingTypeParams"); true } && refinedName.hkParamIndex < underlyingTypeParams.length && originalTypeParam.name != refinedName) - RefinedType(parent, originalTypeParam.name, adjustedHKRefinedInfo(refinedInfo.bounds)) + derivedRefinedType(parent, originalTypeParam.name, adjustedHKRefinedInfo(refinedInfo.bounds)) else - RefinedType.compact(parent, refinedName, compactInfo, boundsVariance, this) + RefinedType(parent, refinedName, rt => refinedInfo.substThis(this, RefinedThis(rt))) } override def equals(that: Any) = that match { case that: RefinedType => this.parent == that.parent && this.refinedName == that.refinedName && - this.compactInfo == that.compactInfo && - this.boundsVariance == that.boundsVariance + this.refinedInfo == that.refinedInfo case _ => false } - override def computeHash = addDelta(doHash(refinedName, compactInfo, parent), boundsVariance) - override def toString = s"RefinedType($parent, $refinedName, $compactInfo)" - } - - /** Main implementation class of refined type */ - class DerivedRefinedType(parent: Type, refinedName: Name, cinfo: Type, derivedFrom: Type)(implicit ctx: Context) extends RefinedType(parent, refinedName) { - val compactInfo = derivedFrom match { - case rt: RefinedType => cinfo.substThis(rt, RefinedThis(this)) - case _ => cinfo - } - def boundsVariance = 0 + override def computeHash = doHash(refinedName, refinedInfo, parent) + override def toString = s"RefinedType($parent, $refinedName, $refinedInfo)" } - /** Implementation class for covariant alias refinements */ - class CoRefinedType(parent: Type, refinedName: Name, cinfo: Type, derivedFrom: Type)(implicit ctx: Context) - extends DerivedRefinedType(parent, refinedName, cinfo, derivedFrom) { - override def boundsVariance = +1 + class CachedRefinedType(parent: Type, refinedName: Name, infoFn: RefinedType => Type) extends RefinedType(parent, refinedName) { + val refinedInfo = infoFn(this) } - /** Implementation class for contravariant alias refinements */ - class ContraRefinedType(parent: Type, refinedName: Name, cinfo: Type, derivedFrom: Type)(implicit ctx: Context) - extends DerivedRefinedType(parent, refinedName, cinfo, derivedFrom) { - override def boundsVariance = -1 - } - - /** A dummy refined type used for bootstrapping when the refined info is given as a function - * from the refined type itself. - */ - class DummyRefinedType(parent: Type, name: Name) - extends RefinedType(parent, name) { - override def computeHash = NotCached - val compactInfo = NoType - val boundsVariance = 0 - } - -/* class PreHashedRefinedType(parent: Type, refinedName: Name, override val refinedInfo: Type, hc: Int) extends RefinedType(parent, refinedName) { myHash = hc override def computeHash = unsupported("computeHash") } -*/ + object RefinedType { def make(parent: Type, names: List[Name], infoFns: List[RefinedType => Type])(implicit ctx: Context): Type = if (names.isEmpty) parent else make(RefinedType(parent, names.head, infoFns.head), names.tail, infoFns.tail) - def apply(parent: Type, name: Name, infoFn: RefinedType => Type)(implicit ctx: Context): RefinedType = { - val dummy = new DummyRefinedType(parent, name) - apply(parent, name, infoFn(dummy), dummy) - } + def apply(parent: Type, name: Name, infoFn: RefinedType => Type)(implicit ctx: Context): RefinedType = + ctx.base.uniqueRefinedTypes.enterIfNew(new CachedRefinedType(parent, name, infoFn)) - def apply(parent: Type, name: Name, info: Type, derivedFrom: Type = NoType)(implicit ctx: Context): RefinedType = { - info match { - case bounds @ TypeBounds(lo, hi) if lo eq hi => - assert(name.isTypeName) - compact(parent, name, hi, bounds.variance, derivedFrom) - case _ => - compact(parent, name, info, 0, derivedFrom) - } + def apply(parent: Type, name: Name, info: Type)(implicit ctx: Context): RefinedType = { + ctx.base.uniqueRefinedTypes.enterIfNew(parent, name, info) } - - def compact(parent: Type, name: Name, compactInfo: Type, boundsVariance: Int, derivedFrom: Type = NoType)(implicit ctx: Context): RefinedType = - ctx.base.uniqueRefinedTypes.enterIfNew { - if (boundsVariance == 0) new DerivedRefinedType(parent, name, compactInfo, derivedFrom) - else if (boundsVariance > 0) new CoRefinedType(parent, name, compactInfo, derivedFrom) - else new ContraRefinedType(parent, name, compactInfo, derivedFrom) - } - // ctx.base.uniqueRefinedTypes.enterIfNew(parent, name, info) } // --- AndType/OrType --------------------------------------------------------------- @@ -1875,7 +1806,7 @@ object Types { private def computeSelfType(base: Type, tparams: List[TypeSymbol])(implicit ctx: Context): Type = tparams match { case tparam :: tparams1 => computeSelfType( - base.paramRefinement(tparam, TypeRef(cls.thisType, tparam)), + RefinedType(base, tparam.name, TypeRef(cls.thisType, tparam).toBounds(tparam)), tparams1) case nil => base @@ -2015,7 +1946,6 @@ object Types { override def variance = 1 override def toString = "Co" + super.toString } - final class ContraTypeBounds(lo: Type, hi: Type, hc: Int) extends CachedTypeBounds(lo, hi, hc) { override def variance = -1 override def toString = "Contra" + super.toString @@ -2169,7 +2099,7 @@ object Types { | NoPrefix => tp case tp: RefinedType => - tp.derivedRefinedType(this(tp.parent), tp.refinedName, this(tp.compactInfo)) + tp.derivedRefinedType(this(tp.parent), tp.refinedName, this(tp.refinedInfo)) case tp @ MethodType(pnames, ptypes) => variance = -variance @@ -2293,12 +2223,7 @@ object Types { | NoPrefix => x case tp: RefinedType => - val y = this(x, tp.parent) - val saved = variance - if (tp.isAliasRefinement) variance = variance * tp.boundsVariance - val result = this(y, tp.compactInfo) - variance = saved - result + this(this(x, tp.parent), tp.refinedInfo) case tp @ MethodType(pnames, ptypes) => variance = -variance diff --git a/src/dotty/tools/dotc/core/Uniques.scala b/src/dotty/tools/dotc/core/Uniques.scala index f05b7821d..9ad736c9c 100644 --- a/src/dotty/tools/dotc/core/Uniques.scala +++ b/src/dotty/tools/dotc/core/Uniques.scala @@ -92,21 +92,20 @@ object Uniques { } } - /** Todo: clean up once the initialization scheme for refined types is decided */ final class RefinedUniques extends HashSet[RefinedType]("uniqueRefinedTypes", initialUniquesCapacity) with Hashable { -// override val hashSeed = classOf[DerivedRefinedType].hashCode // some types start life as DerivedRefinedTypes, need to have same hash seed + override val hashSeed = classOf[CachedRefinedType].hashCode // some types start life as CachedRefinedTypes, need to have same hash seed override def hash(x: RefinedType): Int = x.hash - private def findPrevious(h: Int, parent: Type, refinedName: Name, compactInfo: Type): RefinedType = { + private def findPrevious(h: Int, parent: Type, refinedName: Name, refinedInfo: Type): RefinedType = { var e = findEntryByHash(h) while (e != null) { - if ((e.parent == parent) && (e.refinedName eq refinedName) && (e.compactInfo == compactInfo)) + if ((e.parent == parent) && (e.refinedName eq refinedName) && (e.refinedInfo == refinedInfo)) return e e = nextEntryByHash(h) } e } -/* + def enterIfNew(parent: Type, refinedName: Name, refinedInfo: Type): RefinedType = { val h = doHash(refinedName, refinedInfo, parent) def newType = new PreHashedRefinedType(parent, refinedName, refinedInfo, h) @@ -117,12 +116,12 @@ object Uniques { if (r ne null) r else addEntryAfterScan(newType) } } -*/ + def enterIfNew(rt: RefinedType) = { if (monitored) recordCaching(rt) if (rt.hash == NotCached) rt else { - val r = findPrevious(rt.hash, rt.parent, rt.refinedName, rt.compactInfo) + val r = findPrevious(rt.hash, rt.parent, rt.refinedName, rt.refinedInfo) if (r ne null) r else addEntryAfterScan(rt) } } diff --git a/src/dotty/tools/dotc/core/pickling/UnPickler.scala b/src/dotty/tools/dotc/core/pickling/UnPickler.scala index e5cbdf53b..78a91b2ef 100644 --- a/src/dotty/tools/dotc/core/pickling/UnPickler.scala +++ b/src/dotty/tools/dotc/core/pickling/UnPickler.scala @@ -560,16 +560,15 @@ class UnPickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClassRoot: def elim(tp: Type): Type = tp match { case tp @ RefinedType(parent, name) => val parent1 = elim(tp.parent) - tp.compactInfo match { + tp.refinedInfo match { + case TypeAlias(info: TypeRef) if boundSyms contains info.symbol => + RefinedType(parent1, name, info.symbol.info) case info: TypeRef if boundSyms contains info.symbol => val info1 = info.symbol.info - if (tp.isAliasRefinement) RefinedType(parent1, name, info1) - else { - assert(info1.derivesFrom(defn.SingletonClass)) - RefinedType(parent1, name, info1.mapReduceAnd(removeSingleton)(_ & _)) - } - case cinfo => - tp.derivedRefinedType(parent1, name, cinfo) + assert(info1.derivesFrom(defn.SingletonClass)) + RefinedType(parent1, name, info1.mapReduceAnd(removeSingleton)(_ & _)) + case info => + tp.derivedRefinedType(parent1, name, info) } case _ => tp diff --git a/src/dotty/tools/dotc/core/transform/Erasure.scala b/src/dotty/tools/dotc/core/transform/Erasure.scala index 80f2b3941..34f339d9a 100644 --- a/src/dotty/tools/dotc/core/transform/Erasure.scala +++ b/src/dotty/tools/dotc/core/transform/Erasure.scala @@ -115,7 +115,7 @@ object Erasure { if (parent isRef defn.ArrayClass) eraseArray(tp) match { case tp1: RefinedType if tp1.parent isRef defn.ArrayClass => - sigName(tp1.compactInfo) ++ "[]" + sigName(tp1.refinedInfo) ++ "[]" case tp1 => sigName(tp1) } diff --git a/src/dotty/tools/dotc/typer/Inferencing.scala b/src/dotty/tools/dotc/typer/Inferencing.scala index 2ca0313d1..c9319de1f 100644 --- a/src/dotty/tools/dotc/typer/Inferencing.scala +++ b/src/dotty/tools/dotc/typer/Inferencing.scala @@ -555,7 +555,7 @@ object Inferencing { case _: ThisType | _: BoundType | NoPrefix => // default case, inlined for speed tp case tp: RefinedType => // default case, inlined for speed - tp.derivedRefinedType(wildApprox(tp.parent, theMap), tp.refinedName, wildApprox(tp.compactInfo, theMap)) + tp.derivedRefinedType(wildApprox(tp.parent, theMap), tp.refinedName, wildApprox(tp.refinedInfo, theMap)) case _ => (if (theMap != null) theMap else new WildApproxMap).mapOver(tp) } |