changes some manual tree constructions in macro tests to quasiquotes

34 files changed, 85 insertions, 100 deletions

diff --git a/test/files/neg/macro-basic-mamdmi.check b/test/files/neg/macro-basic-mamdmi.check
index 9328fbd51c..61df5131cc 100644
--- a/test/files/neg/macro-basic-mamdmi.check
+++ b/test/files/neg/macro-basic-mamdmi.check
@@ -1,4 +1,4 @@
-Impls_Macros_Test_1.scala:36: error: macro implementation not found: quux
+Impls_Macros_Test_1.scala:33: error: macro implementation not found: quux
 (the most common reason for that is that you cannot use macro implementations in the same compilation run that defines them)
   println(foo(2) + Macros.bar(2) * new Macros().quux(4))
                                                     ^
diff --git a/test/files/neg/macro-basic-mamdmi/Impls_Macros_Test_1.scala b/test/files/neg/macro-basic-mamdmi/Impls_Macros_Test_1.scala
index f9e0ca5077..97780ef503 100644
--- a/test/files/neg/macro-basic-mamdmi/Impls_Macros_Test_1.scala
+++ b/test/files/neg/macro-basic-mamdmi/Impls_Macros_Test_1.scala
@@ -3,20 +3,17 @@ import scala.reflect.macros.{Context => Ctx}
 object Impls {
   def foo(c: Ctx)(x: c.Expr[Int]): c.Expr[Int] = {
     import c.universe._
-    val body = Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(1))))
-    c.Expr[Int](body)
+    c.Expr[Int](q"$x + 1")
   }
 
   def bar(c: Ctx)(x: c.Expr[Int]): c.Expr[Int] = {
     import c.universe._
-    val body = Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(2))))
-    c.Expr[Int](body)
+    c.Expr[Int](q"$x + 2")
   }
 
   def quux(c: Ctx)(x: c.Expr[Int]): c.Expr[Int] = {
     import c.universe._
-    val body = Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(3))))
-    c.Expr[Int](body)
+    c.Expr[Int](q"$x + 3")
   }
 }
 
diff --git a/test/files/neg/macro-divergence-controlled/Impls_Macros_1.scala b/test/files/neg/macro-divergence-controlled/Impls_Macros_1.scala
index 9d00780728..3983f590dc 100644
--- a/test/files/neg/macro-divergence-controlled/Impls_Macros_1.scala
+++ b/test/files/neg/macro-divergence-controlled/Impls_Macros_1.scala
@@ -15,7 +15,7 @@ object Complex {
       val recur = c.inferImplicitValue(trecur, silent = true)
       if (recur == EmptyTree) c.abort(c.enclosingPosition, s"couldn't synthesize $trecur")
     }
-    c.Expr[Null](Literal(Constant(null)))
+    c.Expr[Null](q"null")
   }
 
   implicit object ComplexString extends Complex[String]
diff --git a/test/files/neg/macro-invalidimpl/Impls_1.scala b/test/files/neg/macro-invalidimpl/Impls_1.scala
index cf78ecc65a..9f48ab7ad9 100644
--- a/test/files/neg/macro-invalidimpl/Impls_1.scala
+++ b/test/files/neg/macro-invalidimpl/Impls_1.scala
@@ -22,8 +22,7 @@ object Impls5 {
 object Impls6 {
   def fooNullary(c: Context) = {
     import c.universe._
-    val body = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("it works"))))
-    c.Expr[Unit](body)
+    c.Expr[Unit](q"""Predef.println("it works")""")
   }
 
   def fooEmpty(c: Context)() = fooNullary(c)
diff --git a/test/files/neg/macro-invalidshape/Macros_Test_2.scala b/test/files/neg/macro-invalidshape/Macros_Test_2.scala
index ebaa5d9b13..819844b9f1 100644
--- a/test/files/neg/macro-invalidshape/Macros_Test_2.scala
+++ b/test/files/neg/macro-invalidshape/Macros_Test_2.scala
@@ -3,7 +3,7 @@ object Macros {
   def foo2(x: Any) = macro Impls.foo(null)(null)
   def foo3(x: Any) = macro {2; Impls.foo}
   {
-    def impl(c: scala.reflect.macros.Context) = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) }
+    def impl(c: scala.reflect.macros.Context) = { import c.universe._; c.Expr[Unit](q"()") }
     def foo = macro impl
     foo
   }
diff --git a/test/files/neg/macro-invalidsig/Impls_1.scala b/test/files/neg/macro-invalidsig/Impls_1.scala
index 4e2e592024..d16ed26386 100644
--- a/test/files/neg/macro-invalidsig/Impls_1.scala
+++ b/test/files/neg/macro-invalidsig/Impls_1.scala
@@ -2,10 +2,7 @@ import scala.reflect.runtime.universe._
 import scala.reflect.macros.Context
 
 object Impls1 {
-  def foo[U: c.WeakTypeTag: Numeric](c: Context) = {
-    import c.universe._
-    Literal(Constant(42))
-  }
+  def foo[U: c.WeakTypeTag: Numeric](c: Context) = { import c.universe._; q"42" }
 }
 
 object Impls2 {
@@ -28,12 +25,11 @@ object Impls6 {
   def foo[T, U: c.WeakTypeTag](c: Context)(implicit x: c.Expr[Int]) = {
     import c.{prefix => prefix}
     import c.universe._
-    val body = Block(List(
-      Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("invoking foo_targs...")))),
-      Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("type of prefix is: " + prefix.staticType)))),
-      Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("U is: " + implicitly[c.WeakTypeTag[U]].tpe))))),
-      Literal(Constant(())))
-    c.Expr[Unit](body)
+    c.Expr[Unit](q"""
+      println("invoking foo_targs...")
+      println("type of prefix is: " + ${prefix.staticType.toString})
+      println("U is: " + ${implicitly[c.WeakTypeTag[U]].tpe.toString})
+    """)
   }
 }
 
@@ -75,7 +71,7 @@ object Impls15 {
     println(implicitly[c.WeakTypeTag[T]])
     println(implicitly[c.WeakTypeTag[U]])
     println(V)
-    c.Expr[Unit](Literal(Constant(())))
+    c.Expr[Unit](q"()")
   }
 }
 
@@ -85,6 +81,6 @@ object Impls16 {
     println(implicitly[c.WeakTypeTag[T]])
     println(implicitly[c.WeakTypeTag[U]])
     println(V)
-    c.Expr[Unit](Literal(Constant(())))
+    c.Expr[Unit](q"()")
   }
 }
\ No newline at end of file
diff --git a/test/files/neg/macro-invalidusage-badbounds/Impls_1.scala b/test/files/neg/macro-invalidusage-badbounds/Impls_1.scala
index 54229b576c..74c163596a 100644
--- a/test/files/neg/macro-invalidusage-badbounds/Impls_1.scala
+++ b/test/files/neg/macro-invalidusage-badbounds/Impls_1.scala
@@ -1,5 +1,5 @@
 import scala.reflect.macros.{Context => Ctx}
 
 object Impls {
-  def foo[U <: String](c: Ctx) = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) }
+  def foo[U <: String](c: Ctx) = { import c.universe._; c.Expr[Unit](q"()") }
 }
diff --git a/test/files/neg/macro-invalidusage-methodvaluesyntax/Impls_1.scala b/test/files/neg/macro-invalidusage-methodvaluesyntax/Impls_1.scala
index 498bd4f18d..11b6a8c3b0 100644
--- a/test/files/neg/macro-invalidusage-methodvaluesyntax/Impls_1.scala
+++ b/test/files/neg/macro-invalidusage-methodvaluesyntax/Impls_1.scala
@@ -3,7 +3,6 @@ import scala.reflect.macros.{Context => Ctx}
 object Impls {
   def foo(c: Ctx) = {
     import c.universe._
-    val body = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("it works"))))
-    c.Expr[Unit](body)
+    c.Expr[Unit](q"""println("it works")""")
   }
 }
\ No newline at end of file
diff --git a/test/files/neg/macro-invalidusage-presuper/Impls_1.scala b/test/files/neg/macro-invalidusage-presuper/Impls_1.scala
index bae782ef4f..c4b57233c9 100644
--- a/test/files/neg/macro-invalidusage-presuper/Impls_1.scala
+++ b/test/files/neg/macro-invalidusage-presuper/Impls_1.scala
@@ -1,5 +1,5 @@
 import scala.reflect.macros.Context
 
 object Impls {
-  def impl(c: Context) = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) }
+  def impl(c: Context) = { import c.universe._; c.Expr[Unit](q"()") }
 }
\ No newline at end of file
diff --git a/test/files/neg/macro-override-method-overrides-macro/Impls_1.scala b/test/files/neg/macro-override-method-overrides-macro/Impls_1.scala
index 69ef57d18d..64a9299ee6 100644
--- a/test/files/neg/macro-override-method-overrides-macro/Impls_1.scala
+++ b/test/files/neg/macro-override-method-overrides-macro/Impls_1.scala
@@ -4,8 +4,7 @@ object Impls {
   def impl(c: Ctx)(tag: String, x: c.Expr[_]) = {
     import c.{prefix => prefix}
     import c.universe._
-    val body = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant(tag)), Literal(Constant(prefix.toString)), x.tree))
-    c.Expr[Unit](body)
+    c.Expr[Unit](q"println($tag, ${prefix.toString}, $x)")
   }
 
   def fooBString(c: Ctx)(x: c.Expr[_]) = impl(c)("fooBString", x)
diff --git a/test/files/neg/macro-without-xmacros-a/Impls_1.scala b/test/files/neg/macro-without-xmacros-a/Impls_1.scala
index c6677c4fde..868616aace 100644
--- a/test/files/neg/macro-without-xmacros-a/Impls_1.scala
+++ b/test/files/neg/macro-without-xmacros-a/Impls_1.scala
@@ -3,16 +3,16 @@ import scala.reflect.macros.{Context => Ctx}
 object Impls {
   def foo_impl(c: Ctx)(x: c.Expr[Int]): c.Expr[Int] = {
     import c.universe._
-    c.Expr(Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(1)))))
+    c.Expr(q"$x + 1")
   }
 
   def bar_impl(c: Ctx)(x: c.Expr[Int]): c.Expr[Int] = {
     import c.universe._
-    c.Expr(Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(2)))))
+    c.Expr(q"$x + 2")
   }
 
   def quux_impl(c: Ctx)(x: c.Expr[Int]): c.Expr[Int] = {
     import c.universe._
-    c.Expr(Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(3)))))
+    c.Expr(q"$x + 3")
   }
 }
\ No newline at end of file
diff --git a/test/files/neg/macro-without-xmacros-b/Impls_1.scala b/test/files/neg/macro-without-xmacros-b/Impls_1.scala
index c6677c4fde..868616aace 100644
--- a/test/files/neg/macro-without-xmacros-b/Impls_1.scala
+++ b/test/files/neg/macro-without-xmacros-b/Impls_1.scala
@@ -3,16 +3,16 @@ import scala.reflect.macros.{Context => Ctx}
 object Impls {
   def foo_impl(c: Ctx)(x: c.Expr[Int]): c.Expr[Int] = {
     import c.universe._
-    c.Expr(Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(1)))))
+    c.Expr(q"$x + 1")
   }
 
   def bar_impl(c: Ctx)(x: c.Expr[Int]): c.Expr[Int] = {
     import c.universe._
-    c.Expr(Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(2)))))
+    c.Expr(q"$x + 2")
   }
 
   def quux_impl(c: Ctx)(x: c.Expr[Int]): c.Expr[Int] = {
     import c.universe._
-    c.Expr(Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(3)))))
+    c.Expr(q"$x + 3")
   }
 }
\ No newline at end of file
diff --git a/test/files/neg/t7157/Impls_Macros_1.scala b/test/files/neg/t7157/Impls_Macros_1.scala
index 625c2501e6..9069d26e6e 100644
--- a/test/files/neg/t7157/Impls_Macros_1.scala
+++ b/test/files/neg/t7157/Impls_Macros_1.scala
@@ -2,30 +2,30 @@ import scala.reflect.macros.Context
 import language.experimental.macros
 
 object Macros {
-  def impl1_0_0(c: Context)() = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) }
-  def impl1_1_1(c: Context)(x: c.Expr[Int]) = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) }
-  def impl1_2_2(c: Context)(x: c.Expr[Int], y: c.Expr[Int]) = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) }
+  def impl1_0_0(c: Context)() = { import c.universe._; c.Expr[Unit](q"()") }
+  def impl1_1_1(c: Context)(x: c.Expr[Int]) = { import c.universe._; c.Expr[Unit](q"()") }
+  def impl1_2_2(c: Context)(x: c.Expr[Int], y: c.Expr[Int]) = { import c.universe._; c.Expr[Unit](q"()") }
   def m1_0_0() = macro impl1_0_0
   def m1_1_1(x: Int) = macro impl1_1_1
   def m1_2_2(x: Int, y: Int) = macro impl1_2_2
 
-  def impl1_0_inf(c: Context)(x: c.Expr[Int]*) = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) }
-  def impl1_1_inf(c: Context)(x: c.Expr[Int], y: c.Expr[Int]*) = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) }
-  def impl1_2_inf(c: Context)(x: c.Expr[Int], y: c.Expr[Int], z: c.Expr[Int]*) = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) }
+  def impl1_0_inf(c: Context)(x: c.Expr[Int]*) = { import c.universe._; c.Expr[Unit](q"()") }
+  def impl1_1_inf(c: Context)(x: c.Expr[Int], y: c.Expr[Int]*) = { import c.universe._; c.Expr[Unit](q"()") }
+  def impl1_2_inf(c: Context)(x: c.Expr[Int], y: c.Expr[Int], z: c.Expr[Int]*) = { import c.universe._; c.Expr[Unit](q"()") }
   def m1_0_inf(x: Int*) = macro impl1_0_inf
   def m1_1_inf(x: Int, y: Int*) = macro impl1_1_inf
   def m1_2_inf(x: Int, y: Int, z: Int*) = macro impl1_2_inf
 
-  def impl2_0_0(c: Context)()() = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) }
-  def impl2_1_1(c: Context)()(x: c.Expr[Int]) = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) }
-  def impl2_2_2(c: Context)()(x: c.Expr[Int], y: c.Expr[Int]) = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) }
+  def impl2_0_0(c: Context)()() = { import c.universe._; c.Expr[Unit](q"()") }
+  def impl2_1_1(c: Context)()(x: c.Expr[Int]) = { import c.universe._; c.Expr[Unit](q"()") }
+  def impl2_2_2(c: Context)()(x: c.Expr[Int], y: c.Expr[Int]) = { import c.universe._; c.Expr[Unit](q"()") }
   def m2_0_0()() = macro impl2_0_0
   def m2_1_1()(x: Int) = macro impl2_1_1
   def m2_2_2()(x: Int, y: Int) = macro impl2_2_2
 
-  def impl2_0_inf(c: Context)()(x: c.Expr[Int]*) = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) }
-  def impl2_1_inf(c: Context)()(x: c.Expr[Int], y: c.Expr[Int]*) = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) }
-  def impl2_2_inf(c: Context)()(x: c.Expr[Int], y: c.Expr[Int], z: c.Expr[Int]*) = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) }
+  def impl2_0_inf(c: Context)()(x: c.Expr[Int]*) = { import c.universe._; c.Expr[Unit](q"()") }
+  def impl2_1_inf(c: Context)()(x: c.Expr[Int], y: c.Expr[Int]*) = { import c.universe._; c.Expr[Unit](q"()") }
+  def impl2_2_inf(c: Context)()(x: c.Expr[Int], y: c.Expr[Int], z: c.Expr[Int]*) = { import c.universe._; c.Expr[Unit](q"()") }
   def m2_0_inf()(x: Int*) = macro impl2_0_inf
   def m2_1_inf()(x: Int, y: Int*) = macro impl2_1_inf
   def m2_2_inf()(x: Int, y: Int, z: Int*) = macro impl2_2_inf
diff --git a/test/files/pos/annotated-treecopy/Impls_Macros_1.scala b/test/files/pos/annotated-treecopy/Impls_Macros_1.scala
index 407d0b4bf3..9b7af0c3b8 100644
--- a/test/files/pos/annotated-treecopy/Impls_Macros_1.scala
+++ b/test/files/pos/annotated-treecopy/Impls_Macros_1.scala
@@ -38,10 +38,10 @@ object Macros {
         val reifiedExpr = c.Expr[scala.reflect.runtime.universe.Expr[T => U]](reifiedTree)
         val template =
           c.universe.reify(new (T => U) with TypedFunction {
-            override def toString = c.Expr[String](Literal(Constant(tp+" => "+ttag.tpe+" { "+b1.toString+" } "))).splice // DEBUG
+            override def toString = c.Expr[String](q"""${tp+" => "+ttag.tpe+" { "+b1.toString+" } "}""").splice // DEBUG
             def tree = reifiedExpr.splice.tree
-            val typeIn = c.Expr[String](Literal(Constant((tp.toString)))).splice
-            val typeOut = c.Expr[String](Literal(Constant((ttag.tpe.toString)))).splice
+            val typeIn = c.Expr[String](q"${tp.toString}").splice
+            val typeOut = c.Expr[String](q"${ttag.tpe.toString}").splice
             def apply(_arg: T): U = c.Expr[U](b1)(ttag.asInstanceOf[c.WeakTypeTag[U]]).splice
           })
         val untyped = c.resetLocalAttrs(template.tree)
diff --git a/test/files/pos/t5692a/Macros_1.scala b/test/files/pos/t5692a/Macros_1.scala
index fa3a0bcf32..e530713bb0 100644
--- a/test/files/pos/t5692a/Macros_1.scala
+++ b/test/files/pos/t5692a/Macros_1.scala
@@ -1,6 +1,6 @@
 import scala.reflect.macros.Context
 
 object Macros {
-  def impl[T](c: Context) = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) }
+  def impl[T](c: Context) = { import c.universe._; c.Expr[Unit](q"()") }
   def foo[T] = macro impl[T]
 }
\ No newline at end of file
diff --git a/test/files/pos/t5692b/Macros_1.scala b/test/files/pos/t5692b/Macros_1.scala
index 12108cfefa..45c672cfce 100644
--- a/test/files/pos/t5692b/Macros_1.scala
+++ b/test/files/pos/t5692b/Macros_1.scala
@@ -1,6 +1,6 @@
 import scala.reflect.macros.Context
 
 object Macros {
-  def impl[T, U](c: Context) = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) }
+  def impl[T, U](c: Context) = { import c.universe._; c.Expr[Unit](q"()") }
   def foo[T, U] = macro impl[T, U]
 }
\ No newline at end of file
diff --git a/test/files/pos/t7461/Macros_1.scala b/test/files/pos/t7461/Macros_1.scala
index fdaf33e8c8..8621650f77 100644
--- a/test/files/pos/t7461/Macros_1.scala
+++ b/test/files/pos/t7461/Macros_1.scala
@@ -6,7 +6,7 @@ object Macros {
     import c.universe._
     val wut = c.typeCheck(Select(Literal(Constant(10)), newTermName("$minus")), silent = true)
     // println(showRaw(wut, printIds = true, printTypes = true))
-    c.Expr[Unit](Literal(Constant(())))
+    c.Expr[Unit](q"()")
   }
 
   def foo = macro impl
diff --git a/test/files/pos/t7649.scala b/test/files/pos/t7649.scala
index a1b02f63f1..ff3c626fca 100644
--- a/test/files/pos/t7649.scala
+++ b/test/files/pos/t7649.scala
@@ -4,7 +4,7 @@ object Test {
   reify {
     // The lookup of the implicit WeakTypeTag[Any]
     // was triggering an unpositioned tree.
-    c.Expr[Any](Literal(Constant(0))).splice
+    c.Expr[Any](q"0").splice
   }
 
   import scala.reflect.ClassTag
diff --git a/test/files/run/macro-bundle-repl.check b/test/files/run/macro-bundle-repl.check
index 008db4d7fd..c11c48dc55 100644
--- a/test/files/run/macro-bundle-repl.check
+++ b/test/files/run/macro-bundle-repl.check
@@ -7,13 +7,13 @@ import scala.language.experimental.macros
 scala> import scala.reflect.macros.Macro
 import scala.reflect.macros.Macro
 
-scala> trait Bar extends Macro { def impl = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) } };def bar = macro Bar.impl
+scala> trait Bar extends Macro { def impl = { import c.universe._; c.Expr[Unit](q"()") } };def bar = macro Bar.impl
 defined trait Bar
 defined term macro bar: Unit
 
 scala> bar
 
-scala> trait Foo extends Macro { def impl = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) } }
+scala> trait Foo extends Macro { def impl = { import c.universe._; c.Expr[Unit](q"()") } }
 defined trait Foo
 
 scala> def foo = macro Foo.impl
diff --git a/test/files/run/macro-bundle-repl.scala b/test/files/run/macro-bundle-repl.scala
index 06a6dcd5ce..3171aaacc2 100644
--- a/test/files/run/macro-bundle-repl.scala
+++ b/test/files/run/macro-bundle-repl.scala
@@ -4,9 +4,9 @@ object Test extends ReplTest {
   def code = """
 import scala.language.experimental.macros
 import scala.reflect.macros.Macro
-trait Bar extends Macro { def impl = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) } };def bar = macro Bar.impl
+trait Bar extends Macro { def impl = { import c.universe._; c.Expr[Unit](q"()") } };def bar = macro Bar.impl
 bar
-trait Foo extends Macro { def impl = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) } }
+trait Foo extends Macro { def impl = { import c.universe._; c.Expr[Unit](q"()") } }
 def foo = macro Foo.impl
 foo
   """
diff --git a/test/files/run/macro-bundle-static/Impls_Macros_1.scala b/test/files/run/macro-bundle-static/Impls_Macros_1.scala
index 79597ec4e5..e81fd0dbd6 100644
--- a/test/files/run/macro-bundle-static/Impls_Macros_1.scala
+++ b/test/files/run/macro-bundle-static/Impls_Macros_1.scala
@@ -4,8 +4,8 @@ import scala.language.experimental.macros
 
 object Enclosing {
   trait Impl extends Macro {
-    def mono = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) }
-    def poly[T: c.WeakTypeTag] = { import c.universe._; c.Expr[String](Literal(Constant(c.weakTypeOf[T].toString))) }
+    def mono = { import c.universe._; c.Expr[Unit](q"()") }
+    def poly[T: c.WeakTypeTag] = { import c.universe._; c.Expr[String](q"${c.weakTypeOf[T].toString}") }
     def weird = macro mono
   }
 }
@@ -18,8 +18,8 @@ object Macros {
 package pkg {
   object Enclosing {
     trait Impl extends Macro {
-      def mono = { import c.universe._; c.Expr[Boolean](Literal(Constant(true))) }
-      def poly[T: c.WeakTypeTag] = { import c.universe._; c.Expr[String](Literal(Constant(c.weakTypeOf[T].toString + c.weakTypeOf[T].toString))) }
+      def mono = { import c.universe._; c.Expr[Boolean](q"true") }
+      def poly[T: c.WeakTypeTag] = { import c.universe._; c.Expr[String](q"${c.weakTypeOf[T].toString + c.weakTypeOf[T].toString}") }
       def weird = macro mono
     }
   }
diff --git a/test/files/run/macro-bundle-toplevel/Impls_Macros_1.scala b/test/files/run/macro-bundle-toplevel/Impls_Macros_1.scala
index e17dd6f6e1..8c7df2cdc5 100644
--- a/test/files/run/macro-bundle-toplevel/Impls_Macros_1.scala
+++ b/test/files/run/macro-bundle-toplevel/Impls_Macros_1.scala
@@ -2,8 +2,8 @@ import scala.reflect.macros.Context
 import scala.reflect.macros.Macro
 
 trait Impl extends Macro {
-  def mono = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) }
-  def poly[T: c.WeakTypeTag] = { import c.universe._; c.Expr[String](Literal(Constant(c.weakTypeOf[T].toString))) }
+  def mono = { import c.universe._; c.Expr[Unit](q"()") }
+  def poly[T: c.WeakTypeTag] = { import c.universe._; c.Expr[String](q"${c.weakTypeOf[T].toString}") }
   def weird = macro mono
 }
 
@@ -14,8 +14,8 @@ object Macros {
 
 package pkg {
   trait Impl extends Macro {
-    def mono = { import c.universe._; c.Expr[Boolean](Literal(Constant(true))) }
-    def poly[T: c.WeakTypeTag] = { import c.universe._; c.Expr[String](Literal(Constant(c.weakTypeOf[T].toString + c.weakTypeOf[T].toString))) }
+    def mono = { import c.universe._; c.Expr[Boolean](q"true") }
+    def poly[T: c.WeakTypeTag] = { import c.universe._; c.Expr[String](q"${c.weakTypeOf[T].toString + c.weakTypeOf[T].toString}") }
     def weird = macro mono
   }
 
diff --git a/test/files/run/macro-expand-tparams-bounds/Impls_1.scala b/test/files/run/macro-expand-tparams-bounds/Impls_1.scala
index bb6592615a..d63f034e9b 100644
--- a/test/files/run/macro-expand-tparams-bounds/Impls_1.scala
+++ b/test/files/run/macro-expand-tparams-bounds/Impls_1.scala
@@ -1,12 +1,12 @@
 import scala.reflect.macros.Context
 
 object Impls1 {
-  def foo[U <: String](c: Context): c.Expr[Unit] = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) }
+  def foo[U <: String](c: Context): c.Expr[Unit] = { import c.universe._; c.Expr[Unit](q"()") }
 }
 
 class C
 class D extends C
 
 object Impls2 {
-  def foo[U <: C](c: Context): c.Expr[Unit] = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) }
+  def foo[U <: C](c: Context): c.Expr[Unit] = { import c.universe._; c.Expr[Unit](q"()") }
 }
diff --git a/test/files/run/macro-expand-tparams-prefix/Impls_1.scala b/test/files/run/macro-expand-tparams-prefix/Impls_1.scala
index e92396d1b4..a98c4abe78 100644
--- a/test/files/run/macro-expand-tparams-prefix/Impls_1.scala
+++ b/test/files/run/macro-expand-tparams-prefix/Impls_1.scala
@@ -5,8 +5,7 @@ object Impls1 {
   def foo[U: c.WeakTypeTag](c: Context)(x: c.Expr[U]) = {
     import c.universe._
     val U = implicitly[c.WeakTypeTag[U]]
-    val body = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant(U.toString))))
-    c.Expr[Unit](body)
+    c.Expr[Unit](q"println(${U.toString})")
   }
 }
 
@@ -16,18 +15,18 @@ object Impls2 {
     val T = implicitly[c.WeakTypeTag[T]]
     val U = implicitly[c.WeakTypeTag[U]]
     val body = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant(T.toString + " " + U.toString))))
-    c.Expr[Unit](body)
+    c.Expr[Unit](q"""println(${T.toString} + " " + ${U.toString})""")
   }
 }
 
 object Impls345 {
   def foo[T, U: c.WeakTypeTag, V](c: Context)(implicit T: c.WeakTypeTag[T], V: c.WeakTypeTag[V]): c.Expr[Unit] = {
     import c.universe._
-    c.Expr(Block(List(
-      Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant(T.toString)))),
-      Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant(implicitly[c.WeakTypeTag[U]].toString)))),
-      Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant(V.toString))))),
-      Literal(Constant(()))))
+    c.Expr(q"""
+      println(${T.toString})
+      println(${implicitly[c.WeakTypeTag[U]].toString})
+      println(${V.toString})
+    """)
   }
 }
 
diff --git a/test/files/run/macro-impl-default-params/Impls_Macros_1.scala b/test/files/run/macro-impl-default-params/Impls_Macros_1.scala
index 95d746980e..043675ec00 100644
--- a/test/files/run/macro-impl-default-params/Impls_Macros_1.scala
+++ b/test/files/run/macro-impl-default-params/Impls_Macros_1.scala
@@ -6,13 +6,12 @@ object Impls {
     import c.{prefix => prefix}
     import c.universe._
     val U = implicitly[c.WeakTypeTag[U]]
-    val body = Block(List(
-      Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("invoking foo_targs...")))),
-      Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("type of prefix is: " + prefix.staticType)))),
-      Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("type of prefix tree is: " + prefix.tree.tpe)))),
-      Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("U is: " + U.tpe))))),
-      Literal(Constant(())))
-    c.Expr[Unit](body)
+    c.Expr[Unit](q"""
+      println("invoking foo_targs...")
+      println("type of prefix is: " + ${prefix.staticType.toString})
+      println("type of prefix tree is: " + ${prefix.tree.tpe.toString})
+      println("U is: " + ${U.tpe.toString})
+    """)
   }
 }
 
diff --git a/test/files/run/macro-impl-rename-context/Impls_Macros_1.scala b/test/files/run/macro-impl-rename-context/Impls_Macros_1.scala
index 738c88bbc8..5f3bbac719 100644
--- a/test/files/run/macro-impl-rename-context/Impls_Macros_1.scala
+++ b/test/files/run/macro-impl-rename-context/Impls_Macros_1.scala
@@ -3,10 +3,7 @@ import scala.reflect.macros.{Context => Ctx}
 object Impls {
   def foo(unconventionalName: Ctx)(x: unconventionalName.Expr[Int]) = {
     import unconventionalName.universe._
-    val body = Block(List(
-      Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("invoking foo..."))))),
-      Literal(Constant(())))
-    unconventionalName.Expr[Unit](body)
+    unconventionalName.Expr[Unit](q"""println("invoking foo...")""")
   }
 }
 
diff --git a/test/files/run/macro-impl-tparam-only-in-impl/Impls_1.scala b/test/files/run/macro-impl-tparam-only-in-impl/Impls_1.scala
index cbc1b8e539..24eacb36de 100644
--- a/test/files/run/macro-impl-tparam-only-in-impl/Impls_1.scala
+++ b/test/files/run/macro-impl-tparam-only-in-impl/Impls_1.scala
@@ -1,5 +1,5 @@
 import scala.reflect.macros.{Context => Ctx}
 
 object Impls {
-  def foo[U <: String](c: Ctx): c.Expr[Unit] = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) }
+  def foo[U <: String](c: Ctx): c.Expr[Unit] = { import c.universe._; c.Expr[Unit](q"()") }
 }
diff --git a/test/files/run/macro-system-properties.check b/test/files/run/macro-system-properties.check
index 3cbe5b9514..c61fe7f2cf 100644
--- a/test/files/run/macro-system-properties.check
+++ b/test/files/run/macro-system-properties.check
@@ -8,7 +8,7 @@ import reflect.macros.Context
 scala>     object GrabContext {
       def lastContext = Option(System.getProperties.get("lastContext").asInstanceOf[reflect.macros.runtime.Context])
       // System.properties lets you stash true globals (unlike statics which are classloader scoped)
-      def impl(c: Context)() = { import c.universe._; System.getProperties.put("lastContext", c); c.Expr[Unit](Literal(Constant(()))) }
+      def impl(c: Context)() = { import c.universe._; System.getProperties.put("lastContext", c); c.Expr[Unit](q"()") }
       def grab() = macro impl
     }
 defined object GrabContext
diff --git a/test/files/run/macro-system-properties.scala b/test/files/run/macro-system-properties.scala
index 31bcdf2600..9dcd044dbd 100644
--- a/test/files/run/macro-system-properties.scala
+++ b/test/files/run/macro-system-properties.scala
@@ -7,7 +7,7 @@ object Test extends ReplTest {
     object GrabContext {
       def lastContext = Option(System.getProperties.get("lastContext").asInstanceOf[reflect.macros.runtime.Context])
       // System.properties lets you stash true globals (unlike statics which are classloader scoped)
-      def impl(c: Context)() = { import c.universe._; System.getProperties.put("lastContext", c); c.Expr[Unit](Literal(Constant(()))) }
+      def impl(c: Context)() = { import c.universe._; System.getProperties.put("lastContext", c); c.Expr[Unit](q"()") }
       def grab() = macro impl
     }
     object Test { class C(implicit a: Any) { GrabContext.grab } }
diff --git a/test/files/run/repl-term-macros.check b/test/files/run/repl-term-macros.check
index da3c70739e..63bafe401b 100644
--- a/test/files/run/repl-term-macros.check
+++ b/test/files/run/repl-term-macros.check
@@ -9,7 +9,7 @@ import language.experimental.macros
 
 scala> 
 
-scala> def impl1(c: Context) = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) }
+scala> def impl1(c: Context) = { import c.universe._; c.Expr[Unit](q"()") }
 impl1: (c: scala.reflect.macros.Context)c.Expr[Unit]
 
 scala> def foo1 = macro impl1
@@ -19,7 +19,7 @@ scala> foo1
 
 scala> 
 
-scala> def impl2(c: Context)() = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) }
+scala> def impl2(c: Context)() = { import c.universe._; c.Expr[Unit](q"()") }
 impl2: (c: scala.reflect.macros.Context)()c.Expr[Unit]
 
 scala> def foo2() = macro impl2
@@ -29,7 +29,7 @@ scala> foo2()
 
 scala> 
 
-scala> def impl3(c: Context)(x: c.Expr[Int])(y: c.Expr[Int]) = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) }
+scala> def impl3(c: Context)(x: c.Expr[Int])(y: c.Expr[Int]) = { import c.universe._; c.Expr[Unit](q"()") }
 impl3: (c: scala.reflect.macros.Context)(x: c.Expr[Int])(y: c.Expr[Int])c.Expr[Unit]
 
 scala> def foo3(x: Int)(y: Int) = macro impl3
diff --git a/test/files/run/repl-term-macros.scala b/test/files/run/repl-term-macros.scala
index 9824bf49cb..125e397b22 100644
--- a/test/files/run/repl-term-macros.scala
+++ b/test/files/run/repl-term-macros.scala
@@ -5,15 +5,15 @@ object Test extends ReplTest {
   import scala.reflect.macros.Context
 import language.experimental.macros
 
-def impl1(c: Context) = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) }
+def impl1(c: Context) = { import c.universe._; c.Expr[Unit](q"()") }
 def foo1 = macro impl1
 foo1
 
-def impl2(c: Context)() = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) }
+def impl2(c: Context)() = { import c.universe._; c.Expr[Unit](q"()") }
 def foo2() = macro impl2
 foo2()
 
-def impl3(c: Context)(x: c.Expr[Int])(y: c.Expr[Int]) = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) }
+def impl3(c: Context)(x: c.Expr[Int])(y: c.Expr[Int]) = { import c.universe._; c.Expr[Unit](q"()") }
 def foo3(x: Int)(y: Int) = macro impl3
 foo3(2)(3)
   """
diff --git a/test/files/run/t5894.scala b/test/files/run/t5894.scala
index 8da4aa8523..5deda34489 100644
--- a/test/files/run/t5894.scala
+++ b/test/files/run/t5894.scala
@@ -4,7 +4,7 @@ class Test
 
 object Test {
   def foo = macro fooImpl
-  def fooImpl(c: reflect.macros.Context) = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) }
+  def fooImpl(c: reflect.macros.Context) = { import c.universe._; c.Expr[Unit](q"()") }
 
   def main(args: Array[String]) {
     try {
diff --git a/test/files/run/t5940.scala b/test/files/run/t5940.scala
index 54aaf88684..9c8f702c68 100644
--- a/test/files/run/t5940.scala
+++ b/test/files/run/t5940.scala
@@ -7,12 +7,12 @@ object Test extends DirectTest {
     import scala.reflect.macros.Context
 
     object Impls {
-      def impl(c: Context) = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) }
+      def impl(c: Context) = { import c.universe._; c.Expr[Unit](q"()") }
     }
 
     object Macros {
       //import Impls._
-      def impl(c: Context) = { import c.universe._; c.Expr[Unit](Literal(Constant(()))) }
+      def impl(c: Context) = { import c.universe._; c.Expr[Unit](q"()") }
       def foo = macro impl
     }
   """
diff --git a/test/files/run/t6199-toolbox.scala b/test/files/run/t6199-toolbox.scala
index 89015f5878..6ba5e50f66 100644
--- a/test/files/run/t6199-toolbox.scala
+++ b/test/files/run/t6199-toolbox.scala
@@ -4,5 +4,5 @@ import scala.tools.reflect.ToolBox
 
 object Test extends App {
   val tb = cm.mkToolBox()
-  println(tb.eval(Literal(Constant(()))))
+  println(tb.eval(q"()"))
 }
\ No newline at end of file