Fix bug for reading type arguments in ClassfileParser

Author: odersky

src/dotty/tools/dotc/Main.scala

@@ -10,10 +10,7 @@ import reporting.Reporter
 
 /* To do:
  *   - simplify hk types
- *   - review isSubType
- *   - have a second look at normalization (leave at method types if pt is method type?)
  *   - Don't open package objects from class files if they are present in source
- *   - check why we cannot access java.util.LinkedHashMap as a map
  *   - Revise the way classes are inherited - when not followed by [...] or (...),
  *     assume the unparameterized type and forward type parameters as we do now for the synthetic head class.
  */

src/dotty/tools/dotc/config/Config.scala

@@ -12,6 +12,8 @@ object Config {
 
   final val checkConstraintsNonCyclic = true
 
+  final val flagInstantiationToNothing = false
+
   /** Throw an exception if a deep subtype recursion is detected */
   final val flagDeepSubTypeRecursions = true
 

src/dotty/tools/dotc/core/TypeComparer.scala

@@ -354,8 +354,11 @@ class TypeComparer(initctx: Context) extends DotClass {
             addConstraint(tp1, tp2, fromBelow = false) && {
               if ((!frozenConstraint) &&
                   (tp2 isRef defn.NothingClass) &&
-                  ctx.typerState.isGlobalCommittable)
-                ctx.log(s"!!! instantiated to Nothing: $tp1, constraint = ${constraint.show}")
+                  ctx.typerState.isGlobalCommittable) {
+                def msg = s"!!! instantiated to Nothing: $tp1, constraint = ${constraint.show}"
+                if (Config.flagInstantiationToNothing) assert(false, msg)
+                else ctx.log(msg)
+              }
               true
             }
           else (ctx.mode is Mode.TypevarsMissContext) || thirdTry(tp1, tp2)
@@ -437,7 +440,7 @@ class TypeComparer(initctx: Context) extends DotClass {
             ancestor2.exists && isSubType(tp1, ancestor2)
           }
         case _ =>
-          def hasMatchingMember(name: Name): Boolean = /*>|>*/ traceIndented(s"hasMatchingMember($name) ${tp1.member(name)}") /*<|<*/ (
+          def hasMatchingMember(name: Name): Boolean = /*>|>*/ ctx.traceIndented(s"hasMatchingMember($name) ${tp1.member(name)}", subtyping) /*<|<*/ (
                tp1.member(name).hasAltWith(alt => isSubType(alt.info, tp2.refinedInfo))
             ||
                { // special case for situations like:

src/dotty/tools/dotc/core/pickling/ClassfileParser.scala

@@ -268,9 +268,9 @@ class ClassfileParser(
                           else TypeBounds.lower(tp)
                         case '*' => TypeBounds.empty
                       }
-                      tp1 = RefinedType(tp, formals.head.name, bounds)
+                      tp1 = RefinedType(tp1, formals.head.name, bounds)
                     case _ =>
-                      tp1 = RefinedType(tp, formals.head.name, TypeAlias(sig2type(tparams, skiptvs)))
+                      tp1 = RefinedType(tp1, formals.head.name, TypeAlias(sig2type(tparams, skiptvs)))
                   }
                   formals = formals.tail
                 }

src/dotty/tools/dotc/typer/Implicits.scala

@@ -626,8 +626,9 @@ class SearchHistory(val searchDepth: Int, val seen: Map[ClassSymbol, Int]) {
 
 /** A set of term references where equality is =:= */
 class TermRefSet(implicit ctx: Context) extends mutable.Traversable[TermRef] {
-  private val elems = new mutable.LinkedHashMap[TermSymbol, List[Type]] // todo: change to j.u.LinkedHashMap?
-
+  import collection.JavaConverters._
+  private val elems = (new java.util.LinkedHashMap[TermSymbol, List[Type]]).asScala
+  
   def += (ref: TermRef): Unit = {
     val pre = ref.prefix
     val sym = ref.symbol.asTerm

tests/pos/test.scala

@@ -1,11 +1,8 @@
 object test {
 
-  import java.util.concurrent.{ Future, Callable, ExecutorService }
-  def callable[T](body: => T): Callable[T] = new Callable[T] { override def call() = body }
+  import collection.JavaConverters._
 
-  
-  def xsubmit(x: Runnable): Future[_] = ???
-  //def xsubmit[T](x: Runnable, y: T): Future[T] = ???
-  def xsubmit[U](x: Callable[U]): Future[U] = ???
-  def spawn0[V](body: V): Future[V]         = xsubmit(callable(body))
+  private val elems =
+    (new java.util.LinkedHashMap[String, List[Int]]).asScala
+  val elems2: collection.mutable.Map[String, List[Int]] = elems
 }