Fix #2300: Try to heal subtype failures by instantiating type variables

The idea is that if an adapt fails because an actual type A is not a
subtype of an expected type B, we try to instantiate all type variables
in A and, if that changes something, try again.

This mitigates the discrepancy that dotc is more lazy in instantiating type
variables than scalac.

Fixes #2300.

Author: odersky

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -383,7 +383,8 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
    *  prefix. If the result has another unsafe instantiation, raise an error.
    */
   private def healNonvariant[T <: Tree](tree: T, pt: Type)(implicit ctx: Context): T  =
-    if (ctx.unsafeNonvariant == ctx.runId && tree.tpe.widen.hasUnsafeNonvariant)
+    if (ctx.unsafeNonvariant == ctx.runId && tree.tpe.widen.hasUnsafeNonvariant) {
+      println(i"HEAL $tree")
       tree match {
         case tree @ Select(qual, _) if !qual.tpe.isStable =>
           val alt = typedSelect(tree, pt, Typed(qual, TypeTree(SkolemType(qual.tpe.widen))))
@@ -392,7 +393,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
         case _ =>
           ctx.error(ex"unsafe instantiation of type ${tree.tpe}", tree.pos)
           tree
-      }
+      }}
     else tree
 
   def typedSelect(tree: untpd.Select, pt: Type)(implicit ctx: Context): Tree = track("typedSelect") {
@@ -2186,6 +2187,16 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
           }
         case _ =>
       }
+      // try to fully instantiate type
+      {
+        val ictx = ctx.fresh.setNewTyperState
+        val constraint = ictx.typerState.constraint
+        if (isFullyDefined(wtp, force = ForceDegree.all)(ictx) &&
+            ictx.typerState.constraint.ne(constraint)) {
+          ictx.typerState.commit()
+          return adapt(tree, pt, original)
+        }
+      }
       // try an implicit conversion
       inferView(tree, pt) match {
         case SearchSuccess(inferred, _, _, _) =>

tests/pos/i2300.scala

@@ -0,0 +1,26 @@
+object hlists {
+  sealed abstract class HList {
+    type Merge[L <: HList] <: HList
+
+    def merge[L <: HList](l: L): Merge[L]
+  }
+  final case class HCons[H, T <: HList](head : H, tail : T) extends HList {
+    type Merge[L <: HList] = HCons[H, tail.Merge[L]]
+
+    def merge[L <: HList](l: L): Merge[L] = HCons(head, tail.merge(l))
+  }
+  sealed trait HNil extends HList {
+    type Merge[L <: HList] = L
+
+    def merge[L <: HList](l: L): Merge[L] = l
+  }
+  final val HNil: HNil = { case object HNil extends HNil; HNil }
+}
+
+object Test {
+  import hlists._
+
+  val merged: HCons[Int,HCons[String,HNil]] = {
+    HCons(42, HNil) merge HCons("foo", HNil)
+  }
+}