1 files changed, 38 insertions, 34 deletions

diff --git a/src/reflect/scala/reflect/internal/BaseTypeSeqs.scala b/src/reflect/scala/reflect/internal/BaseTypeSeqs.scala
index 54f64153c1..1cdefff2e9 100644
--- a/src/reflect/scala/reflect/internal/BaseTypeSeqs.scala
+++ b/src/reflect/scala/reflect/internal/BaseTypeSeqs.scala
@@ -7,8 +7,7 @@ package reflect
 package internal
 
 // todo implement in terms of BitSet
-import scala.collection.{ mutable, immutable }
-import scala.math.max
+import scala.collection.mutable
 import util.Statistics
 
 /** A base type sequence (BaseTypeSeq) is an ordered sequence spanning all the base types
@@ -34,6 +33,9 @@ trait BaseTypeSeqs {
   protected def newBaseTypeSeq(parents: List[Type], elems: Array[Type]) =
     new BaseTypeSeq(parents, elems)
 
+  protected def newMappedBaseTypeSeq(orig: BaseTypeSeq, f: Type => Type) =
+    new MappedBaseTypeSeq(orig, f)
+
   /** Note: constructor is protected to force everyone to use the factory method newBaseTypeSeq instead.
    *  This is necessary because when run from reflection every base type sequence needs to have a
    *  SynchronizedBaseTypeSeq as mixin.
@@ -57,49 +59,51 @@ trait BaseTypeSeqs {
       if(pending contains i) {
         pending.clear()
         throw CyclicInheritance
-      } else
-        elems(i) match {
-          case rtp @ RefinedType(variants, decls) =>
-            // can't assert decls.isEmpty; see t0764
-            //if (!decls.isEmpty) abort("computing closure of "+this+":"+this.isInstanceOf[RefinedType]+"/"+closureCache(j))
-            //Console.println("compute closure of "+this+" => glb("+variants+")")
-            pending += i
-            try {
-              mergePrefixAndArgs(variants, Variance.Contravariant, lubDepth(variants)) match {
-                case NoType => typeError("no common type instance of base types "+(variants mkString ", and ")+" exists.")
-                case tp0    =>
-                  pending(i) = false
-                  elems(i) = tp0
-                  tp0
-              }
-            }
-            catch {
-              case CyclicInheritance =>
-                typeError(
-                  "computing the common type instance of base types "+(variants mkString ", and ")+" leads to a cycle.")
+      } else {
+        def computeLazyType(rtp: RefinedType): Type = {
+          if (!isIntersectionTypeForLazyBaseType(rtp))
+            devWarning("unexpected RefinedType in base type seq, lazy BTS elements should be created via intersectionTypeForLazyBaseType: " + rtp)
+          val variants = rtp.parents
+          // can't assert decls.isEmpty; see t0764
+          //if (!decls.isEmpty) abort("computing closure of "+this+":"+this.isInstanceOf[RefinedType]+"/"+closureCache(j))
+          //Console.println("compute closure of "+this+" => glb("+variants+")")
+          pending += i
+          try {
+            mergePrefixAndArgs(variants, Variance.Contravariant, lubDepth(variants)) match {
+              case NoType => typeError("no common type instance of base types " + (variants mkString ", and ") + " exists.")
+              case tp0 =>
+                pending(i) = false
+                elems(i) = tp0
+                tp0
             }
+          }
+          catch {
+            case CyclicInheritance =>
+              typeError(
+                "computing the common type instance of base types " + (variants mkString ", and ") + " leads to a cycle.")
+          }
+        }
+        elems(i) match {
+          case rtp@RefinedType(variants, decls) =>
+            computeLazyType(rtp)
+          case et @ ExistentialType(quantified, rtp: RefinedType) =>
+            existentialAbstraction(quantified, computeLazyType(rtp))
           case tp =>
             tp
         }
+      }
 
     def rawElem(i: Int) = elems(i)
 
-    /** The type symbol of the type at i'th position in this sequence;
-     *  no evaluation needed.
-     */
-    def typeSymbol(i: Int): Symbol = {
-      elems(i) match {
-        case RefinedType(v :: vs, _) => v.typeSymbol
-        case tp => tp.typeSymbol
-      }
-    }
+    /** The type symbol of the type at i'th position in this sequence */
+    def typeSymbol(i: Int): Symbol = elems(i).typeSymbol
 
     /** Return all evaluated types in this sequence as a list */
     def toList: List[Type] = elems.toList
 
     def copy(head: Type, offset: Int): BaseTypeSeq = {
       val arr = new Array[Type](elems.length + offset)
-      scala.compat.Platform.arraycopy(elems, 0, arr, offset, elems.length)
+      java.lang.System.arraycopy(elems, 0, arr, offset, elems.length)
       arr(0) = head
       newBaseTypeSeq(parents, arr)
     }
@@ -124,7 +128,7 @@ trait BaseTypeSeqs {
       newBaseTypeSeq(parents, arr)
     }
 
-    def lateMap(f: Type => Type): BaseTypeSeq = new MappedBaseTypeSeq(this, f)
+    def lateMap(f: Type => Type): BaseTypeSeq = newMappedBaseTypeSeq(this, f)
 
     def exists(p: Type => Boolean): Boolean = elems exists p
 
@@ -216,7 +220,7 @@ trait BaseTypeSeqs {
           }
           i += 1
         }
-        buf += intersectionType(minTypes)
+        buf += intersectionTypeForLazyBaseType(minTypes) // TODO this reverses the order. Does this matter? Or should this be minTypes.reverse?
         btsSize += 1
       }
     }