Change handling of lambda params in inference

Previously, removing them from the constraint set was broken:
existentials.scala crashed with orphan params.

We now treat type lambda parameters much more like polytype parameters:
they get associated typevars and interpolateUndetVars decides when to
get rid of them.

Author: odersky

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

@@ -72,6 +72,9 @@ abstract class Constraint extends Showable {
   /** The bounds of `param` including all known-to-be-smaller and -greater parameters */
   def fullBounds(param: PolyParam)(implicit ctx: Context): TypeBounds
 
+  /** If `param` is instantiated to some type, the instance type, otherwise NoType */
+  def instanceType(param: PolyParam): Type
+
   /** A new constraint which is derived from this constraint by adding
    *  entries for all type parameters of `poly`.
    *  @param tvars   A list of type variables associated with the params,

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

@@ -94,10 +94,8 @@ trait ConstraintHandling {
     def description = i"ordering $p1 <: $p2 to\n$constraint"
     val res =
       if (constraint.isLess(p2, p1))
-        if (p2.binder.isInstanceOf[TypeLambda] && !p1.binder.isInstanceOf[TypeLambda])
-          unify(p1, p2)
-        else
-          unify(p2, p1)
+        if (p2.binder.isLambda && !p1.binder.isLambda) unify(p1, p2)
+        else unify(p2, p1)
       else {
         val down1 = p1 :: constraint.exclusiveLower(p1, p2)
         val up2 = p2 :: constraint.exclusiveUpper(p2, p1)
@@ -174,7 +172,9 @@ trait ConstraintHandling {
         }
       }
     }
-    val bound = if (fromBelow) constraint.fullLowerBound(param) else constraint.fullUpperBound(param)
+    val bound = constraint.instanceType(param).orElse(
+      if (fromBelow) constraint.fullLowerBound(param)
+      else constraint.fullUpperBound(param))
     val inst = avoidParam(bound)
     typr.println(s"approx ${param.show}, from below = $fromBelow, bound = ${bound.show}, inst = ${inst.show}")
     inst
@@ -228,11 +228,6 @@ trait ConstraintHandling {
     // 3. If instance is from below, and upper bound has open named parameters
     //    make sure the instance has all named parameters of the bound.
     if (fromBelow) inst = inst.widenToNamedTypeParams(param.namedTypeParams)
-
-    if (ctx.typerState.isGlobalCommittable)
-      assert(!inst.isInstanceOf[PolyParam], i"bad inst $this := $inst, constr = ${ctx.typerState.constraint}")
-    // If this fails, you might want to turn on Config.debugCheckConstraintsClosed
-    // to help find the root of the problem.
     inst
   }
 

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

@@ -477,15 +477,19 @@ object Denotations {
 
     final def signature(implicit ctx: Context): Signature = {
       if (isType) Signature.NotAMethod // don't force info if this is a type SymDenotation
-      else info match {
-        case info: MethodicType =>
-          try info.signature
-          catch { // !!! DEBUG
-            case scala.util.control.NonFatal(ex) =>
-              ctx.echo(s"cannot take signature of ${info.show}")
-              throw ex
-          }
-        case _ => Signature.NotAMethod
+      else {
+        def sig(info: Type): Signature = info match {
+          case info: MethodicType =>
+            try info.signature
+            catch { // !!! DEBUG
+              case scala.util.control.NonFatal(ex) =>
+                ctx.echo(s"cannot take signature of ${info.show}")
+                throw ex
+            }
+          case HKApply(tl: TypeLambda, _) => sig(tl.resType)
+          case _ => Signature.NotAMethod
+        }
+        sig(info)
       }
     }
 

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

@@ -210,6 +210,11 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
     }
   }
 
+  def instanceType(param: PolyParam): Type = entry(param) match {
+    case _: TypeBounds => NoType
+    case alias => alias
+  }
+
 // ---------- Adding PolyTypes --------------------------------------------------
 
   /** The list of parameters P such that, for a fresh type parameter Q:
@@ -501,7 +506,9 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
 
   override def checkClosed()(implicit ctx: Context): Unit = {
     def isFreePolyParam(tp: Type) = tp match {
-      case PolyParam(binder: GenericType, _) => !contains(binder)
+      case PolyParam(binder: PolyType, _) =>
+        // note that free type lambda params may appear in the constraint
+        !contains(binder)
       case _ => false
     }
     def checkClosedType(tp: Type, where: String) =

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

@@ -1824,6 +1824,7 @@ object SymDenotations {
     override def isType = false
     override def owner: Symbol = throw new AssertionError("NoDenotation.owner")
     override def computeAsSeenFrom(pre: Type)(implicit ctx: Context): SingleDenotation = this
+    override def mapInfo(f: Type => Type)(implicit ctx: Context): SingleDenotation = this
     validFor = Period.allInRun(NoRunId) // will be brought forward automatically
   }
 

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

@@ -153,10 +153,7 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
         case tp1 => tp1
       }
     case param: PolyParam =>
-      if (param.binder.isInstanceOf[TypeLambda] && typerState.constraint.contains(param))
-        typeComparer.instantiateLambdaParam(param, if (theMap == null) 1 else theMap.currentVariance)
-      else
-        typerState.constraint.typeVarOfParam(param) orElse param
+      typerState.constraint.typeVarOfParam(param) orElse param
     case  _: ThisType | _: BoundType | NoPrefix =>
       tp
     case tp: RefinedType =>

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

@@ -140,30 +140,6 @@ extends TyperState(r) {
     }
     for (poly <- toCollect)
       constraint = constraint.remove(poly)
-
-    lazy val keptLambdas: collection.Set[TypeLambda] = {
-      val toKeep = mutable.Set.empty[TypeLambda]
-      def keep(p: PolyParam) = p.binder match {
-        case tl: TypeLambda => toKeep += tl
-        case _ =>
-      }
-      for (poly <- constraint.domainPolys)
-        if (poly.isInstanceOf[PolyType])
-          for (param <- poly.paramRefs) {
-            constraint.lower(param).foreach(keep)
-            constraint.upper(param).foreach(keep)
-            constraint.entry(param).foreachPart {
-              case p: PolyParam if constraint contains p => keep(p)
-              case _ =>
-            }
-          }
-      toKeep
-    }
-    constraint.domainPolys.foreach {
-      case tl: TypeLambda if !keptLambdas.contains(tl) =>
-         constraint = constraint.remove(tl)
-      case _ =>
-    }
   }
 
   /** Try operation `op`; if it produces errors, execute `fallback` with constraint and

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

@@ -2494,6 +2494,8 @@ object Types {
 
     override def resultType(implicit ctx: Context) = resType
 
+    def isLambda = this.isInstanceOf[TypeLambda]
+
     /** Unconditionally create a new generic type like this one with given elements */
     def duplicate(paramNames: List[TypeName] = this.paramNames, paramBounds: List[TypeBounds] = this.paramBounds, resType: Type)(implicit ctx: Context): GenericType
 
@@ -2871,8 +2873,18 @@ object Types {
     }
 
     /** Instantiate variable from the constraints over its `origin`. */
-    def instantiate(fromBelow: Boolean)(implicit ctx: Context): Type =
-      instantiateWith(ctx.typeComparer.instanceType(origin, fromBelow))
+    def instantiate(fromBelow: Boolean)(implicit ctx: Context): Type = {
+      val inst = ctx.typeComparer.instanceType(origin, fromBelow)
+      if (ctx.typerState.isGlobalCommittable)
+        inst match {
+          case inst: PolyParam =>
+            assert(inst.binder.isLambda, i"bad inst $this := $inst, constr = ${ctx.typerState.constraint}")
+            // If this fails, you might want to turn on Config.debugCheckConstraintsClosed
+            // to help find the root of the problem.
+          case _ =>
+        }
+      instantiateWith(inst)
+    }
 
     /** Unwrap to instance (if instantiated) or origin (if not), until result
      *  is no longer a TypeVar

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

@@ -592,6 +592,15 @@ trait Implicits { self: Typer =>
 
     /** Search a list of eligible implicit references */
     def searchImplicits(eligible: List[TermRef], contextual: Boolean): SearchResult = {
+      // Implicit search was observed to create an infinite loop when comparing
+      // overloaded variants of Set#+ on an existential type. The following code
+      // would prevent this. But it's just a stop-gap, really. We still have to figure
+      // out whether to support such existentials at all. If not, where to draw the line?
+      // pt match 
+      //   case HKApply(tl: TypeLambda, _) => return NoImplicitMatches
+      //   case _ =>
+      // }
+
       val constr = ctx.typerState.constraint
 
       /** Try to typecheck an implicit reference */

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

@@ -323,8 +323,7 @@ object ProtoTypes {
    */
   def constrained(pt: GenericType, owningTree: untpd.Tree)(implicit ctx: Context): (GenericType, List[TypeVar]) = {
     val state = ctx.typerState
-    assert(!(ctx.typerState.isCommittable && owningTree.isEmpty && pt.isInstanceOf[PolyType]),
-      s"inconsistent: no typevars were added to committable constraint ${state.constraint}")
+    val needsTypeVars = ctx.typerState.isCommittable || !owningTree.isEmpty
 
     def newTypeVars(pt: GenericType): List[TypeVar] =
       for (n <- (0 until pt.paramNames.length).toList)
@@ -333,7 +332,7 @@ object ProtoTypes {
     val added =
       if (state.constraint contains pt) pt.duplicate(pt.paramNames, pt.paramBounds, pt.resultType)
       else pt
-    val tvars = if (owningTree.isEmpty) Nil else newTypeVars(added)
+    val tvars = if (needsTypeVars) newTypeVars(added) else Nil
     ctx.typeComparer.addToConstraint(added, tvars)
     (added, tvars)
   }

tests/disabled/pos/flowops.scala

@@ -1,16 +1,50 @@
 object TestList {
 
   var x: ([X] -> List[List[X]])[_] = List(List(1))
+  var y: ([X] -> List[Seq[X]])[_] = List(List(1))
 
-  var y: List[_] = x
+  x = x
+  y = y
+  y = x
+  // x = y  // error
+
+  val h = x.head
+  val x1: List[_] = h
+
+  var z: List[_] = x
 
 }
 object TestSet {
 
-  class Set[S](x: S)
+  var x: ([Y] -> Set[Set[Y]])[_] = Set(Set("a"))
+  var y: ([Y] -> Set[Iterable[Y]])[_] = Set(Set("a"))
+
+  x = x
+  y = y
+  // y = x // error
+  // x = y   // error
 
-  var x: ([Y] -> Set[Set[Y]])[_] = new Set(new Set("a"))
+  val h = x.head
+  val h1: Set[_] = h
 
-  var y: Set[_] = x
+  // val p = x.+(_) // error: not found: _$1   -- (this is not OK!)
+
+  // val p = x.+ // infinite loop in implicit search
+
+  var z: Set[_] = x
 
 }
+object TestX {
+
+  class C[T](x: T) {
+    def get: T = x
+    def cmp: T => Boolean = (x == _)
+  }
+
+  val x: ([Y] -> C[C[Y]])[_] = new C(new C("a"))
+
+  val g = x.get
+
+  val c = x.cmp
+}
+