Merge pull request #1930 from aztek/ticket/5824

SI-5824 Fix crashes in reify with _*

5 files changed, 25 insertions, 5 deletions

diff --git a/src/compiler/scala/reflect/reify/codegen/GenTrees.scala b/src/compiler/scala/reflect/reify/codegen/GenTrees.scala
index f60089c935..fd3673552b 100644
--- a/src/compiler/scala/reflect/reify/codegen/GenTrees.scala
+++ b/src/compiler/scala/reflect/reify/codegen/GenTrees.scala
@@ -177,7 +177,7 @@ trait GenTrees {
       // then we can reify the scrutinee as a symless AST and that will definitely be hygienic
       // why? because then typechecking of a scrutinee doesn't depend on the environment external to the quasiquote
       // otherwise we need to reify the corresponding type
-      if (sym.isLocalToReifee || tpe.isLocalToReifee)
+      if (tree.symbol.isLocalToReifee || tree.tpe.isLocalToReifee || treeInfo.isWildcardStarType(tree))
         reifyProduct(tree)
       else {
         if (reifyDebug) println("reifying bound type %s (underlying type is %s)".format(sym, tpe))
diff --git a/src/compiler/scala/reflect/reify/phases/Reshape.scala b/src/compiler/scala/reflect/reify/phases/Reshape.scala
index 5dd5f08b45..71fe4ddeea 100644
--- a/src/compiler/scala/reflect/reify/phases/Reshape.scala
+++ b/src/compiler/scala/reflect/reify/phases/Reshape.scala
@@ -187,8 +187,12 @@ trait Reshape {
     }
 
     private def toPreTyperTypedOrAnnotated(tree: Tree): Tree = tree match {
-      case ty @ Typed(expr1, tt @ TypeTree()) =>
+      case ty @ Typed(expr1, tpt) =>
         if (reifyDebug) println("reify typed: " + tree)
+        val original = tpt match {
+          case tt @ TypeTree() => tt.original
+          case tpt => tpt
+        }
         val annotatedArg = {
           def loop(tree: Tree): Tree = tree match {
             case annotated1 @ Annotated(ann, annotated2 @ Annotated(_, _)) => loop(annotated2)
@@ -196,15 +200,15 @@ trait Reshape {
             case _ => EmptyTree
           }
 
-          loop(tt.original)
+          loop(original)
         }
         if (annotatedArg != EmptyTree) {
           if (annotatedArg.isType) {
             if (reifyDebug) println("verdict: was an annotated type, reify as usual")
             ty
           } else {
-            if (reifyDebug) println("verdict: was an annotated value, equivalent is " + tt.original)
-            toPreTyperTypedOrAnnotated(tt.original)
+            if (reifyDebug) println("verdict: was an annotated value, equivalent is " + original)
+            toPreTyperTypedOrAnnotated(original)
           }
         } else {
           if (reifyDebug) println("verdict: wasn't annotated, reify as usual")
diff --git a/src/reflect/scala/reflect/internal/TreeInfo.scala b/src/reflect/scala/reflect/internal/TreeInfo.scala
index 032a4aebef..0a8f1cb9ed 100644
--- a/src/reflect/scala/reflect/internal/TreeInfo.scala
+++ b/src/reflect/scala/reflect/internal/TreeInfo.scala
@@ -412,6 +412,13 @@ abstract class TreeInfo {
     case _                   => false
   }
 
+  /** Is the argument a wildcard star type of the form `_*`?
+   */
+  def isWildcardStarType(tree: Tree): Boolean = tree match {
+    case Ident(tpnme.WILDCARD_STAR) => true
+    case _                          => false
+  }
+
   /** Is this pattern node a catch-all (wildcard or variable) pattern? */
   def isDefaultCase(cdef: CaseDef) = cdef match {
     case CaseDef(pat, EmptyTree, _) => isWildcardArg(pat)
diff --git a/test/files/run/t5824.check b/test/files/run/t5824.check
new file mode 100644
index 0000000000..3774da60e5
--- /dev/null
+++ b/test/files/run/t5824.check
@@ -0,0 +1 @@
+a b c
diff --git a/test/files/run/t5824.scala b/test/files/run/t5824.scala
new file mode 100644
index 0000000000..2ad169e2d1
--- /dev/null
+++ b/test/files/run/t5824.scala
@@ -0,0 +1,8 @@
+import scala.reflect.runtime.universe._
+import scala.tools.reflect.Eval
+
+object Test extends App {
+  reify {
+    println("%s %s %s".format(List("a", "b", "c"): _*))
+  }.eval
+}