Rework type inference

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

@@ -5,7 +5,7 @@ package core
 import Types._
 import Flags._
 import Contexts._
-import util.{SimpleIdentityMap, DotClass}
+import util.{SimpleIdentityMap, SimpleIdentitySet, DotClass}
 import reporting._
 import printing.{Showable, Printer}
 import printing.Texts._
@@ -76,6 +76,11 @@ class TyperState(previous: TyperState /* | Null */) {
   /** The uninstantiated variables */
   def uninstVars = constraint.uninstVars
 
+  /** The set of uninstantiated type varibles which have this state as their owning state */
+  private[this] var myOwnedVars: TypeVars = SimpleIdentitySet.empty
+  def ownedVars = myOwnedVars
+  def ownedVars_=(vs: TypeVars): Unit = myOwnedVars = vs
+
   /** Gives for each instantiated type var that does not yet have its `inst` field
    *  set, the instance value stored in the constraint. Storing instances in constraints
    *  is done only in a temporary way for contexts that may be retracted
@@ -154,6 +159,7 @@ class TyperState(previous: TyperState /* | Null */) {
     constraint foreachTypeVar { tvar =>
       if (tvar.owningState.get eq this) tvar.owningState = new WeakReference(targetState)
     }
+    targetState.ownedVars ++= ownedVars
     targetState.gc()
     reporter.flush()
     isCommitted = true

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

@@ -18,7 +18,7 @@ import Denotations._
 import Periods._
 import util.Positions.{Position, NoPosition}
 import util.Stats._
-import util.DotClass
+import util.{DotClass, SimpleIdentitySet}
 import reporting.diagnostic.Message
 import reporting.diagnostic.messages.CyclicReferenceInvolving
 import ast.tpd._
@@ -3369,7 +3369,10 @@ object Types {
     private[core] def inst = myInst
     private[core] def inst_=(tp: Type) = {
       myInst = tp
-      if (tp.exists) owningState = null // no longer needed; null out to avoid a memory leak
+      if (tp.exists) {
+        owningState.get.ownedVars -= this
+        owningState = null // no longer needed; null out to avoid a memory leak
+      }
     }
 
     /** The state owning the variable. This is at first `creatorState`, but it can
@@ -3433,6 +3436,8 @@ object Types {
     }
   }
 
+  type TypeVars = SimpleIdentitySet[TypeVar]
+
   // ------ ClassInfo, Type Bounds ------------------------------------------------------------
 
   type TypeOrSymbol = AnyRef /* should be: Type | Symbol */

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

@@ -675,14 +675,16 @@ object Erasure {
       super.typedStats(stats1, exprOwner).filter(!_.isEmpty)
     }
 
-    override def adapt(tree: Tree, pt: Type)(implicit ctx: Context): Tree =
+    override def adapt(tree: Tree, pt: Type, locked: TypeVars)(implicit ctx: Context): Tree =
       trace(i"adapting ${tree.showSummary}: ${tree.tpe} to $pt", show = true) {
-        assert(ctx.phase == ctx.erasurePhase.next, ctx.phase)
+        assert(ctx.phase == ctx.erasurePhase || ctx.phase == ctx.erasurePhase.next, ctx.phase)
         if (tree.isEmpty) tree
         else if (ctx.mode is Mode.Pattern) tree // TODO: replace with assertion once pattern matcher is active
         else adaptToType(tree, pt)
       }
-  }
+
+    override def simplify(tree: Tree, pt: Type, locked: TypeVars)(implicit ctx: Context): tree.type = tree
+}
 
   def takesBridges(sym: Symbol)(implicit ctx: Context) =
     sym.isClass && !sym.is(Flags.Trait | Flags.Package)

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

@@ -259,14 +259,14 @@ class TreeChecker extends Phase with SymTransformer {
       tpdTree
     }
 
-    override def typedUnadapted(tree: untpd.Tree, pt: Type)(implicit ctx: Context): tpd.Tree = {
+    override def typedUnadapted(tree: untpd.Tree, pt: Type, locked: TypeVars)(implicit ctx: Context): tpd.Tree = {
       val res = tree match {
         case _: untpd.TypedSplice | _: untpd.Thicket | _: EmptyValDef[_] =>
-          super.typedUnadapted(tree)
+          super.typedUnadapted(tree, pt, locked)
         case _ if tree.isType =>
           promote(tree)
         case _ =>
-          val tree1 = super.typedUnadapted(tree, pt)
+          val tree1 = super.typedUnadapted(tree, pt, locked)
           def isSubType(tp1: Type, tp2: Type) =
             (tp1 eq tp2) || // accept NoType / NoType
             (tp1 <:< tp2)
@@ -435,7 +435,7 @@ class TreeChecker extends Phase with SymTransformer {
     override def ensureNoLocalRefs(tree: Tree, pt: Type, localSyms: => List[Symbol])(implicit ctx: Context): Tree =
       tree
 
-    override def adapt(tree: Tree, pt: Type)(implicit ctx: Context) = {
+    override def adapt(tree: Tree, pt: Type, locked: TypeVars)(implicit ctx: Context) = {
       def isPrimaryConstructorReturn =
         ctx.owner.isPrimaryConstructor && pt.isRef(ctx.owner.owner) && tree.tpe.isRef(defn.UnitClass)
       if (ctx.mode.isExpr &&
@@ -449,6 +449,8 @@ class TreeChecker extends Phase with SymTransformer {
         })
       tree
     }
+
+    override def simplify(tree: Tree, pt: Type, locked: TypeVars)(implicit ctx: Context): tree.type = tree
   }
 
   /**

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

@@ -546,7 +546,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     init()
 
     def addArg(arg: Tree, formal: Type): Unit =
-      typedArgBuf += adaptInterpolated(arg, formal.widenExpr)
+      typedArgBuf += adapt(arg, formal.widenExpr)
 
     def makeVarArg(n: Int, elemFormal: Type): Unit = {
       val args = typedArgBuf.takeRight(n).toList
@@ -711,7 +711,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
        *  part. Return an optional value to indicate success.
        */
       def tryWithImplicitOnQualifier(fun1: Tree, proto: FunProto)(implicit ctx: Context): Option[Tree] =
-        tryInsertImplicitOnQualifier(fun1, proto) flatMap { fun2 =>
+        tryInsertImplicitOnQualifier(fun1, proto, ctx.typerState.ownedVars) flatMap { fun2 =>
           tryEither {
             implicit ctx => Some(simpleApply(fun2, proto)): Option[Tree]
           } {
@@ -1519,11 +1519,11 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
    *  If the resulting trees all have the same type, return them instead of the original ones.
    */
   def harmonize(trees: List[Tree])(implicit ctx: Context): List[Tree] = {
-    def adapt(tree: Tree, pt: Type): Tree = tree match {
-      case cdef: CaseDef => tpd.cpy.CaseDef(cdef)(body = adapt(cdef.body, pt))
-      case _ => adaptInterpolated(tree, pt)
+    def adaptDeep(tree: Tree, pt: Type): Tree = tree match {
+      case cdef: CaseDef => tpd.cpy.CaseDef(cdef)(body = adaptDeep(cdef.body, pt))
+      case _ => adapt(tree, pt)
     }
-    if (ctx.isAfterTyper) trees else harmonizeWith(trees)(_.tpe, adapt)
+    if (ctx.isAfterTyper) trees else harmonizeWith(trees)(_.tpe, adaptDeep)
   }
 
   /** Apply a transformation `harmonize` on the results of operation `op`.

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

@@ -120,9 +120,12 @@ object ErrorReporting {
       val found1 = dropJavaMethod(found)
       val expected1 = dropJavaMethod(expected)
       if ((found1 eq found) != (expected eq expected1) && (found1 <:< expected1))
-        "\n(Note that Scala's and Java's representation of this type differs)"
+        i"""
+           |(Note that Scala's and Java's representation of this type differs)"""
       else if (ctx.settings.explainTypes.value)
-        "\n" + ctx.typerState.show + "\n" + TypeComparer.explained((found <:< expected)(_))
+        i"""
+           |${ctx.typerState.constraint}
+           |${TypeComparer.explained((found <:< expected)(_))}"""
       else
         ""
     }

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

@@ -768,7 +768,7 @@ trait Implicits { self: Typer =>
         case result: SearchSuccess =>
           result.tstate.commit()
           implicits.println(i"success: $result")
-          implicits.println(i"committing ${result.tstate.constraint} yielding ${ctx.typerState.constraint} ${ctx.typerState.hashesStr}")
+          implicits.println(i"committing ${result.tstate.constraint} yielding ${ctx.typerState.constraint} in ${ctx.typerState}")
           result
         case result: SearchFailure if result.isAmbiguous =>
           val deepPt = pt.deepenProto
@@ -828,11 +828,12 @@ trait Implicits { self: Typer =>
     def typedImplicit(cand: Candidate, contextual: Boolean)(implicit ctx: Context): SearchResult = track("typedImplicit") { trace(i"typed implicit ${cand.ref}, pt = $pt, implicitsEnabled == ${ctx.mode is ImplicitsEnabled}", implicits, show = true) {
       val ref = cand.ref
       var generated: Tree = tpd.ref(ref).withPos(pos.startPos)
+      val locked = ctx.typerState.ownedVars
       if (!argument.isEmpty)
         generated = typedUnadapted(
           untpd.Apply(untpd.TypedSplice(generated), untpd.TypedSplice(argument) :: Nil),
-          pt)
-      val generated1 = adapt(generated, pt)
+          pt, locked)
+      val generated1 = adapt(generated, pt, locked)
       lazy val shadowing =
         typed(untpd.Ident(cand.implicitRef.implicitName) withPos pos.toSynthetic, funProto)(
           nestedContext().addMode(Mode.ImplicitShadowing).setExploreTyperState())