fixed t0392; un-deprecated Iterator.fromArray (...

fixed t0392; un-deprecated Iterator.fromArray (I don't see a good
alternative?)

6 files changed, 43 insertions, 21 deletions

diff --git a/src/compiler/scala/tools/nsc/symtab/Types.scala b/src/compiler/scala/tools/nsc/symtab/Types.scala
index 8e754b95cd..0e37ef6dc5 100644
--- a/src/compiler/scala/tools/nsc/symtab/Types.scala
+++ b/src/compiler/scala/tools/nsc/symtab/Types.scala
@@ -421,8 +421,10 @@ trait Types {
           }
 */
         case tp =>
-          //Console.println("" + this + ".memberType(" + sym +":" + sym.tpe +")" + sym.ownerChain);//debug
-          tp.asSeenFrom(this, sym.owner)
+//          if (sym.name.toString == "c") print(this + ".memberType(" + sym +":" + sym.tpe +")" + sym.ownerChain);//debug
+          val res = tp.asSeenFrom(this, sym.owner)
+//          if (sym.name.toString == "c") println(" = "+res)
+          res
       }
     }
 
@@ -651,7 +653,7 @@ trait Types {
                    (bcs eq bcs0) ||
                    sym.getFlag(PRIVATE | LOCAL) != (PRIVATE | LOCAL) ||
                    (bcs0.head.hasTransOwner(bcs.head)))) {
-                if (name.isTypeName || stableOnly) {
+                if (name.isTypeName || stableOnly && sym.isStable) {
                   checkMalformedSwitch = savedCheckMalformedSwitch
                   if (util.Statistics.enabled)
                     findMemberMillis = findMemberMillis + currentTime - startTime
@@ -1701,7 +1703,7 @@ A type's typeSymbol should never be inspected directly.
       val tvars = quantified map (tparam => new TypeVar(tparam.tpe, new TypeConstraint))
       val underlying1 = underlying.instantiateTypeParams(quantified, tvars)
       op(underlying1) && {
-        solve(tvars, quantified, quantified map (x => 0), false)
+        solve(tvars, quantified, quantified map (x => 0), false) &&
         isWithinBounds(NoPrefix, NoSymbol, quantified, tvars map (_.constr.inst))
       }
     }
@@ -3066,7 +3068,7 @@ A type's typeSymbol should never be inspected directly.
         }
         val rebind = rebind0.suchThat(sym => sym.isType || sym.isStable)
         if (rebind == NoSymbol) {
-          if (settings.debug.value) Console.println("" + phase + " " + phase.flatClasses+sym.owner+sym.name)
+          if (settings.debug.value) Console.println("" + phase + " " +phase.flatClasses+sym.owner+sym.name+" "+sym.isType)
           throw new MalformedType(pre, sym.nameString)
         }
         rebind
@@ -3585,6 +3587,10 @@ A type's typeSymbol should never be inspected directly.
           skolemizationLevel -= 1
         }
       case (_, et: ExistentialType) =>
+//        println("<<< "+tp1+" with "+tp2)
+//        settings.explaintypes.value = true
+//        et.withTypeVars { x => explainTypes(tp1, x); true }
+//        settings.explaintypes.value = false
         et.withTypeVars(tp1 <:< _)
       case (RefinedType(parents1, ref1), _) =>
         parents1 exists (_ <:< tp2)
@@ -3722,7 +3728,7 @@ A type's typeSymbol should never be inspected directly.
    *  @throws NoInstance
    */
   def solve(tvars: List[TypeVar], tparams: List[Symbol],
-            variances: List[Int], upper: Boolean) {
+            variances: List[Int], upper: Boolean): Boolean = {
     val config = tvars zip (tparams zip variances)
 
     def solveOne(tvar: TypeVar, tparam: Symbol, variance: Int) {
@@ -3769,6 +3775,14 @@ A type's typeSymbol should never be inspected directly.
     }
     for ((tvar, (tparam, variance)) <- config)
       solveOne(tvar, tparam, variance)
+
+    var ok = true
+    for (tvar <- tvars)
+      if (!(tvar.constr.lobounds forall (_ <:< tvar.constr.inst)) ||
+          !(tvar.constr.hibounds forall (tvar.constr.inst <:< _))) {
+        ok = false
+      }
+    ok
   }
 
   /** Do type arguments `targs' conform to formal parameters
diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
index ea2a4c59c8..5e16274eed 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Infer.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
@@ -137,7 +137,16 @@ trait Infer {
    */
   private def solvedTypes(tvars: List[TypeVar], tparams: List[Symbol],
                           variances: List[Int], upper: Boolean): List[Type] = {
-    solve(tvars, tparams, variances, upper)
+    def boundsString(tvar: TypeVar) =
+      "\n  "+
+      ((tvar.constr.lobounds map (_ + " <: " + tvar.origin.typeSymbol.name)) :::
+       (tvar.constr.hibounds map (tvar.origin.typeSymbol.name + " <: " + _)) mkString ", ")
+    if (!solve(tvars, tparams, variances, upper)) {
+//    no panic, it's good enough to just guess a solution, we'll find out
+//    later whether it works.
+//      throw new DeferredNoInstance(() =>
+//        "no solution exists for constraints"+(tvars map boundsString))
+    }
     for (val tvar <- tvars) assert(tvar.constr.inst != tvar, tvar.origin)
     tvars map instantiate
   }
@@ -952,7 +961,7 @@ trait Infer {
         } catch {
           case ex: NoInstance =>
             errorTree(tree, "constructor of type " + restpe +
-                      " can be instantiated in more than one way to expected type " + pt +
+                      " cannot be uniquely instantiated to expected type " + pt +
                       "\n --- because ---\n" + ex.getMessage())
         }
       def instError = {
diff --git a/src/library/scala/Iterator.scala b/src/library/scala/Iterator.scala
index 15247578ec..3701623f4b 100644
--- a/src/library/scala/Iterator.scala
+++ b/src/library/scala/Iterator.scala
@@ -45,20 +45,18 @@ object Iterator {
 
   /**
    *  @param xs the array of elements
-   *  @return   the iterator on <code>xs</code>.
-   *  @deprecated replaced by <code>RandomAccessSeq.elements</code> and </code>slice</code>.
+   *  @see also: RandomAccessSeq.elements and slice
    */
-  @deprecated def fromArray[a](xs: Array[a]): Iterator[a] =
+  def fromArray[a](xs: Array[a]): Iterator[a] =
     fromArray(xs, 0, xs.length)
 
   /**
    *  @param xs     the array of elements
-   *  @param start  ...
-   *  @param length ...
-   *  @return       ...
-   *  @deprecated replaced by RandomAccessSeq.elements and slice
+   *  @param start  the start index
+   *  @param length  the end index
+   *  @see also: RandomAccessSeq.elements and slice
    */
-  @deprecated def fromArray[a](xs: Array[a], start: Int, length: Int): Iterator[a] =
+  def fromArray[a](xs: Array[a], start: Int, length: Int): Iterator[a] =
     new BufferedIterator.Advanced[a] {
       private var i = start
       val end = if ((start + length) < xs.length) start else xs.length
diff --git a/src/library/scala/ref/PhantomReference.scala b/src/library/scala/ref/PhantomReference.scala
index d3519ea438..5be4e39117 100644
--- a/src/library/scala/ref/PhantomReference.scala
+++ b/src/library/scala/ref/PhantomReference.scala
@@ -15,5 +15,6 @@ package scala.ref
  */
 class PhantomReference[+T <: AnyRef](value: T, queue: ReferenceQueue[T]) extends ReferenceWrapper[T] {
   val underlying: java.lang.ref.PhantomReference[_ <: T] =
-    new java.lang.ref.PhantomReference(value, queue.underlying)
+    new java.lang.ref.PhantomReference[T](value, queue.underlying.asInstanceOf[java.lang.ref.ReferenceQueue[T]])
 }
+
diff --git a/src/library/scala/ref/SoftReference.scala b/src/library/scala/ref/SoftReference.scala
index 0a0b3642e7..fc6313f6ef 100644
--- a/src/library/scala/ref/SoftReference.scala
+++ b/src/library/scala/ref/SoftReference.scala
@@ -16,6 +16,6 @@ package scala.ref
 class SoftReference[+T <: AnyRef](value : T, queue : ReferenceQueue[T]) extends ReferenceWrapper[T] {
   def this(value : T) = this(value, null);
   val underlying: java.lang.ref.SoftReference[_ <: T] =
-    if (queue == null) new java.lang.ref.SoftReference(value);
-    else new java.lang.ref.SoftReference(value, queue.underlying);
+    if (queue == null) new java.lang.ref.SoftReference[T](value);
+    else new java.lang.ref.SoftReference[T](value, queue.underlying.asInstanceOf[java.lang.ref.ReferenceQueue[T]])
 }
diff --git a/src/library/scala/ref/WeakReference.scala b/src/library/scala/ref/WeakReference.scala
index c1ec3f8ff5..0d2e29d601 100644
--- a/src/library/scala/ref/WeakReference.scala
+++ b/src/library/scala/ref/WeakReference.scala
@@ -16,6 +16,6 @@ package scala.ref
 class WeakReference[+T <: AnyRef](value: T, queue: ReferenceQueue[T]) extends ReferenceWrapper[T] {
   def this(value: T) = this(value, null)
   val underlying: java.lang.ref.WeakReference[_ <: T] =
-    if (queue == null) new java.lang.ref.WeakReference(value)
-    else new java.lang.ref.WeakReference(value, queue.underlying)
+    if (queue == null) new java.lang.ref.WeakReference[T](value)
+    else new java.lang.ref.WeakReference[T](value, queue.underlying.asInstanceOf[java.lang.ref.ReferenceQueue[T]])
 }