Fix liftIfHK

Could create orphan paramrefs before.

Author: odersky

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

@@ -1287,8 +1287,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
           tl.integrate(tparams1, tparam1.paramInfoAsSeenFrom(tp1)).bounds &
           tl.integrate(tparams2, tparam2.paramInfoAsSeenFrom(tp2)).bounds),
         resultTypeExp = tl =>
-          original(tl.integrate(tparams1, tp1).appliedTo(tl.paramRefs),
-             tl.integrate(tparams2, tp2).appliedTo(tl.paramRefs)))
+          original(tp1.appliedTo(tl.paramRefs), tp2.appliedTo(tl.paramRefs)))
   }
 
   /** Try to distribute `&` inside type, detect and handle conflicts

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -119,24 +119,26 @@ class TreePickler(pickler: TastyPickler) {
       pickleType(c.symbolValue.termRef)
   }
 
-  def pickleType(tpe0: Type, richTypes: Boolean = false)(implicit ctx: Context): Unit = try {
+  def pickleType(tpe0: Type, richTypes: Boolean = false)(implicit ctx: Context): Unit = {
     val tpe = tpe0.stripTypeVar
-    val prev = pickledTypes.get(tpe)
-    if (prev == null) {
-      pickledTypes.put(tpe, currentAddr)
-      pickleNewType(tpe, richTypes)
-    }
-    else {
-      writeByte(SHARED)
-      writeRef(prev.asInstanceOf[Addr])
+    try {
+      val prev = pickledTypes.get(tpe)
+      if (prev == null) {
+        pickledTypes.put(tpe, currentAddr)
+        pickleNewType(tpe, richTypes)
+      }
+      else {
+        writeByte(SHARED)
+        writeRef(prev.asInstanceOf[Addr])
+      }
+    } catch {
+      case ex: AssertionError =>
+        println(i"error when pickling type $tpe")
+        throw ex
     }
-  } catch {
-    case ex: AssertionError =>
-      println(i"error when pickling type $tpe0")
-      throw ex
   }
 
-  private def pickleNewType(tpe: Type, richTypes: Boolean)(implicit ctx: Context): Unit = try { tpe match {
+  private def pickleNewType(tpe: Type, richTypes: Boolean)(implicit ctx: Context): Unit = tpe match {
     case AppliedType(tycon, args) =>
       writeByte(APPLIEDtype)
       withLength { pickleType(tycon); args.foreach(pickleType(_)) }
@@ -241,21 +243,10 @@ class TreePickler(pickler: TastyPickler) {
       pickleMethodic(POLYtype, tpe)
     case tpe: MethodType if richTypes =>
       pickleMethodic(METHODtype, tpe)
-    case tpe: TypeParamRef =>
-      if (!pickleParamRef(tpe))
-      // TODO figure out why this case arises in e.g. pickling AbstractFileReader.
-        ctx.typerState.constraint.entry(tpe) match {
-          case TypeBounds(lo, hi) if lo eq hi => pickleNewType(lo, richTypes)
-          case _ => assert(false, s"orphan poly parameter: $tpe")
-        }
-    case tpe: TermParamRef =>
-      assert(pickleParamRef(tpe), s"orphan method parameter: $tpe")
+    case tpe: ParamRef =>
+      assert(pickleParamRef(tpe), s"orphan parameter reference: $tpe")
     case tpe: LazyRef =>
       pickleType(tpe.ref)
-  }} catch {
-    case ex: AssertionError =>
-      println(i"error while pickling type $tpe")
-      throw ex
   }
 
   def picklePackageRef(pkg: Symbol)(implicit ctx: Context): Unit = {

compiler/src/dotty/tools/dotc/transform/TreeChecker.scala

@@ -18,6 +18,7 @@ import core.Decorators._
 import core.TypeErasure.isErasedType
 import core.Phases.Phase
 import core.Mode
+import SymUtils._
 import typer._
 import typer.ErrorReporting._
 import reporting.ThrowingReporter
@@ -45,7 +46,7 @@ import scala.util.control.NonFatal
  */
 class TreeChecker extends Phase with SymTransformer {
   import ast.tpd._
-
+  import TreeChecker._
 
   private val seenClasses = collection.mutable.HashMap[String, Symbol]()
   private val seenModuleVals = collection.mutable.HashMap[String, Symbol]()
@@ -288,26 +289,6 @@ class TreeChecker extends Phase with SymTransformer {
       res
     }
 
-    /** Check that TypeParamRefs and MethodParams refer to an enclosing type */
-    def checkNoOrphans(tp: Type)(implicit ctx: Context) = new TypeMap() {
-      val definedBinders = mutable.Set[Type]()
-      def apply(tp: Type): Type = {
-        tp match {
-          case tp: BindingType =>
-            definedBinders += tp
-            mapOver(tp)
-            definedBinders -= tp
-          case tp: ParamRef =>
-            assert(definedBinders.contains(tp.binder), s"orphan param: $tp")
-          case tp: TypeVar =>
-            apply(tp.underlying)
-          case _ =>
-            mapOver(tp)
-        }
-        tp
-      }
-    }.apply(tp)
-
     def checkNotRepeated(tree: Tree)(implicit ctx: Context): tree.type = {
       def allowedRepeated = (tree.symbol.flags is Case) && tree.tpe.widen.isRepeatedParam
 
@@ -467,3 +448,27 @@ class TreeChecker extends Phase with SymTransformer {
     }
   }
 }
+
+object TreeChecker {
+  /** Check that TypeParamRefs and MethodParams refer to an enclosing type */
+  def checkNoOrphans(tp0: Type, tree: untpd.Tree = untpd.EmptyTree)(implicit ctx: Context) = new TypeMap() {
+    val definedBinders = new java.util.IdentityHashMap[Type, Any]
+    def apply(tp: Type): Type = {
+      tp match {
+        case tp: BindingType =>
+          definedBinders.put(tp, tp)
+          mapOver(tp)
+          definedBinders.remove(tp)
+        case tp: ParamRef =>
+          assert(definedBinders.get(tp.binder) != null, s"orphan param: ${tp.show}, hash of binder = ${System.identityHashCode(tp.binder)}, tree = ${tree.show}, type = $tp0")
+        case tp: TypeVar =>
+          apply(tp.underlying)
+        case tp: TypeRef if tp.info.isAlias && tp.symbol.isAliasPreferred =>
+          apply(tp.superType)
+        case _ =>
+          mapOver(tp)
+      }
+      tp
+    }
+  }.apply(tp0)
+}