diff options
author | Paul Phillips <paulp@improving.org> | 2013-06-03 22:12:10 -0700 |
---|---|---|
committer | Paul Phillips <paulp@improving.org> | 2013-06-03 22:12:10 -0700 |
commit | fb06073844f388ec4c007b4c08e7d508fc88d5ab (patch) | |
tree | 12062d7a8fce298bc5bbdb7b83fe8c930d18282b /src/reflect | |
parent | a04977736c007fc7976c10c7fa5c74ae67902b92 (diff) | |
parent | 278305a7f60c46515c2133d11f7c561e972ef705 (diff) | |
download | scala-fb06073844f388ec4c007b4c08e7d508fc88d5ab.tar.gz scala-fb06073844f388ec4c007b4c08e7d508fc88d5ab.tar.bz2 scala-fb06073844f388ec4c007b4c08e7d508fc88d5ab.zip |
Merge pull request #2624 from paulp/pr/revert-14534c693d
Revert "SI-7517 type constructors too eagerly normalized."
Diffstat (limited to 'src/reflect')
-rw-r--r-- | src/reflect/scala/reflect/internal/Types.scala | 4 | ||||
-rw-r--r-- | src/reflect/scala/reflect/internal/tpe/GlbLubs.scala | 16 | ||||
-rw-r--r-- | src/reflect/scala/reflect/internal/tpe/TypeMaps.scala | 15 |
3 files changed, 25 insertions, 10 deletions
diff --git a/src/reflect/scala/reflect/internal/Types.scala b/src/reflect/scala/reflect/internal/Types.scala index dfb8632968..00a929003e 100644 --- a/src/reflect/scala/reflect/internal/Types.scala +++ b/src/reflect/scala/reflect/internal/Types.scala @@ -3222,7 +3222,7 @@ trait Types if (constr.instValid) constr.inst // get here when checking higher-order subtyping of the typevar by itself // TODO: check whether this ever happens? - else if (isHigherKinded) logResult(s"Normalizing HK $this")(typeFun(params, applyArgs(params map (_.typeConstructor)))) + else if (isHigherKinded) logResult("Normalizing HK $this")(typeFun(params, applyArgs(params map (_.typeConstructor)))) else super.normalize ) override def typeSymbol = origin.typeSymbol @@ -3649,7 +3649,7 @@ trait Types def existentialAbstraction(tparams: List[Symbol], tpe0: Type): Type = if (tparams.isEmpty) tpe0 else { - val tpe = tpe0 map (_.dealias) + val tpe = normalizeAliases(tpe0) val tpe1 = new ExistentialExtrapolation(tparams) extrapolate tpe var tparams0 = tparams var tparams1 = tparams0 filter tpe1.contains diff --git a/src/reflect/scala/reflect/internal/tpe/GlbLubs.scala b/src/reflect/scala/reflect/internal/tpe/GlbLubs.scala index 7a10401a45..0a7a2a127c 100644 --- a/src/reflect/scala/reflect/internal/tpe/GlbLubs.scala +++ b/src/reflect/scala/reflect/internal/tpe/GlbLubs.scala @@ -80,11 +80,11 @@ private[internal] trait GlbLubs { var lubListDepth = 0 // This catches some recursive situations which would otherwise // befuddle us, e.g. pos/hklub0.scala - def isHotForTs(xs: List[Type]) = ts exists (_.typeParams == xs.map(_.typeSymbolDirect)) + def isHotForTs(xs: List[Type]) = ts exists (_.typeParams == xs.map(_.typeSymbol)) def elimHigherOrderTypeParam(tp: Type) = tp match { case TypeRef(_, _, args) if args.nonEmpty && isHotForTs(args) => - logResult(s"Retracting dummies from $tp in lublist")(tp.typeConstructor) + logResult("Retracting dummies from " + tp + " in lublist")(tp.typeConstructor) case _ => tp } // pretypes is a tail-recursion-preserving accumulator. @@ -101,7 +101,7 @@ private[internal] trait GlbLubs { // Is the frontier made up of types with the same symbol? val isUniformFrontier = (ts0: @unchecked) match { - case t :: ts => ts forall (_.typeSymbolDirect == t.typeSymbolDirect) + case t :: ts => ts forall (_.typeSymbol == t.typeSymbol) } // Produce a single type for this frontier by merging the prefixes and arguments of those @@ -112,11 +112,11 @@ private[internal] trait GlbLubs { if (isUniformFrontier) { val fbounds = findRecursiveBounds(ts0) map (_._2) val tcLubList = typeConstructorLubList(ts0) - def isRecursive(tp: Type) = tp.typeSymbolDirect.typeParams exists fbounds.contains + def isRecursive(tp: Type) = tp.typeSymbol.typeParams exists fbounds.contains val ts1 = ts0 map { t => if (isRecursive(t)) { - tcLubList map (t baseType _.typeSymbolDirect) find (t => !isRecursive(t)) match { + tcLubList map (t baseType _.typeSymbol) find (t => !isRecursive(t)) match { case Some(tp) => logResult(s"Breaking recursion in lublist, substituting weaker type.\n Was: $t\n Now")(tp) case _ => t } @@ -133,7 +133,7 @@ private[internal] trait GlbLubs { // frontier is not uniform yet, move it beyond the current minimal symbol; // lather, rinSe, repeat val sym = minSym(ts0) - val newtps = tsBts map (ts => if (ts.head.typeSymbolDirect == sym) ts.tail else ts) + val newtps = tsBts map (ts => if (ts.head.typeSymbol == sym) ts.tail else ts) if (printLubs) { val str = (newtps.zipWithIndex map { case (tps, idx) => tps.map(" " + _ + "\n").mkString(" (" + idx + ")\n", "", "\n") @@ -157,7 +157,9 @@ private[internal] trait GlbLubs { /** The minimal symbol of a list of types (as determined by `Symbol.isLess`). */ private def minSym(tps: List[Type]): Symbol = - tps.iterator map (_.typeSymbolDirect) reduceLeft ((x, y) => if (x isLess y) x else y) + (tps.head.typeSymbol /: tps.tail) { + (sym1, tp2) => if (tp2.typeSymbol isLess sym1) tp2.typeSymbol else sym1 + } /** A minimal type list which has a given list of types as its base type sequence */ def spanningTypes(ts: List[Type]): List[Type] = ts match { diff --git a/src/reflect/scala/reflect/internal/tpe/TypeMaps.scala b/src/reflect/scala/reflect/internal/tpe/TypeMaps.scala index 76d02f5f9d..c35825dcee 100644 --- a/src/reflect/scala/reflect/internal/tpe/TypeMaps.scala +++ b/src/reflect/scala/reflect/internal/tpe/TypeMaps.scala @@ -12,6 +12,19 @@ private[internal] trait TypeMaps { self: SymbolTable => import definitions._ + /** Normalize any type aliases within this type (@see Type#normalize). + * Note that this depends very much on the call to "normalize", not "dealias", + * so it is no longer carries the too-stealthy name "deAlias". + */ + object normalizeAliases extends TypeMap { + def apply(tp: Type): Type = tp match { + case TypeRef(_, sym, _) if sym.isAliasType => + def msg = if (tp.isHigherKinded) s"Normalizing type alias function $tp" else s"Dealiasing type alias $tp" + mapOver(logResult(msg)(tp.normalize)) + case _ => mapOver(tp) + } + } + /** Remove any occurrence of type <singleton> from this type and its parents */ object dropSingletonType extends TypeMap { def apply(tp: Type): Type = { @@ -376,7 +389,7 @@ private[internal] trait TypeMaps { case TypeRef(pre, sym, args) if tparams contains sym => val repl = if (variance.isPositive) dropSingletonType(tp1.bounds.hi) else tp1.bounds.lo val count = occurCount(sym) - val containsTypeParam = tparams exists repl.contains + val containsTypeParam = tparams exists (repl contains _) def msg = { val word = if (variance.isPositive) "upper" else "lower" s"Widened lone occurrence of $tp1 inside existential to $word bound" |