Uncurry messing up types (tracking Scala bugs SI-9442 and SI-9475)

[VladUreche]

sun@sun-cpu:~/workspace/dev/miniboxing-plugin/sandbox(wip)$ cat macros.scala
import scala.reflect.macros.Context
import scala.language.experimental.macros
import scala.annotation.{Annotation, StaticAnnotation}

object Macros {
  private def solveSequence(context: Context)(v: context.mirror.universe.ValDef, typeMappings: Map[context.Name, List[context.Type]]):(context.Name, Map[context.Type, context.Tree]) = {
    import context.mirror.universe._
    val x = v.mods.annotations.collectFirst{
      case x@q"new expand.sequence[${Ident(nme2)}](...$args)"  =>
        if( args.flatten.length != typeMappings(nme2).length) {
          context.error(x.pos, s"@sequence arguments list does not match the expand.args for $nme2")
        }
        val predef = context.mirror.staticModule("scala.Predef").asModule
        val missing = Select(Ident(predef), newTermName("???"))
        nme2 -> (typeMappings(nme2) zip args.flatten).toMap.withDefaultValue(missing)
    }
    x.get
  }
}
sun@sun-cpu:~/workspace/dev/miniboxing-plugin/sandbox(wip)$ mb-scalac macros.scala 
Picked up _JAVA_OPTIONS: -Xms2g -Xmx2g -Xss4m -XX:+CMSClassUnloadingEnabled -XX:MaxPermSize=512M -XX:ReservedCodeCacheSize=256m -XX:PermSize=256m -XX:+TieredCompilation -XX:+UseNUMA
macros.scala:15: error: type arguments [context.universe.Type,context.mirror.universe.Tree,List[(context.universe.Type, context.mirror.universe.Tree)]] do not conform to method zip's type parameter bounds [A1 >: context.universe.Type,B,That]
        nme2 -> (typeMappings(nme2) zip args.flatten).toMap.withDefaultValue(missing)
                                    ^
macros.scala:15: error: type arguments [context.mirror.universe.Tree] do not conform to method withDefaultValue's type parameter bounds [B1 >: B]
        nme2 -> (typeMappings(nme2) zip args.flatten).toMap.withDefaultValue(missing)
                                                            ^
error: java.lang.AssertionError: assertion failed: Stupid node: typeMappings$1.apply(nme2).zip[context.universe.Type, context.mirror.universe.Tree, List[(context.universe.Type, context.mirror.universe.Tree)]]  false  false
    at scala.tools.nsc.Global.assert(Global.scala:262)
    at miniboxing.plugin.transform.prepare.PrepareTreeTransformer$PreparePhaseImpl$$anonfun$apply$1.apply(MiniboxPrepareTreeTransformer.scala:31)
    at miniboxing.plugin.transform.prepare.PrepareTreeTransformer$PreparePhaseImpl$$anonfun$apply$1.apply(MiniboxPrepareTreeTransformer.scala:31)
    at scala.reflect.internal.Trees$ForeachTreeTraverser.traverse(Trees.scala:1641)
    at scala.reflect.internal.Trees$ForeachTreeTraverser.traverse(Trees.scala:1639)
    at scala.reflect.internal.Trees$class.traverseComponents$1(Trees.scala:1283)
    at scala.reflect.internal.Trees$class.itraverse(Trees.scala:1330)
    at scala.reflect.internal.SymbolTable.itraverse(SymbolTable.scala:16)
    at scala.reflect.internal.SymbolTable.itraverse(SymbolTable.scala:16)
    at scala.reflect.api.Trees$Traverser.traverse(Trees.scala:2475)
    at scala.reflect.internal.Trees$ForeachTreeTraverser.traverse(Trees.scala:1642)
    at scala.reflect.internal.Trees$ForeachTreeTraverser.traverse(Trees.scala:1639)
    at scala.reflect.internal.Trees$class.traverseComponents$1(Trees.scala:1294)

[VladUreche]

Reduced to:

$ cat macros.scala 
trait Ctx {
  trait Tree
}
trait Lst[+A] {
  def zip[A1 >: A, B](that: Lst[B]): Nothing
}
object Test {
  def foo(c: Ctx)(l: Lst[c.Tree]) = l zip l
}

$ mb-scalac macros.scala
macros.scala:10: error: type arguments [c.Tree,c.Tree] do not conform to method zip's type parameter bounds [A1 >: Ctx#Tree,B]
  def foo(c: Ctx)(l: Lst[c.Tree]) = l zip l
                                      ^
one error found

[VladUreche]

Thank you uncurry. Thank you Scala test suite. Thank you Scala 👎 👎 👎 👎

Here's the incorrect translation in uncurry, which nobody in the Scala pipeline seems to mind:

    def foo(c: Ctx, l: Lst[Ctx#Tree]): Nothing = {
      <synthetic> val l$1: Lst[Ctx#Tree] = l.asInstanceOf[Lst[Ctx#Tree]]();
      l$1.zip[c.Tree, c.Tree](l$1)
    }

Except for miniboxing, of course :(

Here's the full output:

$ scalac macros.scala -Xprint:uncurry -Ycheck:uncurry
[[syntax trees at end of                   uncurry]] // macros.scala
package scala {
  abstract trait Ctx extends Object {
    abstract trait Tree extends Object
  };
  abstract trait Lst[+A] extends Object {
    def zip[A1 >: A, B](that: Lst[B]): Nothing
  };
  object Test extends Object {
    def foo(c: Ctx, l: Lst[Ctx#Tree]): Nothing = {
      <synthetic> val l$1: Lst[Ctx#Tree] = l.asInstanceOf[Lst[Ctx#Tree]]();
      l$1.zip[c.Tree, c.Tree](l$1)
    }
  }
}

[Now checking: uncurry]

[VladUreche]

I'll write my own propagator one of these days...

[VladUreche]

This will be addressed in the 2.11.8 release (patch was merged), so there are three things left to be done:

• bump Scala version in the plugin once 2.11.8 is released
• warning for users (advising them to stay away from 2.10 and 2.11s below 2.11.8)
• confirmation test

[VladUreche]

Also: https://issues.scala-lang.org/browse/SI-9475