SI-6187 Make partial functions re-typable

 - `New(tpe)` doesn't survive a `resetAttrs` / typecheck; use
   a name instead.
 - Abandon the tree attachment that passed the default
   case from `typer` to `patmat`; this tree eluded the
   attribute reset performed in the macro. Instead, add it
   to the match. Apart from making the tree re-typable, it
   also exposes the true code structure to macros, which
   is important if they need to perform other code
   transformations.
 - Install original trees on the declared types of the
   parameters of the `applyOrElse` method to ensure that
   references to them within the method pick up the correct
   type parameter skolems upon retypechecking.
 - Propagate `TypeTree#original` through `copyAttrs`,
   which is called during tree duplication / `TreeCopiers`.
   Without this, the original trees that we installed were
   not visible anymore during `ResetAttrs`.

We are not able to reify partial functions yet -- the
particular sticking point is reification of the parentage
which is only available in the `ClassInfoType`.

1 files changed, 32 insertions, 0 deletions

diff --git a/test/files/run/t6187.check b/test/files/run/t6187.check
new file mode 100644
index 0000000000..c0ca02923b
--- /dev/null
+++ b/test/files/run/t6187.check
@@ -0,0 +1,32 @@
+Type in expressions to have them evaluated.
+Type :help for more information.
+
+scala> import language.experimental.macros, reflect.macros.Context
+import language.experimental.macros
+import reflect.macros.Context
+
+scala> def macroImpl[T: c.WeakTypeTag](c: Context)(t: c.Expr[T]): c.Expr[List[T]] = {
+  val r = c.universe.reify { List(t.splice) }
+  c.Expr[List[T]]( c.resetLocalAttrs(r.tree) )
+}
+macroImpl: [T](c: scala.reflect.macros.Context)(t: c.Expr[T])(implicit evidence$1: c.WeakTypeTag[T])c.Expr[List[T]]
+
+scala> def demo[T](t: T): List[T] = macro macroImpl[T]
+demo: [T](t: T)List[T]
+
+scala> def m[T](t: T): List[List[T]] =
+  demo( List((t,true)) collect { case (x,true) => x } )
+m: [T](t: T)List[List[T]]
+
+scala> m(List(1))
+res0: List[List[List[Int]]] = List(List(List(1)))
+
+scala> // Showing we haven't added unreachable warnings
+
+scala> List(1) collect { case x => x }
+res1: List[Int] = List(1)
+
+scala> List("") collect { case x => x }
+res2: List[String] = List("")
+
+scala>