Merge pull request #1514 from OlivierBlanvillain/fix-1513

Fix #1513: misaligned by name type parameter type bounds

Author: odersky

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

@@ -2532,8 +2532,8 @@ object Types {
   /** A type for polymorphic methods */
   class PolyType(val paramNames: List[TypeName])(paramBoundsExp: GenericType => List[TypeBounds], resultTypeExp: GenericType => Type)
     extends CachedGroundType with GenericType with MethodOrPoly {
-    val paramBounds = paramBoundsExp(this)
-    val resType = resultTypeExp(this)
+    val paramBounds: List[TypeBounds] = paramBoundsExp(this)
+    val resType: Type = resultTypeExp(this)
     def variances = Nil
 
     protected def computeSignature(implicit ctx: Context) = resultSignature

src/dotty/tools/dotc/transform/PostTyper.scala

@@ -93,7 +93,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer  { thisTran
    *
    *  should behave differently.
    *
-   *     O1.x  should have the same effect as   { println("43"; 42 }
+   *     O1.x  should have the same effect as   { println("43"); 42 }
    *
    *  whereas
    *
@@ -103,10 +103,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer  { thisTran
    *  purity of the prefix unless the selection goes to an inline val.
    */
   private def normalizeTree(tree: Tree)(implicit ctx: Context): Tree = tree match {
-    case tree: TypeTree => tree
-    case TypeApply(fn, args) =>
-      Checking.checkBounds(args, fn.tpe.widen.asInstanceOf[PolyType])
-      tree
+    case _: TypeTree | _: TypeApply => tree
     case _ =>
       if (tree.isType) {
         Checking.typeChecker.traverse(tree)

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

@@ -37,7 +37,7 @@ object Checking {
    *  well as for AppliedTypeTree nodes. Also checks that type arguments to
    *  *-type parameters are fully applied.
    */
-  def checkBounds(args: List[tpd.Tree], boundss: List[TypeBounds], instantiate: (Type, List[Type]) => Type)(implicit ctx: Context) = {
+  def checkBounds(args: List[tpd.Tree], boundss: List[TypeBounds], instantiate: (Type, List[Type]) => Type)(implicit ctx: Context): Unit = {
     (args, boundss).zipped.foreach { (arg, bound) =>
       if (!bound.isHK && arg.tpe.isHK)
         ctx.error(ex"missing type parameter(s) for $arg", arg.pos)

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

@@ -323,21 +323,30 @@ trait TypeAssigner {
       case pt: PolyType =>
         val paramNames = pt.paramNames
         if (hasNamedArg(args)) {
-          val argMap = new mutable.HashMap[Name, Type]
+          // Type arguments which are specified by name (immutable after this first loop)
+          val namedArgMap = new mutable.HashMap[Name, Type]
           for (NamedArg(name, arg) <- args)
-            if (argMap.contains(name))
+            if (namedArgMap.contains(name))
               ctx.error("duplicate name", arg.pos)
             else if (!paramNames.contains(name))
               ctx.error(s"undefined parameter name, required: ${paramNames.mkString(" or ")}", arg.pos)
             else
-              argMap(name) = arg.tpe
+              namedArgMap(name) = arg.tpe
+
+          // Holds indexes of non-named typed arguments in paramNames
           val gapBuf = new mutable.ListBuffer[Int]
-          def nextPoly = {
-            val idx = gapBuf.length
+          def nextPoly(idx: Int) = {
+            val newIndex = gapBuf.length
             gapBuf += idx
-            PolyParam(pt, idx)
+            // Re-index unassigned type arguments that remain after transformation
+            PolyParam(pt, newIndex)
+          }
+
+          // Type parameters after naming assignment, conserving paramNames order
+          val normArgs: List[Type] = paramNames.zipWithIndex.map { case (pname, idx) =>
+            namedArgMap.getOrElse(pname, nextPoly(idx))
           }
-          val normArgs = paramNames.map(pname => argMap.getOrElse(pname, nextPoly))
+
           val transform = new TypeMap {
             def apply(t: Type) = t match {
               case PolyParam(`pt`, idx) => normArgs(idx)
@@ -349,19 +358,20 @@ trait TypeAssigner {
           else {
             val gaps = gapBuf.toList
             pt.derivedPolyType(
-              gaps.map(paramNames.filterNot(argMap.contains)),
+              gaps.map(paramNames),
               gaps.map(idx => transform(pt.paramBounds(idx)).bounds),
               resultType1)
           }
         }
         else {
           val argTypes = args.tpes
-          if (sameLength(argTypes, paramNames)|| ctx.phase.prev.relaxedTyping) pt.instantiate(argTypes)
+          if (sameLength(argTypes, paramNames) || ctx.phase.prev.relaxedTyping) pt.instantiate(argTypes)
           else wrongNumberOfArgs(fn.tpe, "type ", pt.paramNames.length, tree.pos)
         }
       case _ =>
         errorType(i"${err.exprStr(fn)} does not take type parameters", tree.pos)
     }
+
     tree.withType(ownType)
   }
 
@@ -385,8 +395,8 @@ trait TypeAssigner {
 
   def assignType(tree: untpd.Closure, meth: Tree, target: Tree)(implicit ctx: Context) =
     tree.withType(
-        if (target.isEmpty) meth.tpe.widen.toFunctionType(tree.env.length)
-        else target.tpe)
+      if (target.isEmpty) meth.tpe.widen.toFunctionType(tree.env.length)
+      else target.tpe)
 
   def assignType(tree: untpd.CaseDef, body: Tree)(implicit ctx: Context) =
     tree.withType(body.tpe)

tests/pos/t1513a.scala

@@ -0,0 +1,36 @@
+object Test {
+  // Heterogeneous lists and natural numbers as defined in shapeless.
+
+  sealed trait HList
+  sealed trait ::[H, T <: HList] extends HList
+  sealed trait HNil extends HList
+
+  sealed trait Nat
+  sealed trait Succ[P <: Nat] extends Nat
+  sealed trait Zero extends Nat
+
+  // Accessor type class to compute the N'th element of an HList L.
+
+  trait Accessor[L <: HList, N <: Nat] { type Out }
+  object Accessor {
+    type Aux[L <: HList, N <: Nat, O] = Accessor[L, N] { type Out = O }
+
+    // (H :: T).At[Zero] = H
+    implicit def caseZero[H, T <: HList]: Aux[H :: T, Zero, H] = ???
+
+    // T.At[N] = O => (H :: T).At[Succ[N]] = O
+    implicit def caseN[H, T <: HList, N <: Nat, O]
+      (implicit a: Aux[T, N, O]): Aux[H :: T, Succ[N], O] = ???
+  }
+
+  case class Proxy[T]()
+
+  def at1[NN <: Nat, OO]              (implicit e: Accessor.Aux[String :: HNil, NN, OO]): OO = ???
+  def at2[NN <: Nat, OO](p: Proxy[NN])(implicit e: Accessor.Aux[String :: HNil, NN, OO]): OO = ???
+
+  // N is fixed by a value
+  at2(Proxy[Zero]): String
+
+  // N is fixed as a type parameter (by name)
+  at1[NN = Zero]: String
+}

tests/pos/t1513b.scala

@@ -0,0 +1,25 @@
+object Test {
+  def f[
+    T1 <: String,
+    T2 <: Int,
+    T3 <: Boolean
+  ](a1: T1, a2: T2, a3: T3) = ()
+
+  f                                          ("", 1, true)
+  f[T1 = String]                             ("", 1, true)
+  f[T2 = Int]                                ("", 1, true)
+  f[T3 = Boolean]                            ("", 1, true)
+  f[T1 = String,  T2 = Int]                  ("", 1, true)
+  f[T1 = String,  T3 = Boolean]              ("", 1, true)
+  f[T2 = Int,     T1 = String]               ("", 1, true)
+  f[T2 = Int,     T3 = Boolean]              ("", 1, true)
+  f[T3 = Boolean, T2 = Int]                  ("", 1, true)
+  f[T3 = Boolean, T1 = String]               ("", 1, true)
+  f[T1 = String,  T2 = Int,     T3 = Boolean]("", 1, true)
+  f[T1 = String,  T3 = Boolean, T2 = Int]    ("", 1, true)
+  f[T2 = Int,     T1 = String,  T3 = Boolean]("", 1, true)
+  f[T2 = Int,     T3 = Boolean, T1 = String] ("", 1, true)
+  f[T3 = Boolean, T1 = String,  T2 = Int]    ("", 1, true)
+  f[T3 = Boolean, T2 = Int,     T1 = String] ("", 1, true)
+  f[String,       Int,          Boolean]     ("", 1, true)
+}