Make TypeLambdas not be ValueTypes

Author: odersky

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

@@ -393,7 +393,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
     val replacement = tp.dealias.stripTypeVar
     if (param == replacement) this
     else {
-      assert(replacement.isValueType)
+      assert(replacement.isValueTypeOrLambda)
       val poly = param.binder
       val idx = param.paramNum
 

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

@@ -533,7 +533,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
             case OrType(tp1, tp2) => isNullable(tp1) || isNullable(tp2)
             case _ => false
           }
-          (tp1.symbol eq NothingClass) && tp2.isInstanceOf[ValueType] ||
+          (tp1.symbol eq NothingClass) && tp2.isValueTypeOrLambda ||
           (tp1.symbol eq NullClass) && isNullable(tp2)
       }
     case tp1: SingletonType =>

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

@@ -96,6 +96,9 @@ object Types {
     /** Is this type a value type? */
     final def isValueType: Boolean = this.isInstanceOf[ValueType]
 
+    /** Is the is value type or type lambda? */
+    final def isValueTypeOrLambda: Boolean = isValueType || this.isInstanceOf[TypeLambda]
+
     /** Does this type denote a stable reference (i.e. singleton type)? */
     final def isStable(implicit ctx: Context): Boolean = stripTypeVar match {
       case tp: TermRef => tp.termSymbol.isStable && tp.prefix.isStable
@@ -2203,7 +2206,7 @@ object Types {
 
   object AndType {
     def apply(tp1: Type, tp2: Type)(implicit ctx: Context) = {
-      assert(tp1.isInstanceOf[ValueType] && tp2.isInstanceOf[ValueType], i"$tp1 & $tp2 / " + s"$tp1 & $tp2")
+      assert(tp1.isValueType && tp2.isValueType, i"$tp1 & $tp2 / " + s"$tp1 & $tp2")
       unchecked(tp1, tp2)
     }
     def unchecked(tp1: Type, tp2: Type)(implicit ctx: Context) = {

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

@@ -412,7 +412,7 @@ trait Implicits { self: Typer =>
     && !to.isError
     && !ctx.isAfterTyper
     && (ctx.mode is Mode.ImplicitsEnabled)
-    && from.isInstanceOf[ValueType]
+    && from.isValueType
     && (  from.isValueSubType(to)
        || inferView(dummyTreeOfType(from), to)
             (ctx.fresh.addMode(Mode.ImplicitExploration).setExploreTyperState)