Address reviewers comments

 - explain why checkRealizable better
 - add test case for bad bounds in basetypes
 - drop dead code
 - documentation fixes
 - fixes to lubArgs/glbArgs

Author: odersky

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

@@ -101,6 +101,9 @@ class CheckRealizable(implicit ctx: Context) {
    *    - all type members have good bounds
    *    - all base types are class types, and if their arguments are wildcards
    *      they have good bounds.
+   *    - base types do not appear in multiple instances with different arguments.
+   *      (depending on the simplification scheme for AndTypes employed, this could
+   *       also lead to base types with bad bounds).
    */
   private def boundsRealizability(tp: Type) = {
     val mbrProblems =
@@ -109,7 +112,7 @@ class CheckRealizable(implicit ctx: Context) {
         if !(mbr.info.loBound <:< mbr.info.hiBound)
       }
       yield new HasProblemBounds(mbr)
-      
+
     def baseTypeProblems(base: Type) = base match {
       case AndType(base1, base2) =>
         new HasProblemBase(base1, base2) :: Nil
@@ -121,7 +124,7 @@ class CheckRealizable(implicit ctx: Context) {
     }
     val baseProblems =
       tp.baseClasses.map(_.baseTypeOf(tp)).flatMap(baseTypeProblems)
-      
+
     (((Realizable: Realizability)
       /: mbrProblems)(_ andAlso _)
       /: baseProblems)(_ andAlso _)

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

@@ -194,13 +194,12 @@ trait ConstraintHandling {
   final def approximation(param: TypeParamRef, fromBelow: Boolean): Type = {
     val avoidParam = new TypeMap {
       override def stopAtStatic = true
-      def avoidInArg(arg: Type, formal: TypeParamInfo): Type =
+      def avoidInArg(arg: Type): Type =
         if (param.occursIn(arg)) TypeBounds.empty else arg
       def apply(tp: Type) = mapOver {
         tp match {
           case tp @ AppliedType(tycon, args) =>
-            tp.derivedAppliedType(tycon,
-              args.zipWithConserve(tycon.typeParams)(avoidInArg))
+            tp.derivedAppliedType(tycon, args.mapConserve(avoidInArg))
           case tp: RefinedType if param occursIn tp.refinedInfo =>
             tp.parent
           case tp: WildcardType =>

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

@@ -78,9 +78,6 @@ class Definitions {
         val cls = denot.asClass.classSymbol
         val paramDecls = newScope
         val typeParam = enterSyntheticTypeParam(cls, paramFlags, paramDecls)
-        def instantiate(tpe: Type) =
-          if (tpe.typeParams.nonEmpty) tpe.appliedTo(typeParam.typeRef)
-          else tpe.dealias
         val parents = parentConstrs.toList
         denot.info = ClassInfo(ScalaPackageClass.thisType, cls, parents, paramDecls)
       }

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

@@ -644,12 +644,13 @@ object Denotations {
     // ------ Forming types -------------------------------------------
 
     /** The TypeRef representing this type denotation at its original location. */
-    def appliedRef(implicit ctx: Context): Type =
-      typeRef.appliedTo(symbol.typeParams.map(_.typeRef))
-
     def typeRef(implicit ctx: Context): TypeRef =
       TypeRef(symbol.owner.thisType, symbol.name.asTypeName, this)
 
+    /** The typeRef applied to its own type parameters */
+    def appliedRef(implicit ctx: Context): Type =
+      typeRef.appliedTo(symbol.typeParams.map(_.typeRef))
+
     /** The TermRef representing this term denotation at its original location. */
     def termRef(implicit ctx: Context): TermRef =
       TermRef(symbol.owner.thisType, symbol.name.asTermName, this)

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

@@ -337,6 +337,10 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
     case tp1 @ OrType(tp11, tp12) =>
       def joinOK = tp2.dealias match {
         case tp2: AppliedType if !tp2.tycon.typeSymbol.isClass =>
+          // If we apply the default algorithm for `A[X] | B[Y] <: C[Z]` where `C` is a
+          // type parameter, we will instantiate `C` to `A` and then fail when comparing
+          // with `B[Y]`. To do the right thing, we need to instantiate `C` to the
+          // common superclass of `A` and `B`.
           isSubType(tp1.join, tp2)
         case _ =>
           false
@@ -366,7 +370,9 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
       if (cls2.isClass) {
         val base = tp1.baseType(cls2)
         if (base.exists) {
-          if (cls2.is(JavaDefined)) return base.typeSymbol == cls2
+          if (cls2.is(JavaDefined))
+            // If `cls2` is parameterized, we are seeing a raw type, so we need to compare only the symbol
+            return base.typeSymbol == cls2
           if (base ne tp1) return isSubType(base, tp2)
         }
         if (cls2 == defn.SingletonClass && tp1.isStable) return true
@@ -689,14 +695,14 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
        *
        *  Returns `true` iff `d >= 0` and `tycon2` can be instantiated to
        *
-       *      [tparams1_d, ... tparams1_n-1] -> tycon1a[args_1, ..., args_d-1, tparams_d, ... tparams_n-1]
+       *      [tparams1_d, ... tparams1_n-1] -> tycon1[args_1, ..., args_d-1, tparams_d, ... tparams_n-1]
        *
        *  such that the resulting type application is a supertype of `tp1`.
        */
       def appOK(tp1base: Type) = tp1base match {
         case tp1base: AppliedType =>
           var tycon1 = tp1base.tycon
-          var args1 = tp1base.args
+          val args1 = tp1base.args
           val tparams1all = tycon1.typeParams
           val lengthDiff = tparams1all.length - tparams.length
           lengthDiff >= 0 && {
@@ -1244,14 +1250,22 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
   final def lub(tps: List[Type]): Type =
     ((defn.NothingType: Type) /: tps)(lub(_,_, canConstrain = false))
 
+  /** Try to produce joint arguments for a lub `A[T_1, ..., T_n] | A[T_1', ..., T_n']` using
+   *  the following strategies:
+   *
+   *    - if arguments are the same, that argument.
+   *    - if corresponding parameter variance is co/contra-variant, the lub/glb.
+   *    - otherwise a TypeBounds containing both arguments
+   */
   def lubArgs(args1: List[Type], args2: List[Type], tparams: List[TypeParamInfo], canConstrain: Boolean = false): List[Type] =
     tparams match {
       case tparam :: tparamsRest =>
         val arg1 :: args1Rest = args1
         val arg2 :: args2Rest = args2
         val v = tparam.paramVariance
         val lubArg =
-          if (v > 0) lub(arg1.hiBound, arg2.hiBound, canConstrain)
+          if (isSameTypeWhenFrozen(arg1, arg2)) arg1
+          else if (v > 0) lub(arg1.hiBound, arg2.hiBound, canConstrain)
           else if (v < 0) glb(arg1.loBound, arg2.loBound)
           else TypeBounds(glb(arg1.loBound, arg2.loBound),
                           lub(arg1.hiBound, arg2.hiBound, canConstrain))
@@ -1263,8 +1277,8 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
   /** Try to produce joint arguments for a glb `A[T_1, ..., T_n] & A[T_1', ..., T_n']` using
    *  the following strategies:
    *
-   *    - if corresponding parameter variance is co/contra-variant, the glb/lub.
    *    - if arguments are the same, that argument.
+   *    - if corresponding parameter variance is co/contra-variant, the glb/lub.
    *    - if at least one of the arguments if a TypeBounds, the union of
    *      the bounds.
    *    - if homogenizeArgs is set, and arguments can be unified by instantiating
@@ -1435,7 +1449,8 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
   private def distributeAnd(tp1: Type, tp2: Type): Type = tp1 match {
     case tp1 @ AppliedType(tycon1, args1) =>
       tp2 match {
-        case AppliedType(tycon2, args2) if tycon1.typeSymbol == tycon2.typeSymbol =>
+        case AppliedType(tycon2, args2)
+        if tycon1.typeSymbol == tycon2.typeSymbol && tycon1 =:= tycon2 =>
           val jointArgs = glbArgs(args1, args2, tycon1.typeParams)
           if (jointArgs.forall(_.exists)) (tycon1 & tycon2).appliedTo(jointArgs)
           else NoType

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

@@ -1032,9 +1032,7 @@ object Types {
       case tp: AnnotatedType =>
         tp.underlying.underlyingClassRef(refinementOK)
       case tp: RefinedType =>
-        def isParamName = tp.classSymbol.typeParams.exists(_.name == tp.refinedName)
-        if (refinementOK || isParamName) tp.underlying.underlyingClassRef(refinementOK)
-        else NoType
+        if (refinementOK) tp.underlying.underlyingClassRef(refinementOK) else NoType
       case tp: RecType =>
         tp.underlying.underlyingClassRef(refinementOK)
       case _ =>
@@ -3498,8 +3496,8 @@ object Types {
   /** Type bounds >: lo <: hi */
   abstract case class TypeBounds(lo: Type, hi: Type) extends CachedProxyType with TypeType {
 
-    assert(lo.isInstanceOf[TermType])
-    assert(hi.isInstanceOf[TermType])
+    assert(lo.isInstanceOf[TermType], lo)
+    assert(hi.isInstanceOf[TermType], hi)
 
     override def underlying(implicit ctx: Context): Type = hi
 

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

@@ -554,7 +554,7 @@ trait Checking {
       case _ =>
         ctx.error(ex"$tp is not a class type", pos)
         defn.ObjectType
-  }
+    }
 
   /** Check that a non-implicit parameter making up the first parameter section of an
    *  implicit conversion is not a singleton type.

tests/neg/wildbase.scala

@@ -0,0 +1,5 @@
+class A[T]
+
+class B extends A[_] // OK
+
+class C extends A[_ >: Any <: Nothing]  // error: conflicting bounds

tests/pos/andtypes.scala

@@ -0,0 +1,12 @@
+class Outer {
+  type Foo[X]
+}
+
+object Test {
+  def foo[T](x: T) = x
+
+  def bla[A <: Outer, B <: Outer](a: A, b: B) = {
+    val x: a.Foo[Int] & b.Foo[Int] = ???
+    foo(x)
+  }
+}