227 files changed, 660 insertions, 597 deletions

diff --git a/test/files/continuations-neg/function2.check b/test/files/continuations-neg/function2.check
index 82b81c1444..4b1a6227bc 100644
--- a/test/files/continuations-neg/function2.check
+++ b/test/files/continuations-neg/function2.check
@@ -1,6 +1,6 @@
 function2.scala:11: error: type mismatch;
  found   : () => Int
- required: () => Int @util.continuations.cps[Int]
+ required: () => Int @scala.util.continuations.cpsParam[Int,Int]
     val g: () => Int @cps[Int] = f
                                  ^
 one error found
diff --git a/test/files/continuations-neg/t5314-type-error.check b/test/files/continuations-neg/t5314-type-error.check
index 1f4e46a7f2..e66c9d833f 100644
--- a/test/files/continuations-neg/t5314-type-error.check
+++ b/test/files/continuations-neg/t5314-type-error.check
@@ -1,6 +1,6 @@
 t5314-type-error.scala:7: error: type mismatch;
- found   : Int @util.continuations.cps[Int]
- required: Int @util.continuations.cps[String]
+ found   : Int @scala.util.continuations.cpsParam[Int,Int]
+ required: Int @scala.util.continuations.cpsParam[String,String]
   def bar(x:Int): Int @cps[String] = return foo(x)
                                                ^
 one error found
diff --git a/test/files/jvm/annotations.check b/test/files/jvm/annotations.check
index e307f8930d..a8dc5ecdd1 100644
--- a/test/files/jvm/annotations.check
+++ b/test/files/jvm/annotations.check
@@ -29,8 +29,20 @@ public Test4$Foo8(int)
 private int Test4$Foo9.z
 
 @test.SourceAnnotation(mails={bill.gates@bloodsuckers.com}, value=http://eppli.com)
+private int Test4$Foo9.z2
+
+@test.SourceAnnotation(mails={bill.gates@bloodsuckers.com}, value=http://eppli.com)
+private int Test4$Foo9.z3
+
+@test.SourceAnnotation(mails={bill.gates@bloodsuckers.com}, value=http://eppli.com)
 public int Test4$Foo9.getZ()
 
+@test.SourceAnnotation(mails={bill.gates@bloodsuckers.com}, value=http://eppli.com)
+public int Test4$Foo9.getZ2()
+
+@test.SourceAnnotation(mails={bill.gates@bloodsuckers.com}, value=http://eppli.com)
+public int Test4$Foo9.getZ3()
+
 @test.SourceAnnotation(mails={bill.gates@bloodsuckers.com}, value=http://apple.com)
 public int Test4$Foo9.x()
 
diff --git a/test/files/jvm/annotations.scala b/test/files/jvm/annotations.scala
index 66ebde592b..77a45fae89 100644
--- a/test/files/jvm/annotations.scala
+++ b/test/files/jvm/annotations.scala
@@ -101,6 +101,12 @@ object Test4 {
 
     type myAnn = SourceAnnotation @beanGetter @field
     @BeanProperty @myAnn("http://eppli.com") var z = 0
+
+    type myAnn2[T] = SourceAnnotation @beanGetter @field
+    @BeanProperty @myAnn2[String]("http://eppli.com") var z2 = 0
+
+    type myAnn3[CC[_]] = SourceAnnotation @beanGetter @field
+    @BeanProperty @myAnn3[List]("http://eppli.com") var z3 = 0
   }
   class Foo10(@SourceAnnotation("on param 1") val name: String)
   class Foo11(@(SourceAnnotation @scala.annotation.meta.field)("on param 2") val name: String)
diff --git a/test/files/jvm/interpreter.check b/test/files/jvm/interpreter.check
index 6145b6c4d2..477096fb7e 100644
--- a/test/files/jvm/interpreter.check
+++ b/test/files/jvm/interpreter.check
@@ -357,10 +357,8 @@ defined class Term
 scala> def f(e: Exp) = e match {  // non-exhaustive warning here
   case _:Fact => 3
 }
-<console>:18: warning: match is not exhaustive!
-missing combination            Exp
-missing combination           Term
-
+<console>:18: warning: match may not be exhaustive.
+It would fail on the following inputs: Exp(), Term()
        def f(e: Exp) = e match {  // non-exhaustive warning here
                        ^
 f: (e: Exp)Int
diff --git a/test/files/jvm/interpreter.scala b/test/files/jvm/interpreter.scala
index f45eb034a9..bd1851053f 100644
--- a/test/files/jvm/interpreter.scala
+++ b/test/files/jvm/interpreter.scala
@@ -2,7 +2,7 @@ import scala.tools.nsc._
 import scala.tools.partest.ReplTest
 
 object Test extends ReplTest {
-  override def extraSettings = "-deprecation -Xoldpatmat"
+  override def extraSettings = "-deprecation"
   def code = <code>
 // basics
 3+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 908438cf65..f9e0ca5077 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,19 +3,19 @@ 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, newTermName("$plus")), List(Literal(Constant(1))))
+    val body = Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(1))))
     c.Expr[Int](body)
   }
 
   def bar(c: Ctx)(x: c.Expr[Int]): c.Expr[Int] = {
     import c.universe._
-    val body = Apply(Select(x.tree, newTermName("$plus")), List(Literal(Constant(2))))
+    val body = Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(2))))
     c.Expr[Int](body)
   }
 
   def quux(c: Ctx)(x: c.Expr[Int]): c.Expr[Int] = {
     import c.universe._
-    val body = Apply(Select(x.tree, newTermName("$plus")), List(Literal(Constant(3))))
+    val body = Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(3))))
     c.Expr[Int](body)
   }
 }
diff --git a/test/files/neg/macro-invalidimpl-f/Impls_1.scala b/test/files/neg/macro-invalidimpl-f/Impls_1.scala
index 334ee714be..0e4da86d22 100644
--- a/test/files/neg/macro-invalidimpl-f/Impls_1.scala
+++ b/test/files/neg/macro-invalidimpl-f/Impls_1.scala
@@ -3,7 +3,7 @@ import scala.reflect.macros.{Context => Ctx}
 object Impls {
   def fooNullary(c: Ctx) = {
     import c.universe._
-    val body = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("it works"))))
+    val body = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("it works"))))
     c.Expr[Unit](body)
   }
 
diff --git a/test/files/neg/macro-invalidimpl-g/Impls_1.scala b/test/files/neg/macro-invalidimpl-g/Impls_1.scala
index 334ee714be..0e4da86d22 100644
--- a/test/files/neg/macro-invalidimpl-g/Impls_1.scala
+++ b/test/files/neg/macro-invalidimpl-g/Impls_1.scala
@@ -3,7 +3,7 @@ import scala.reflect.macros.{Context => Ctx}
 object Impls {
   def fooNullary(c: Ctx) = {
     import c.universe._
-    val body = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("it works"))))
+    val body = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("it works"))))
     c.Expr[Unit](body)
   }
 
diff --git a/test/files/neg/macro-invalidsig-implicit-params/Impls_Macros_1.scala b/test/files/neg/macro-invalidsig-implicit-params/Impls_Macros_1.scala
index 7a7293422e..8205694768 100644
--- a/test/files/neg/macro-invalidsig-implicit-params/Impls_Macros_1.scala
+++ b/test/files/neg/macro-invalidsig-implicit-params/Impls_Macros_1.scala
@@ -6,9 +6,9 @@ object Impls {
     import c.{prefix => prefix}
     import c.universe._
     val body = Block(List(
-      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("invoking foo_targs...")))),
-      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("type of prefix is: " + prefix.staticType)))),
-      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("U is: " + implicitly[c.WeakTypeTag[U]].tpe))))),
+      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)
   }
diff --git a/test/files/neg/macro-invalidusage-methodvaluesyntax/Impls_1.scala b/test/files/neg/macro-invalidusage-methodvaluesyntax/Impls_1.scala
index 8d7fdf3e8a..498bd4f18d 100644
--- a/test/files/neg/macro-invalidusage-methodvaluesyntax/Impls_1.scala
+++ b/test/files/neg/macro-invalidusage-methodvaluesyntax/Impls_1.scala
@@ -3,7 +3,7 @@ import scala.reflect.macros.{Context => Ctx}
 object Impls {
   def foo(c: Ctx) = {
     import c.universe._
-    val body = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("it works"))))
+    val body = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("it works"))))
     c.Expr[Unit](body)
   }
 }
\ 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 ec93dd4111..69ef57d18d 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,7 +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), newTermName("println")), List(Literal(Constant(tag)), Literal(Constant(prefix.toString)), x.tree))
+    val body = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant(tag)), Literal(Constant(prefix.toString)), x.tree))
     c.Expr[Unit](body)
   }
 
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 8976f8e28d..c6677c4fde 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, newTermName("$plus")), List(Literal(Constant(1)))))
+    c.Expr(Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(1)))))
   }
 
   def bar_impl(c: Ctx)(x: c.Expr[Int]): c.Expr[Int] = {
     import c.universe._
-    c.Expr(Apply(Select(x.tree, newTermName("$plus")), List(Literal(Constant(2)))))
+    c.Expr(Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(2)))))
   }
 
   def quux_impl(c: Ctx)(x: c.Expr[Int]): c.Expr[Int] = {
     import c.universe._
-    c.Expr(Apply(Select(x.tree, newTermName("$plus")), List(Literal(Constant(3)))))
+    c.Expr(Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(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 8976f8e28d..c6677c4fde 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, newTermName("$plus")), List(Literal(Constant(1)))))
+    c.Expr(Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(1)))))
   }
 
   def bar_impl(c: Ctx)(x: c.Expr[Int]): c.Expr[Int] = {
     import c.universe._
-    c.Expr(Apply(Select(x.tree, newTermName("$plus")), List(Literal(Constant(2)))))
+    c.Expr(Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(2)))))
   }
 
   def quux_impl(c: Ctx)(x: c.Expr[Int]): c.Expr[Int] = {
     import c.universe._
-    c.Expr(Apply(Select(x.tree, newTermName("$plus")), List(Literal(Constant(3)))))
+    c.Expr(Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(3)))))
   }
 }
\ No newline at end of file
diff --git a/test/files/neg/override-object-no.check b/test/files/neg/override-object-no.check
index 52bad2b937..9cfda80fc3 100644
--- a/test/files/neg/override-object-no.check
+++ b/test/files/neg/override-object-no.check
@@ -6,8 +6,8 @@ an overriding object must conform to the overridden object's class bound;
                     ^
 override-object-no.scala:21: error: overriding object Bar in trait Quux1 with object Bar in trait Quux2:
 an overriding object must conform to the overridden object's class bound;
- found   : Object{def g: String}
- required: Object{def g: Int}
+ found   : AnyRef{def g: String}
+ required: AnyRef{def g: Int}
   trait Quux2 extends Quux1 { override object Bar { def g = "abc" } } // err
                                               ^
 override-object-no.scala:25: error: overriding object Bar in trait Quux3;
diff --git a/test/files/neg/pat_unreachable.check b/test/files/neg/pat_unreachable.check
index c5706b7fad..b4c0e7e104 100644
--- a/test/files/neg/pat_unreachable.check
+++ b/test/files/neg/pat_unreachable.check
@@ -1,13 +1,14 @@
-pat_unreachable.scala:5: error: unreachable code
-    case Seq(x, y, z, w) => List(z,w) // redundant!
-                                ^
-pat_unreachable.scala:9: error: unreachable code
-    case Seq(x, y) => List(x, y)
-                          ^
-pat_unreachable.scala:23: error: unreachable code
+pat_unreachable.scala:22: warning: patterns after a variable pattern cannot match (SLS 8.1.1)
+If you intended to match against parameter b of method contrivedExample, you must use backticks, like: case `b` =>
+    case b => println("matched b")
+         ^
+pat_unreachable.scala:23: warning: unreachable code due to variable pattern 'b' on line 22
+If you intended to match against parameter c of method contrivedExample, you must use backticks, like: case `c` =>
     case c => println("matched c")
                      ^
-pat_unreachable.scala:24: error: unreachable code
+pat_unreachable.scala:24: warning: unreachable code due to variable pattern 'b' on line 22
     case _ => println("matched neither")
                      ^
-four errors found
+error: No warnings can be incurred under -Xfatal-warnings.
+three warnings found
+one error found
diff --git a/test/files/neg/pat_unreachable.flags b/test/files/neg/pat_unreachable.flags
index cb8324a345..85d8eb2ba2 100644
--- a/test/files/neg/pat_unreachable.flags
+++ b/test/files/neg/pat_unreachable.flags
@@ -1 +1 @@
--Xoldpatmat
\ No newline at end of file
+-Xfatal-warnings
diff --git a/test/files/neg/t2078.check b/test/files/neg/t2078.check
index 3cdaa7d27a..00bb323a0b 100644
--- a/test/files/neg/t2078.check
+++ b/test/files/neg/t2078.check
@@ -1,4 +1,4 @@
-t2078.scala:2: error: contravariant type S occurs in covariant position in type => Object{val x: S} of value f
+t2078.scala:2: error: contravariant type S occurs in covariant position in type => AnyRef{val x: S} of value f
   val f  = new { val x = y }
       ^
 one error found
diff --git a/test/files/neg/t2336.check b/test/files/neg/t2336.check
index 983717469c..28acd4d179 100644
--- a/test/files/neg/t2336.check
+++ b/test/files/neg/t2336.check
@@ -1,4 +1,4 @@
-t2336.scala:6: error: type Foo[Int] is not a stable prefix
+t2336.scala:6: error: Foo[Int] is not a legal prefix for a constructor
   new Foo[Int]#Bar(0)
                ^
 one error found
diff --git a/test/files/neg/t3691.check b/test/files/neg/t3691.check
index bdf6c268b2..6a7e13049a 100644
--- a/test/files/neg/t3691.check
+++ b/test/files/neg/t3691.check
@@ -9,7 +9,7 @@ t3691.scala:5: error: type mismatch;
  val c = (new A[String]{}): { type A } // not ok
           ^
 t3691.scala:7: error: type mismatch;
- found   : Object{type A = String}
+ found   : AnyRef{type A = String}
  required: AnyRef{type A[X]}
  val x = (new { type A = String }): { type A[X] } // not ok
           ^
diff --git a/test/files/neg/t3692-new.check b/test/files/neg/t3692-new.check
index 5aa991c105..9b96449930 100644
--- a/test/files/neg/t3692-new.check
+++ b/test/files/neg/t3692-new.check
@@ -7,8 +7,13 @@ t3692-new.scala:15: warning: non-variable type argument Int in type pattern Map[
 t3692-new.scala:16: warning: non-variable type argument Int in type pattern Map[T,Int] is unchecked since it is eliminated by erasure
       case m2: Map[T, Int] => new java.util.HashMap[T, Integer]
                ^
-t3692-new.scala:16: error: unreachable code
-      case m2: Map[T, Int] => new java.util.HashMap[T, Integer]
+t3692-new.scala:15: warning: unreachable code
+      case m1: Map[Int, V] => new java.util.HashMap[Integer, V]
                               ^
-three warnings found
+t3692-new.scala:4: warning: Tester has a main method with parameter type Array[String], but Tester will not be a runnable program.
+  Reason: main method must have exact signature (Array[String])Unit
+object Tester {
+       ^
+error: No warnings can be incurred under -Xfatal-warnings.
+5 warnings found
 one error found
diff --git a/test/files/neg/t3692-new.flags b/test/files/neg/t3692-new.flags
index cb8324a345..85d8eb2ba2 100644
--- a/test/files/neg/t3692-new.flags
+++ b/test/files/neg/t3692-new.flags
@@ -1 +1 @@
--Xoldpatmat
\ No newline at end of file
+-Xfatal-warnings
diff --git a/test/files/neg/t3692-old.check b/test/files/neg/t3692-old.check
deleted file mode 100644
index 9f3ae516aa..0000000000
--- a/test/files/neg/t3692-old.check
+++ /dev/null
@@ -1,14 +0,0 @@
-t3692-old.scala:13: warning: non-variable type argument Int in type pattern Map[Int,Int] is unchecked since it is eliminated by erasure
-      case m0: Map[Int, Int] => new java.util.HashMap[Integer, Integer]
-               ^
-t3692-old.scala:14: warning: non-variable type argument Int in type pattern Map[Int,V] is unchecked since it is eliminated by erasure
-      case m1: Map[Int, V] => new java.util.HashMap[Integer, V]
-               ^
-t3692-old.scala:15: warning: non-variable type argument Int in type pattern Map[T,Int] is unchecked since it is eliminated by erasure
-      case m2: Map[T, Int] => new java.util.HashMap[T, Integer]
-               ^
-t3692-old.scala:15: error: unreachable code
-      case m2: Map[T, Int] => new java.util.HashMap[T, Integer]
-                              ^
-three warnings found
-one error found
diff --git a/test/files/neg/t3692-old.flags b/test/files/neg/t3692-old.flags
deleted file mode 100644
index cb8324a345..0000000000
--- a/test/files/neg/t3692-old.flags
+++ /dev/null
@@ -1 +0,0 @@
--Xoldpatmat
\ No newline at end of file
diff --git a/test/files/neg/t3692-old.scala b/test/files/neg/t3692-old.scala
deleted file mode 100644
index 151535ae94..0000000000
--- a/test/files/neg/t3692-old.scala
+++ /dev/null
@@ -1,19 +0,0 @@
-import java.lang.Integer
-
-object ManifestTester {
-  def main(args: Array[String]) = {
-    val map = Map("John" -> 1, "Josh" -> 2)
-    new ManifestTester().toJavaMap(map)
-  }
-}
-
-class ManifestTester {
-  private final def toJavaMap[T, V](map: Map[T, V])(implicit m1: Manifest[T], m2: Manifest[V]): java.util.Map[_, _] = {
-    map match {
-      case m0: Map[Int, Int] => new java.util.HashMap[Integer, Integer]
-      case m1: Map[Int, V] => new java.util.HashMap[Integer, V]
-      case m2: Map[T, Int] => new java.util.HashMap[T, Integer]
-      case _ => new java.util.HashMap[T, V]
-    }
-  }
-}
\ No newline at end of file
diff --git a/test/files/neg/t4460a.check b/test/files/neg/t4460a.check
new file mode 100644
index 0000000000..b711e7acb1
--- /dev/null
+++ b/test/files/neg/t4460a.check
@@ -0,0 +1,4 @@
+t4460a.scala:6: error: called constructor's definition must precede calling constructor's definition
+  def this() = this() // was binding to Predef.<init> !!
+               ^
+one error found
diff --git a/test/files/neg/t4460a.scala b/test/files/neg/t4460a.scala
new file mode 100644
index 0000000000..0a7a22178d
--- /dev/null
+++ b/test/files/neg/t4460a.scala
@@ -0,0 +1,7 @@
+trait A
+
+class B(val x: Int) {
+  self: A =>
+
+  def this() = this() // was binding to Predef.<init> !!
+}
diff --git a/test/files/neg/t4460b.check b/test/files/neg/t4460b.check
new file mode 100644
index 0000000000..f0e703fd10
--- /dev/null
+++ b/test/files/neg/t4460b.check
@@ -0,0 +1,4 @@
+t4460b.scala:7: error: called constructor's definition must precede calling constructor's definition
+	  def this() = this() // was binding to Predef.<init> !!
+                       ^
+one error found
diff --git a/test/files/neg/t4460b.scala b/test/files/neg/t4460b.scala
new file mode 100644
index 0000000000..1233017dd4
--- /dev/null
+++ b/test/files/neg/t4460b.scala
@@ -0,0 +1,9 @@
+trait A
+
+class Outer() {
+	class B(val x: Int) {
+	  self: A =>
+
+	  def this() = this() // was binding to Predef.<init> !!
+	}
+}
diff --git a/test/files/neg/t4460c.check b/test/files/neg/t4460c.check
new file mode 100644
index 0000000000..4e96711b8b
--- /dev/null
+++ b/test/files/neg/t4460c.check
@@ -0,0 +1,7 @@
+t4460c.scala:4: error: overloaded method constructor B with alternatives:
+  (a: String)B <and>
+  (x: Int)B
+ cannot be applied to ()
+  def this(a: String) = this()
+                        ^
+one error found
diff --git a/test/files/neg/t4460c.scala b/test/files/neg/t4460c.scala
new file mode 100644
index 0000000000..1ae258508e
--- /dev/null
+++ b/test/files/neg/t4460c.scala
@@ -0,0 +1,7 @@
+class B(val x: Int) {
+  self: A =>
+
+  def this(a: String) = this()
+}
+
+class A()
diff --git a/test/files/neg/t4877.check b/test/files/neg/t4877.check
index a4b1e6a50d..5a2413ca8b 100644
--- a/test/files/neg/t4877.check
+++ b/test/files/neg/t4877.check
@@ -1,10 +1,10 @@
 t4877.scala:4: error: type mismatch;
- found   : Object{def bar: Int}
+ found   : AnyRef{def bar: Int}
  required: AnyRef{def bar: String}
   def foo: AnyRef { def bar: String } = new AnyRef { def bar = 42 }
                                         ^
 t4877.scala:6: error: type mismatch;
- found   : Object{def bar(x: Int): String}
+ found   : AnyRef{def bar(x: Int): String}
  required: AnyRef{def bar(x: Int): Int}
   def foo3: AnyRef { def bar(x: Int): Int } = new AnyRef { def bar(x: Int) = "abc" }
                                               ^
@@ -14,7 +14,7 @@ t4877.scala:7: error: type mismatch;
   def foo4: C { def bar(x: Int): Int ; def quux(x: Int): Int } = new C { def bar(x: Int) = 5 }
                                                                  ^
 t4877.scala:17: error: type mismatch;
- found   : Object{type Mom = String; def bar(x: Int): Int; def bippy(): List[Int]}
+ found   : AnyRef{type Mom = String; def bar(x: Int): Int; def bippy(): List[Int]}
  required: B.this.Bippy
     (which expands to)  AnyRef{type Mom; def bar(x: Int): this.Mom; def bippy(): List[this.Mom]}
   val x: Bippy = new AnyRef {
diff --git a/test/files/neg/t5060.check b/test/files/neg/t5060.check
index e71f30ccdb..09b2d9a4b1 100644
--- a/test/files/neg/t5060.check
+++ b/test/files/neg/t5060.check
@@ -1,7 +1,7 @@
-t5060.scala:2: error: covariant type T occurs in contravariant position in type => Object{def contains(x: T): Unit} of value foo0
+t5060.scala:2: error: covariant type T occurs in contravariant position in type => AnyRef{def contains(x: T): Unit} of value foo0
   val foo0 = {
       ^
-t5060.scala:6: error: covariant type T occurs in contravariant position in type => Object{def contains(x: T): Unit} of method foo1
+t5060.scala:6: error: covariant type T occurs in contravariant position in type => AnyRef{def contains(x: T): Unit} of method foo1
   def foo1 = {
       ^
 two errors found
diff --git a/test/files/neg/t5063.check b/test/files/neg/t5063.check
index 84690d0a1d..c6e553c1b5 100644
--- a/test/files/neg/t5063.check
+++ b/test/files/neg/t5063.check
@@ -1,4 +1,4 @@
-t5063.scala:2: error: value + is not a member of Object
+t5063.scala:2: error: value + is not a member of AnyRef
   super.+("")
         ^
 one error found
diff --git a/test/files/neg/t6436.check b/test/files/neg/t6436.check
index ecb28f9100..5cee6fb558 100644
--- a/test/files/neg/t6436.check
+++ b/test/files/neg/t6436.check
@@ -2,8 +2,8 @@ t6436.scala:8: error: type mismatch;
  found   : StringContext
  required: ?{def q: ?}
 Note that implicit conversions are not applicable because they are ambiguous:
- both method foo1 in object quasiquotes of type (ctx: StringContext)Object{def q: Nothing}
- and method foo2 in object quasiquotes of type (ctx: StringContext)Object{def q: Nothing}
+ both method foo1 in object quasiquotes of type (ctx: StringContext)AnyRef{def q: Nothing}
+ and method foo2 in object quasiquotes of type (ctx: StringContext)AnyRef{def q: Nothing}
  are possible conversion functions from StringContext to ?{def q: ?}
   println(q"a")
           ^
diff --git a/test/files/neg/t6436b.check b/test/files/neg/t6436b.check
index b3c2d73739..21ab972b79 100644
--- a/test/files/neg/t6436b.check
+++ b/test/files/neg/t6436b.check
@@ -2,8 +2,8 @@ t6436b.scala:8: error: type mismatch;
  found   : StringContext
  required: ?{def q: ?}
 Note that implicit conversions are not applicable because they are ambiguous:
- both method foo1 in object quasiquotes of type (ctx: StringContext)Object{def q: Nothing}
- and method foo2 in object quasiquotes of type (ctx: StringContext)Object{def q: Nothing}
+ both method foo1 in object quasiquotes of type (ctx: StringContext)AnyRef{def q: Nothing}
+ and method foo2 in object quasiquotes of type (ctx: StringContext)AnyRef{def q: Nothing}
  are possible conversion functions from StringContext to ?{def q: ?}
   println(StringContext("a").q())
                        ^
diff --git a/test/files/neg/t963.check b/test/files/neg/t963.check
index 1f2d0687b3..4dc202c7bd 100644
--- a/test/files/neg/t963.check
+++ b/test/files/neg/t963.check
@@ -5,7 +5,7 @@ t963.scala:17: error: stable identifier required, but Test.this.y4.x found.
   val w4 : y4.x.type = y4.x
               ^
 t963.scala:10: error: type mismatch;
- found   : Object{def x: Integer}
+ found   : AnyRef{def x: Integer}
  required: AnyRef{val x: Integer}
   val y2 : { val x : java.lang.Integer  } = new { def x = new java.lang.Integer(r.nextInt) }
                                             ^
diff --git a/test/files/neg/unreachablechar.check b/test/files/neg/unreachablechar.check
index 58ce1a7e91..121f12a0c7 100644
--- a/test/files/neg/unreachablechar.check
+++ b/test/files/neg/unreachablechar.check
@@ -1,4 +1,9 @@
-unreachablechar.scala:5: error: unreachable code
+unreachablechar.scala:4: warning: patterns after a variable pattern cannot match (SLS 8.1.1)
+    case _ => println("stuff");
+         ^
+unreachablechar.scala:5: warning: unreachable code due to variable pattern on line 4
     case 'f' => println("not stuff?");
                        ^
+error: No warnings can be incurred under -Xfatal-warnings.
+two warnings found
 one error found
diff --git a/test/files/neg/unreachablechar.flags b/test/files/neg/unreachablechar.flags
index 809e9ff2f2..85d8eb2ba2 100644
--- a/test/files/neg/unreachablechar.flags
+++ b/test/files/neg/unreachablechar.flags
@@ -1 +1 @@
- -Xoldpatmat
+-Xfatal-warnings
diff --git a/test/files/pos/t1439.flags b/test/files/pos/t1439.flags
index 1e70f5c5c7..bca57e4785 100644
--- a/test/files/pos/t1439.flags
+++ b/test/files/pos/t1439.flags
@@ -1 +1 @@
--unchecked -Xfatal-warnings -Xoldpatmat -language:higherKinds
+-unchecked -Xfatal-warnings -language:higherKinds
diff --git a/test/files/pos/t6745.scala b/test/files/pos/t6745.scala
new file mode 100644
index 0000000000..2ab8e6d39a
--- /dev/null
+++ b/test/files/pos/t6745.scala
@@ -0,0 +1,4 @@
+class Bar(val i: Int) {
+  self: Any with AnyRef =>
+  def this() = this(0)
+}
diff --git a/test/files/pos/t6846.scala b/test/files/pos/t6846.scala
new file mode 100644
index 0000000000..009566493f
--- /dev/null
+++ b/test/files/pos/t6846.scala
@@ -0,0 +1,28 @@
+object Test {
+  class Arb[_]
+  implicit def foo[M[_], A]: Arb[M[A]] = null
+  foo: Arb[List[Int]]
+  type ListInt = List[Int]
+  foo: Arb[ListInt]
+}
+
+object Test2 {
+  import scala.collection.immutable.List
+
+  class Carb[_]
+  implicit def narrow[N, M[_], A](x: Carb[M[A]])(implicit ev: N <:< M[A]): Carb[N] = null
+  implicit def bar[M[_], A]: Carb[M[A]] = null
+
+  type ListInt = List[Int]
+
+  val x: List[Int] = List(1)
+  val y: ListInt = List(1)
+
+  type ListSingletonX = x.type
+  type ListSingletonY = y.type
+
+  bar: Carb[List[Int]]
+  bar: Carb[ListInt]
+  bar: Carb[ListSingletonX]
+  bar: Carb[ListSingletonY]
+}
diff --git a/test/files/run/existentials-in-compiler.check b/test/files/run/existentials-in-compiler.check
index 4df4b0ca96..0d7a9298b4 100644
--- a/test/files/run/existentials-in-compiler.check
+++ b/test/files/run/existentials-in-compiler.check
@@ -1,156 +1,156 @@
-abstract trait Bippy[A <: AnyRef, B] extends Object
+abstract trait Bippy[A <: AnyRef, B] extends AnyRef
     extest.Bippy[_ <: AnyRef, _]
 
-abstract trait BippyBud[A <: AnyRef, B, C <: List[A]] extends Object
+abstract trait BippyBud[A <: AnyRef, B, C <: List[A]] extends AnyRef
     extest.BippyBud[A,B,C] forSome { A <: AnyRef; B; C <: List[A] }
 
-abstract trait BippyLike[A <: AnyRef, B <: List[A], This <: extest.BippyLike[A,B,This] with extest.Bippy[A,B]] extends Object
+abstract trait BippyLike[A <: AnyRef, B <: List[A], This <: extest.BippyLike[A,B,This] with extest.Bippy[A,B]] extends AnyRef
     extest.BippyLike[A,B,This] forSome { A <: AnyRef; B <: List[A]; This <: extest.BippyLike[A,B,This] with extest.Bippy[A,B] }
 
-abstract trait Contra[-A >: AnyRef, -B] extends Object
+abstract trait Contra[-A >: AnyRef, -B] extends AnyRef
     extest.Contra[_ >: AnyRef, _]
 
-abstract trait ContraLike[-A >: AnyRef, -B >: List[A]] extends Object
+abstract trait ContraLike[-A >: AnyRef, -B >: List[A]] extends AnyRef
     extest.ContraLike[A,B] forSome { -A >: AnyRef; -B >: List[A] }
 
-abstract trait Cov01[+A <: AnyRef, +B] extends Object
+abstract trait Cov01[+A <: AnyRef, +B] extends AnyRef
     extest.Cov01[_ <: AnyRef, _]
 
-abstract trait Cov02[+A <: AnyRef, B] extends Object
+abstract trait Cov02[+A <: AnyRef, B] extends AnyRef
     extest.Cov02[_ <: AnyRef, _]
 
-abstract trait Cov03[+A <: AnyRef, -B] extends Object
+abstract trait Cov03[+A <: AnyRef, -B] extends AnyRef
     extest.Cov03[_ <: AnyRef, _]
 
-abstract trait Cov04[A <: AnyRef, +B] extends Object
+abstract trait Cov04[A <: AnyRef, +B] extends AnyRef
     extest.Cov04[_ <: AnyRef, _]
 
-abstract trait Cov05[A <: AnyRef, B] extends Object
+abstract trait Cov05[A <: AnyRef, B] extends AnyRef
     extest.Cov05[_ <: AnyRef, _]
 
-abstract trait Cov06[A <: AnyRef, -B] extends Object
+abstract trait Cov06[A <: AnyRef, -B] extends AnyRef
     extest.Cov06[_ <: AnyRef, _]
 
-abstract trait Cov07[-A <: AnyRef, +B] extends Object
+abstract trait Cov07[-A <: AnyRef, +B] extends AnyRef
     extest.Cov07[_ <: AnyRef, _]
 
-abstract trait Cov08[-A <: AnyRef, B] extends Object
+abstract trait Cov08[-A <: AnyRef, B] extends AnyRef
     extest.Cov08[_ <: AnyRef, _]
 
-abstract trait Cov09[-A <: AnyRef, -B] extends Object
+abstract trait Cov09[-A <: AnyRef, -B] extends AnyRef
     extest.Cov09[_ <: AnyRef, _]
 
-abstract trait Cov11[+A <: AnyRef, +B <: List[_]] extends Object
+abstract trait Cov11[+A <: AnyRef, +B <: List[_]] extends AnyRef
     extest.Cov11[_ <: AnyRef, _ <: List[_]]
 
-abstract trait Cov12[+A <: AnyRef, B <: List[_]] extends Object
+abstract trait Cov12[+A <: AnyRef, B <: List[_]] extends AnyRef
     extest.Cov12[_ <: AnyRef, _ <: List[_]]
 
-abstract trait Cov13[+A <: AnyRef, -B <: List[_]] extends Object
+abstract trait Cov13[+A <: AnyRef, -B <: List[_]] extends AnyRef
     extest.Cov13[_ <: AnyRef, _ <: List[_]]
 
-abstract trait Cov14[A <: AnyRef, +B <: List[_]] extends Object
+abstract trait Cov14[A <: AnyRef, +B <: List[_]] extends AnyRef
     extest.Cov14[_ <: AnyRef, _ <: List[_]]
 
-abstract trait Cov15[A <: AnyRef, B <: List[_]] extends Object
+abstract trait Cov15[A <: AnyRef, B <: List[_]] extends AnyRef
     extest.Cov15[_ <: AnyRef, _ <: List[_]]
 
-abstract trait Cov16[A <: AnyRef, -B <: List[_]] extends Object
+abstract trait Cov16[A <: AnyRef, -B <: List[_]] extends AnyRef
     extest.Cov16[_ <: AnyRef, _ <: List[_]]
 
-abstract trait Cov17[-A <: AnyRef, +B <: List[_]] extends Object
+abstract trait Cov17[-A <: AnyRef, +B <: List[_]] extends AnyRef
     extest.Cov17[_ <: AnyRef, _ <: List[_]]
 
-abstract trait Cov18[-A <: AnyRef, B <: List[_]] extends Object
+abstract trait Cov18[-A <: AnyRef, B <: List[_]] extends AnyRef
     extest.Cov18[_ <: AnyRef, _ <: List[_]]
 
-abstract trait Cov19[-A <: AnyRef, -B <: List[_]] extends Object
+abstract trait Cov19[-A <: AnyRef, -B <: List[_]] extends AnyRef
     extest.Cov19[_ <: AnyRef, _ <: List[_]]
 
-abstract trait Cov21[+A, +B] extends Object
+abstract trait Cov21[+A, +B] extends AnyRef
     extest.Cov21[_, _]
 
-abstract trait Cov22[+A, B] extends Object
+abstract trait Cov22[+A, B] extends AnyRef
     extest.Cov22[_, _]
 
-abstract trait Cov23[+A, -B] extends Object
+abstract trait Cov23[+A, -B] extends AnyRef
     extest.Cov23[_, _]
 
-abstract trait Cov24[A, +B] extends Object
+abstract trait Cov24[A, +B] extends AnyRef
     extest.Cov24[_, _]
 
-abstract trait Cov25[A, B] extends Object
+abstract trait Cov25[A, B] extends AnyRef
     extest.Cov25[_, _]
 
-abstract trait Cov26[A, -B] extends Object
+abstract trait Cov26[A, -B] extends AnyRef
     extest.Cov26[_, _]
 
-abstract trait Cov27[-A, +B] extends Object
+abstract trait Cov27[-A, +B] extends AnyRef
     extest.Cov27[_, _]
 
-abstract trait Cov28[-A, B] extends Object
+abstract trait Cov28[-A, B] extends AnyRef
     extest.Cov28[_, _]
 
-abstract trait Cov29[-A, -B] extends Object
+abstract trait Cov29[-A, -B] extends AnyRef
     extest.Cov29[_, _]
 
-abstract trait Cov31[+A, +B, C <: (A, B)] extends Object
+abstract trait Cov31[+A, +B, C <: (A, B)] extends AnyRef
     extest.Cov31[A,B,C] forSome { +A; +B; C <: (A, B) }
 
-abstract trait Cov32[+A, B, C <: (A, B)] extends Object
+abstract trait Cov32[+A, B, C <: (A, B)] extends AnyRef
     extest.Cov32[A,B,C] forSome { +A; B; C <: (A, B) }
 
-abstract trait Cov33[+A, -B, C <: Tuple2[A, _]] extends Object
+abstract trait Cov33[+A, -B, C <: Tuple2[A, _]] extends AnyRef
     extest.Cov33[A,B,C] forSome { +A; -B; C <: Tuple2[A, _] }
 
-abstract trait Cov34[A, +B, C <: (A, B)] extends Object
+abstract trait Cov34[A, +B, C <: (A, B)] extends AnyRef
     extest.Cov34[A,B,C] forSome { A; +B; C <: (A, B) }
 
-abstract trait Cov35[A, B, C <: (A, B)] extends Object
+abstract trait Cov35[A, B, C <: (A, B)] extends AnyRef
     extest.Cov35[A,B,C] forSome { A; B; C <: (A, B) }
 
-abstract trait Cov36[A, -B, C <: Tuple2[A, _]] extends Object
+abstract trait Cov36[A, -B, C <: Tuple2[A, _]] extends AnyRef
     extest.Cov36[A,B,C] forSome { A; -B; C <: Tuple2[A, _] }
 
-abstract trait Cov37[-A, +B, C <: Tuple2[_, B]] extends Object
+abstract trait Cov37[-A, +B, C <: Tuple2[_, B]] extends AnyRef
     extest.Cov37[A,B,C] forSome { -A; +B; C <: Tuple2[_, B] }
 
-abstract trait Cov38[-A, B, C <: Tuple2[_, B]] extends Object
+abstract trait Cov38[-A, B, C <: Tuple2[_, B]] extends AnyRef
     extest.Cov38[A,B,C] forSome { -A; B; C <: Tuple2[_, B] }
 
-abstract trait Cov39[-A, -B, C <: Tuple2[_, _]] extends Object
+abstract trait Cov39[-A, -B, C <: Tuple2[_, _]] extends AnyRef
     extest.Cov39[_, _, _ <: Tuple2[_, _]]
 
-abstract trait Cov41[+A >: Null, +B] extends Object
+abstract trait Cov41[+A >: Null, +B] extends AnyRef
     extest.Cov41[_ >: Null, _]
 
-abstract trait Cov42[+A >: Null, B] extends Object
+abstract trait Cov42[+A >: Null, B] extends AnyRef
     extest.Cov42[_ >: Null, _]
 
-abstract trait Cov43[+A >: Null, -B] extends Object
+abstract trait Cov43[+A >: Null, -B] extends AnyRef
     extest.Cov43[_ >: Null, _]
 
-abstract trait Cov44[A >: Null, +B] extends Object
+abstract trait Cov44[A >: Null, +B] extends AnyRef
     extest.Cov44[_ >: Null, _]
 
-abstract trait Cov45[A >: Null, B] extends Object
+abstract trait Cov45[A >: Null, B] extends AnyRef
     extest.Cov45[_ >: Null, _]
 
-abstract trait Cov46[A >: Null, -B] extends Object
+abstract trait Cov46[A >: Null, -B] extends AnyRef
     extest.Cov46[_ >: Null, _]
 
-abstract trait Cov47[-A >: Null, +B] extends Object
+abstract trait Cov47[-A >: Null, +B] extends AnyRef
     extest.Cov47[_ >: Null, _]
 
-abstract trait Cov48[-A >: Null, B] extends Object
+abstract trait Cov48[-A >: Null, B] extends AnyRef
     extest.Cov48[_ >: Null, _]
 
-abstract trait Cov49[-A >: Null, -B] extends Object
+abstract trait Cov49[-A >: Null, -B] extends AnyRef
     extest.Cov49[_ >: Null, _]
 
-abstract trait Covariant[+A <: AnyRef, +B] extends Object
+abstract trait Covariant[+A <: AnyRef, +B] extends AnyRef
     extest.Covariant[_ <: AnyRef, _]
 
-abstract trait CovariantLike[+A <: AnyRef, +B <: List[A], +This <: extest.CovariantLike[A,B,This] with extest.Covariant[A,B]] extends Object
+abstract trait CovariantLike[+A <: AnyRef, +B <: List[A], +This <: extest.CovariantLike[A,B,This] with extest.Covariant[A,B]] extends AnyRef
     extest.CovariantLike[A,B,This] forSome { +A <: AnyRef; +B <: List[A]; +This <: extest.CovariantLike[A,B,This] with extest.Covariant[A,B] }
 
diff --git a/test/files/run/existentials3-new.check b/test/files/run/existentials3-new.check
index 00614b19db..8f7dd701ac 100644
--- a/test/files/run/existentials3-new.check
+++ b/test/files/run/existentials3-new.check
@@ -7,7 +7,7 @@ Test.ToS, t=RefinedType, s=f5
 () => Test.ToS, t=TypeRef, s=trait Function0
 $anon, t=TypeRef, s=type $anon
 $anon, t=TypeRef, s=type $anon
-List[java.lang.Object{type T1}#T1], t=TypeRef, s=class List
+List[AnyRef{type T1}#T1], t=TypeRef, s=class List
 List[Seq[Int]], t=TypeRef, s=class List
 List[Seq[U forSome { type U <: Int }]], t=TypeRef, s=class List
 Bar.type, t=TypeRef, s=type Bar.type
@@ -19,6 +19,6 @@ Test.ToS, t=RefinedType, s=g5
 () => Test.ToS, t=TypeRef, s=trait Function0
 $anon, t=TypeRef, s=type $anon
 $anon, t=TypeRef, s=type $anon
-List[java.lang.Object{type T1}#T1], t=TypeRef, s=class List
+List[AnyRef{type T1}#T1], t=TypeRef, s=class List
 List[Seq[Int]], t=TypeRef, s=class List
 List[Seq[U forSome { type U <: Int }]], t=TypeRef, s=class List
diff --git a/test/files/run/existentials3-old.check b/test/files/run/existentials3-old.check
index 72abfac637..36a458dacc 100644
--- a/test/files/run/existentials3-old.check
+++ b/test/files/run/existentials3-old.check
@@ -5,7 +5,7 @@ Object with Test$ToS
 Object with Test$ToS
 scala.Function0[Object with Test$ToS]
 scala.Function0[Object with Test$ToS]
-_ <: Object with _ <: Object with Test$ToS
+_ <: Object with _ <: Object with Object with Test$ToS
 _ <: Object with _ <: Object with _ <: Object with Test$ToS
 scala.collection.immutable.List[Object with scala.collection.Seq[Int]]
 scala.collection.immutable.List[Object with scala.collection.Seq[_ <: Int]]
@@ -16,7 +16,7 @@ Object with Test$ToS
 Object with Test$ToS
 scala.Function0[Object with Test$ToS]
 scala.Function0[Object with Test$ToS]
-_ <: Object with _ <: Object with Test$ToS
+_ <: Object with _ <: Object with Object with Test$ToS
 _ <: Object with _ <: Object with _ <: Object with Test$ToS
 scala.collection.immutable.List[Object with scala.collection.Seq[Int]]
 scala.collection.immutable.List[Object with scala.collection.Seq[_ <: Int]]
diff --git a/test/files/run/idempotency-this.check b/test/files/run/idempotency-this.check
index 08738c4565..efabaf1ec4 100644
--- a/test/files/run/idempotency-this.check
+++ b/test/files/run/idempotency-this.check
@@ -1,4 +1,4 @@
 List()
 immutable.this.List.apply[String]("")
-Apply(TypeApply(Select(Select(This(newTypeName("immutable")), scala.collection.immutable.List), newTermName("apply")), List(TypeTree().setOriginal(Ident(newTypeName("String"))))), List(Literal(Constant(""))))
+Apply(TypeApply(Select(Select(This(TypeName("immutable")), scala.collection.immutable.List), TermName("apply")), List(TypeTree().setOriginal(Ident(TypeName("String"))))), List(Literal(Constant(""))))
 error!
diff --git a/test/files/run/macro-abort-fresh/Macros_1.scala b/test/files/run/macro-abort-fresh/Macros_1.scala
index af1e292588..415b76852f 100644
--- a/test/files/run/macro-abort-fresh/Macros_1.scala
+++ b/test/files/run/macro-abort-fresh/Macros_1.scala
@@ -5,7 +5,7 @@ object Impls {
     import c.universe._
     println(c.fresh())
     println(c.fresh("qwe"))
-    println(c.fresh(newTypeName("qwe")))
+    println(c.fresh(TypeName("qwe")))
     c.abort(NoPosition, "blargh")
   }
 }
diff --git a/test/files/run/macro-abort-fresh/Test_2.scala b/test/files/run/macro-abort-fresh/Test_2.scala
index 0b9986e9f6..61f0bdfadc 100644
--- a/test/files/run/macro-abort-fresh/Test_2.scala
+++ b/test/files/run/macro-abort-fresh/Test_2.scala
@@ -2,7 +2,7 @@ object Test extends App {
   import scala.reflect.runtime.universe._
   import scala.reflect.runtime.{currentMirror => cm}
   import scala.tools.reflect.ToolBox
-  val tree = Select(Ident(newTermName("Macros")), newTermName("foo"))
+  val tree = Select(Ident(TermName("Macros")), TermName("foo"))
   try cm.mkToolBox().eval(tree)
   catch { case ex: Throwable =>  println(ex.getMessage) }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-basic-ma-md-mi/Impls_1.scala b/test/files/run/macro-basic-ma-md-mi/Impls_1.scala
index 646634c972..ce30366c61 100644
--- a/test/files/run/macro-basic-ma-md-mi/Impls_1.scala
+++ b/test/files/run/macro-basic-ma-md-mi/Impls_1.scala
@@ -3,19 +3,19 @@ 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, newTermName("$plus")), List(Literal(Constant(1))))
+    val body = Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(1))))
     c.Expr[Int](body)
   }
 
   def bar(c: Ctx)(x: c.Expr[Int]): c.Expr[Int] = {
     import c.universe._
-    val body = Apply(Select(x.tree, newTermName("$plus")), List(Literal(Constant(2))))
+    val body = Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(2))))
     c.Expr[Int](body)
   }
 
   def quux(c: Ctx)(x: c.Expr[Int]): c.Expr[Int] = {
     import c.universe._
-    val body = Apply(Select(x.tree, newTermName("$plus")), List(Literal(Constant(3))))
+    val body = Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(3))))
     c.Expr[Int](body)
   }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-basic-ma-mdmi/Impls_Macros_1.scala b/test/files/run/macro-basic-ma-mdmi/Impls_Macros_1.scala
index aa1e52e4aa..a601af6dde 100644
--- a/test/files/run/macro-basic-ma-mdmi/Impls_Macros_1.scala
+++ b/test/files/run/macro-basic-ma-mdmi/Impls_Macros_1.scala
@@ -3,19 +3,19 @@ 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, newTermName("$plus")), List(Literal(Constant(1))))
+    val body = Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(1))))
     c.Expr[Int](body)
   }
 
   def bar(c: Ctx)(x: c.Expr[Int]): c.Expr[Int] = {
     import c.universe._
-    val body = Apply(Select(x.tree, newTermName("$plus")), List(Literal(Constant(2))))
+    val body = Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(2))))
     c.Expr[Int](body)
   }
 
   def quux(c: Ctx)(x: c.Expr[Int]): c.Expr[Int] = {
     import c.universe._
-    val body = Apply(Select(x.tree, newTermName("$plus")), List(Literal(Constant(3))))
+    val body = Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(3))))
     c.Expr[Int](body)
   }
 }
diff --git a/test/files/run/macro-basic-mamd-mi/Impls_1.scala b/test/files/run/macro-basic-mamd-mi/Impls_1.scala
index 061aa2d4a3..6e5983bdec 100644
--- a/test/files/run/macro-basic-mamd-mi/Impls_1.scala
+++ b/test/files/run/macro-basic-mamd-mi/Impls_1.scala
@@ -3,17 +3,17 @@ import scala.reflect.macros.{Context => Ctx}
 object Impls {
   def foo(c: Ctx)(x: c.Expr[Int]): c.Expr[Int] = {
     import c.universe._
-    c.Expr(Apply(Select(x.tree, newTermName("$plus")), List(Literal(Constant(1)))))
+    c.Expr(Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(1)))))
   }
 
   def bar(c: Ctx)(x: c.Expr[Int]): c.Expr[Int] = {
     import c.universe._
-    c.Expr(Apply(Select(x.tree, newTermName("$plus")), List(Literal(Constant(2)))))
+    c.Expr(Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(2)))))
   }
 
   def quux(c: Ctx)(x: c.Expr[Int]): c.Expr[Int] = {
     import c.universe._
-    val body = Apply(Select(x.tree, newTermName("$plus")), List(Literal(Constant(3))))
+    val body = Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(3))))
     c.Expr[Int](body)
   }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-bodyexpandstoimpl/Impls_1.scala b/test/files/run/macro-bodyexpandstoimpl/Impls_1.scala
index 0ca0be5a48..9c1e4ee46d 100644
--- a/test/files/run/macro-bodyexpandstoimpl/Impls_1.scala
+++ b/test/files/run/macro-bodyexpandstoimpl/Impls_1.scala
@@ -6,7 +6,7 @@ object Impls {
   def refToFoo(dummy: Int) = macro refToFoo_impl
   def refToFoo_impl(c: Ctx)(dummy: c.Expr[Int]) = {
     import c.universe._
-    val body = Select(Ident(newTermName("Impls")), newTermName("foo"))
+    val body = Select(Ident(TermName("Impls")), TermName("foo"))
     c.Expr[Int](body)
   }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-declared-in-annotation/Impls_1.scala b/test/files/run/macro-declared-in-annotation/Impls_1.scala
index a11ee2907a..1ea06de679 100644
--- a/test/files/run/macro-declared-in-annotation/Impls_1.scala
+++ b/test/files/run/macro-declared-in-annotation/Impls_1.scala
@@ -4,7 +4,7 @@ object Impls {
   def foo(c: Ctx) = {
     import c.{prefix => prefix}
     import c.universe._
-    val printPrefix = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("prefix = " + prefix))))
+    val printPrefix = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("prefix = " + prefix))))
     val body = Block(List(printPrefix), Literal(Constant("this is deprecated")))
     c.Expr[String](body)
   }
diff --git a/test/files/run/macro-declared-in-anonymous/Impls_1.scala b/test/files/run/macro-declared-in-anonymous/Impls_1.scala
index 6f06f6d3f0..348f3420f2 100644
--- a/test/files/run/macro-declared-in-anonymous/Impls_1.scala
+++ b/test/files/run/macro-declared-in-anonymous/Impls_1.scala
@@ -4,8 +4,8 @@ object Impls {
   def foo(c: Ctx) = {
     import c.{prefix => prefix}
     import c.universe._
-    val printPrefix = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("prefix = " + prefix))))
-    val body = Block(List(printPrefix), Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("it works")))))
+    val printPrefix = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("prefix = " + prefix))))
+    val body = Block(List(printPrefix), Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("it works")))))
     c.Expr[Unit](body)
   }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-declared-in-block/Impls_1.scala b/test/files/run/macro-declared-in-block/Impls_1.scala
index 6f06f6d3f0..348f3420f2 100644
--- a/test/files/run/macro-declared-in-block/Impls_1.scala
+++ b/test/files/run/macro-declared-in-block/Impls_1.scala
@@ -4,8 +4,8 @@ object Impls {
   def foo(c: Ctx) = {
     import c.{prefix => prefix}
     import c.universe._
-    val printPrefix = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("prefix = " + prefix))))
-    val body = Block(List(printPrefix), Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("it works")))))
+    val printPrefix = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("prefix = " + prefix))))
+    val body = Block(List(printPrefix), Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("it works")))))
     c.Expr[Unit](body)
   }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-declared-in-class-class/Impls_1.scala b/test/files/run/macro-declared-in-class-class/Impls_1.scala
index 6f06f6d3f0..348f3420f2 100644
--- a/test/files/run/macro-declared-in-class-class/Impls_1.scala
+++ b/test/files/run/macro-declared-in-class-class/Impls_1.scala
@@ -4,8 +4,8 @@ object Impls {
   def foo(c: Ctx) = {
     import c.{prefix => prefix}
     import c.universe._
-    val printPrefix = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("prefix = " + prefix))))
-    val body = Block(List(printPrefix), Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("it works")))))
+    val printPrefix = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("prefix = " + prefix))))
+    val body = Block(List(printPrefix), Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("it works")))))
     c.Expr[Unit](body)
   }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-declared-in-class-object/Impls_1.scala b/test/files/run/macro-declared-in-class-object/Impls_1.scala
index 6f06f6d3f0..348f3420f2 100644
--- a/test/files/run/macro-declared-in-class-object/Impls_1.scala
+++ b/test/files/run/macro-declared-in-class-object/Impls_1.scala
@@ -4,8 +4,8 @@ object Impls {
   def foo(c: Ctx) = {
     import c.{prefix => prefix}
     import c.universe._
-    val printPrefix = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("prefix = " + prefix))))
-    val body = Block(List(printPrefix), Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("it works")))))
+    val printPrefix = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("prefix = " + prefix))))
+    val body = Block(List(printPrefix), Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("it works")))))
     c.Expr[Unit](body)
   }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-declared-in-class/Impls_1.scala b/test/files/run/macro-declared-in-class/Impls_1.scala
index 6f06f6d3f0..348f3420f2 100644
--- a/test/files/run/macro-declared-in-class/Impls_1.scala
+++ b/test/files/run/macro-declared-in-class/Impls_1.scala
@@ -4,8 +4,8 @@ object Impls {
   def foo(c: Ctx) = {
     import c.{prefix => prefix}
     import c.universe._
-    val printPrefix = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("prefix = " + prefix))))
-    val body = Block(List(printPrefix), Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("it works")))))
+    val printPrefix = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("prefix = " + prefix))))
+    val body = Block(List(printPrefix), Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("it works")))))
     c.Expr[Unit](body)
   }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-declared-in-default-param/Impls_1.scala b/test/files/run/macro-declared-in-default-param/Impls_1.scala
index db1e5c7435..4380f40b04 100644
--- a/test/files/run/macro-declared-in-default-param/Impls_1.scala
+++ b/test/files/run/macro-declared-in-default-param/Impls_1.scala
@@ -4,7 +4,7 @@ object Impls {
   def foo(c: Ctx) = {
     import c.{prefix => prefix}
     import c.universe._
-    val printPrefix = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("prefix = " + prefix))))
+    val printPrefix = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("prefix = " + prefix))))
     val body = Block(List(printPrefix), Literal(Constant("it works")))
     c.Expr[String](body)
   }
diff --git a/test/files/run/macro-declared-in-implicit-class/Impls_Macros_1.scala b/test/files/run/macro-declared-in-implicit-class/Impls_Macros_1.scala
index 837b306976..4c009cc367 100644
--- a/test/files/run/macro-declared-in-implicit-class/Impls_Macros_1.scala
+++ b/test/files/run/macro-declared-in-implicit-class/Impls_Macros_1.scala
@@ -4,8 +4,8 @@ object Impls {
   def toOptionOfInt(c: Ctx) = {
     import c.{prefix => prefix}
     import c.universe._
-    val printPrefix = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("prefix = " + prefix))))
-    val body = Block(List(printPrefix), Apply(Ident(definitions.SomeModule), List(Select(Select(prefix.tree, newTermName("x")), newTermName("toInt")))))
+    val printPrefix = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("prefix = " + prefix))))
+    val body = Block(List(printPrefix), Apply(Ident(definitions.SomeModule), List(Select(Select(prefix.tree, TermName("x")), TermName("toInt")))))
     c.Expr[Option[Int]](body)
   }
 }
diff --git a/test/files/run/macro-declared-in-method/Impls_1.scala b/test/files/run/macro-declared-in-method/Impls_1.scala
index 6f06f6d3f0..348f3420f2 100644
--- a/test/files/run/macro-declared-in-method/Impls_1.scala
+++ b/test/files/run/macro-declared-in-method/Impls_1.scala
@@ -4,8 +4,8 @@ object Impls {
   def foo(c: Ctx) = {
     import c.{prefix => prefix}
     import c.universe._
-    val printPrefix = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("prefix = " + prefix))))
-    val body = Block(List(printPrefix), Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("it works")))))
+    val printPrefix = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("prefix = " + prefix))))
+    val body = Block(List(printPrefix), Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("it works")))))
     c.Expr[Unit](body)
   }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-declared-in-object-class/Impls_1.scala b/test/files/run/macro-declared-in-object-class/Impls_1.scala
index 6f06f6d3f0..348f3420f2 100644
--- a/test/files/run/macro-declared-in-object-class/Impls_1.scala
+++ b/test/files/run/macro-declared-in-object-class/Impls_1.scala
@@ -4,8 +4,8 @@ object Impls {
   def foo(c: Ctx) = {
     import c.{prefix => prefix}
     import c.universe._
-    val printPrefix = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("prefix = " + prefix))))
-    val body = Block(List(printPrefix), Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("it works")))))
+    val printPrefix = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("prefix = " + prefix))))
+    val body = Block(List(printPrefix), Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("it works")))))
     c.Expr[Unit](body)
   }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-declared-in-object-object/Impls_1.scala b/test/files/run/macro-declared-in-object-object/Impls_1.scala
index 6f06f6d3f0..348f3420f2 100644
--- a/test/files/run/macro-declared-in-object-object/Impls_1.scala
+++ b/test/files/run/macro-declared-in-object-object/Impls_1.scala
@@ -4,8 +4,8 @@ object Impls {
   def foo(c: Ctx) = {
     import c.{prefix => prefix}
     import c.universe._
-    val printPrefix = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("prefix = " + prefix))))
-    val body = Block(List(printPrefix), Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("it works")))))
+    val printPrefix = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("prefix = " + prefix))))
+    val body = Block(List(printPrefix), Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("it works")))))
     c.Expr[Unit](body)
   }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-declared-in-object/Impls_1.scala b/test/files/run/macro-declared-in-object/Impls_1.scala
index 6f06f6d3f0..348f3420f2 100644
--- a/test/files/run/macro-declared-in-object/Impls_1.scala
+++ b/test/files/run/macro-declared-in-object/Impls_1.scala
@@ -4,8 +4,8 @@ object Impls {
   def foo(c: Ctx) = {
     import c.{prefix => prefix}
     import c.universe._
-    val printPrefix = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("prefix = " + prefix))))
-    val body = Block(List(printPrefix), Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("it works")))))
+    val printPrefix = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("prefix = " + prefix))))
+    val body = Block(List(printPrefix), Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("it works")))))
     c.Expr[Unit](body)
   }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-declared-in-package-object/Impls_1.scala b/test/files/run/macro-declared-in-package-object/Impls_1.scala
index 6f06f6d3f0..348f3420f2 100644
--- a/test/files/run/macro-declared-in-package-object/Impls_1.scala
+++ b/test/files/run/macro-declared-in-package-object/Impls_1.scala
@@ -4,8 +4,8 @@ object Impls {
   def foo(c: Ctx) = {
     import c.{prefix => prefix}
     import c.universe._
-    val printPrefix = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("prefix = " + prefix))))
-    val body = Block(List(printPrefix), Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("it works")))))
+    val printPrefix = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("prefix = " + prefix))))
+    val body = Block(List(printPrefix), Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("it works")))))
     c.Expr[Unit](body)
   }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-declared-in-refinement/Impls_1.scala b/test/files/run/macro-declared-in-refinement/Impls_1.scala
index 6f06f6d3f0..348f3420f2 100644
--- a/test/files/run/macro-declared-in-refinement/Impls_1.scala
+++ b/test/files/run/macro-declared-in-refinement/Impls_1.scala
@@ -4,8 +4,8 @@ object Impls {
   def foo(c: Ctx) = {
     import c.{prefix => prefix}
     import c.universe._
-    val printPrefix = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("prefix = " + prefix))))
-    val body = Block(List(printPrefix), Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("it works")))))
+    val printPrefix = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("prefix = " + prefix))))
+    val body = Block(List(printPrefix), Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("it works")))))
     c.Expr[Unit](body)
   }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-declared-in-trait.check b/test/files/run/macro-declared-in-trait.check
index 104ff1e99b..0d70ac74f3 100644
--- a/test/files/run/macro-declared-in-trait.check
+++ b/test/files/run/macro-declared-in-trait.check
@@ -1,5 +1,5 @@
 prefix = Expr[Nothing]({
-  final class $anon extends Object with Base {
+  final class $anon extends AnyRef with Base {
     def <init>(): anonymous class $anon = {
       $anon.super.<init>();
       ()
diff --git a/test/files/run/macro-declared-in-trait/Impls_1.scala b/test/files/run/macro-declared-in-trait/Impls_1.scala
index 6f06f6d3f0..348f3420f2 100644
--- a/test/files/run/macro-declared-in-trait/Impls_1.scala
+++ b/test/files/run/macro-declared-in-trait/Impls_1.scala
@@ -4,8 +4,8 @@ object Impls {
   def foo(c: Ctx) = {
     import c.{prefix => prefix}
     import c.universe._
-    val printPrefix = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("prefix = " + prefix))))
-    val body = Block(List(printPrefix), Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("it works")))))
+    val printPrefix = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("prefix = " + prefix))))
+    val body = Block(List(printPrefix), Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("it works")))))
     c.Expr[Unit](body)
   }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-def-infer-return-type-b/Test_2.scala b/test/files/run/macro-def-infer-return-type-b/Test_2.scala
index ea0fd4bbff..9e57b90b57 100644
--- a/test/files/run/macro-def-infer-return-type-b/Test_2.scala
+++ b/test/files/run/macro-def-infer-return-type-b/Test_2.scala
@@ -2,7 +2,7 @@ object Test extends App {
   import scala.reflect.runtime.universe._
   import scala.reflect.runtime.{currentMirror => cm}
   import scala.tools.reflect.ToolBox
-  val tree = Apply(Select(Ident(newTermName("Macros")), newTermName("foo")), List(Literal(Constant(42))))
+  val tree = Apply(Select(Ident(TermName("Macros")), TermName("foo")), List(Literal(Constant(42))))
   try cm.mkToolBox().eval(tree)
   catch { case ex: Throwable =>  println(ex.getMessage) }
 }
diff --git a/test/files/run/macro-duplicate.check b/test/files/run/macro-duplicate.check
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/test/files/run/macro-duplicate.check
diff --git a/test/files/run/macro-duplicate.flags b/test/files/run/macro-duplicate.flags
new file mode 100644
index 0000000000..cd66464f2f
--- /dev/null
+++ b/test/files/run/macro-duplicate.flags
@@ -0,0 +1 @@
+-language:experimental.macros
\ No newline at end of file
diff --git a/test/files/run/macro-duplicate/Impls_Macros_1.scala b/test/files/run/macro-duplicate/Impls_Macros_1.scala
new file mode 100644
index 0000000000..de81923330
--- /dev/null
+++ b/test/files/run/macro-duplicate/Impls_Macros_1.scala
@@ -0,0 +1,29 @@
+import scala.reflect.macros.Context
+
+object Macros {
+  def impl(c: Context) = {
+    import c.universe._
+    val Expr(Block((cdef: ClassDef) :: Nil, _)) = reify { class C { def x = 2 } }
+    val cdef1 =
+      new Transformer {
+        override def transform(tree: Tree): Tree = tree match {
+          case Template(_, _, ctor :: defs) =>
+            val defs1 = defs collect {
+              case ddef @ DefDef(mods, name, tparams, vparamss, tpt, body) =>
+                val future = Select(Select(Select(Ident(newTermName("scala")), newTermName("concurrent")), newTermName("package")), newTermName("future"))
+                val Future = Select(Select(Ident(newTermName("scala")), newTermName("concurrent")), newTypeName("Future"))
+                val tpt1 = if (tpt.isEmpty) tpt else AppliedTypeTree(Future, List(tpt))
+                val body1 = Apply(future, List(body))
+                val name1 = newTermName("async" + name.toString.capitalize)
+                DefDef(mods, name1, tparams, vparamss, tpt1, body1)
+            }
+            Template(Nil, emptyValDef, ctor +: defs ::: defs1)
+          case _ =>
+            super.transform(tree)
+        }
+      } transform cdef
+    c.Expr[Unit](Block(cdef1 :: Nil, Literal(Constant(()))))
+  }
+
+  def foo = macro impl
+}
\ No newline at end of file
diff --git a/test/files/run/macro-duplicate/Test_2.scala b/test/files/run/macro-duplicate/Test_2.scala
new file mode 100644
index 0000000000..6dbd4382d3
--- /dev/null
+++ b/test/files/run/macro-duplicate/Test_2.scala
@@ -0,0 +1,6 @@
+import scala.concurrent._
+import ExecutionContext.Implicits.global
+
+object Test extends App {
+  Macros.foo
+}
\ No newline at end of file
diff --git a/test/files/run/macro-expand-implicit-argument/Macros_1.scala b/test/files/run/macro-expand-implicit-argument/Macros_1.scala
index d9fd5b8cb0..b2c7b4d6ca 100644
--- a/test/files/run/macro-expand-implicit-argument/Macros_1.scala
+++ b/test/files/run/macro-expand-implicit-argument/Macros_1.scala
@@ -41,14 +41,14 @@ object Macros {
     def const(x:Int) = Literal(Constant(x))
 
     val n = as.length
-    val arr = newTermName("arr")
+    val arr = TermName("arr")
 
-    val create = Apply(Select(ct.tree, newTermName("newArray")), List(const(n)))
+    val create = Apply(Select(ct.tree, TermName("newArray")), List(const(n)))
     val arrtpe = TypeTree(implicitly[c.WeakTypeTag[Array[A]]].tpe)
     val valdef = ValDef(Modifiers(), arr, arrtpe, create)
 
     val updates = (0 until n).map {
-      i => Apply(Select(Ident(arr), newTermName("update")), List(const(i), as(i).tree))
+      i => Apply(Select(Ident(arr), TermName("update")), List(const(i), as(i).tree))
     }
 
     val exprs = (Seq(valdef) ++ updates ++ Seq(Ident(arr))).toList
diff --git a/test/files/run/macro-expand-implicit-macro-has-implicit/Impls_1.scala b/test/files/run/macro-expand-implicit-macro-has-implicit/Impls_1.scala
index 082e6b2efe..ac1e55c9b2 100644
--- a/test/files/run/macro-expand-implicit-macro-has-implicit/Impls_1.scala
+++ b/test/files/run/macro-expand-implicit-macro-has-implicit/Impls_1.scala
@@ -3,7 +3,7 @@ import scala.reflect.macros.{Context => Ctx}
 object Impls {
   def foo(c: Ctx)(x: c.Expr[Int]) = {
     import c.universe._
-    val body = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(x.tree))
+    val body = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(x.tree))
     c.Expr[Unit](body)
   }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-expand-implicit-macro-is-implicit/Impls_1.scala b/test/files/run/macro-expand-implicit-macro-is-implicit/Impls_1.scala
index cceb038f05..aa1fc7a358 100644
--- a/test/files/run/macro-expand-implicit-macro-is-implicit/Impls_1.scala
+++ b/test/files/run/macro-expand-implicit-macro-is-implicit/Impls_1.scala
@@ -3,7 +3,7 @@ import scala.reflect.macros.{Context => Ctx}
 object Impls {
   def foo(c: Ctx)(x: c.Expr[String]): c.Expr[Option[Int]] = {
     import c.universe._
-    val body = Apply(Ident(definitions.SomeModule), List(Select(x.tree, newTermName("toInt"))))
+    val body = Apply(Ident(definitions.SomeModule), List(Select(x.tree, TermName("toInt"))))
     c.Expr[Option[Int]](body)
   }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-expand-implicit-macro-is-view/Impls_1.scala b/test/files/run/macro-expand-implicit-macro-is-view/Impls_1.scala
index cceb038f05..aa1fc7a358 100644
--- a/test/files/run/macro-expand-implicit-macro-is-view/Impls_1.scala
+++ b/test/files/run/macro-expand-implicit-macro-is-view/Impls_1.scala
@@ -3,7 +3,7 @@ import scala.reflect.macros.{Context => Ctx}
 object Impls {
   def foo(c: Ctx)(x: c.Expr[String]): c.Expr[Option[Int]] = {
     import c.universe._
-    val body = Apply(Ident(definitions.SomeModule), List(Select(x.tree, newTermName("toInt"))))
+    val body = Apply(Ident(definitions.SomeModule), List(Select(x.tree, TermName("toInt"))))
     c.Expr[Option[Int]](body)
   }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-expand-multiple-arglists/Impls_1.scala b/test/files/run/macro-expand-multiple-arglists/Impls_1.scala
index 11e07932c3..4fddc13d68 100644
--- a/test/files/run/macro-expand-multiple-arglists/Impls_1.scala
+++ b/test/files/run/macro-expand-multiple-arglists/Impls_1.scala
@@ -3,8 +3,8 @@ import scala.reflect.macros.{Context => Ctx}
 object Impls {
   def foo(c: Ctx)(x: c.Expr[Int])(y: c.Expr[Int]) = {
     import c.universe._
-    val sum = Apply(Select(x.tree, newTermName("$minus")), List(y.tree))
-    val body = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(sum))
+    val sum = Apply(Select(x.tree, TermName("$minus")), List(y.tree))
+    val body = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(sum))
     c.Expr[Unit](body)
   }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-expand-nullary-generic/Impls_1.scala b/test/files/run/macro-expand-nullary-generic/Impls_1.scala
index 1180c83a40..39a9db0e14 100644
--- a/test/files/run/macro-expand-nullary-generic/Impls_1.scala
+++ b/test/files/run/macro-expand-nullary-generic/Impls_1.scala
@@ -4,7 +4,7 @@ import scala.reflect.macros.{Context => Ctx}
 object Impls {
   def impl[T: c.WeakTypeTag](c: Ctx) = {
     import c.universe._
-    val body = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("it works " + implicitly[c.WeakTypeTag[T]]))))
+    val body = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("it works " + implicitly[c.WeakTypeTag[T]]))))
     c.Expr[Unit](body)
   }
 
diff --git a/test/files/run/macro-expand-nullary-nongeneric/Impls_1.scala b/test/files/run/macro-expand-nullary-nongeneric/Impls_1.scala
index c6bd1cdbf1..41e50acc86 100644
--- a/test/files/run/macro-expand-nullary-nongeneric/Impls_1.scala
+++ b/test/files/run/macro-expand-nullary-nongeneric/Impls_1.scala
@@ -3,7 +3,7 @@ import scala.reflect.macros.{Context => Ctx}
 object Impls {
   def impl(c: Ctx) = {
     import c.universe._
-    val body = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("it works"))))
+    val body = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("it works"))))
     c.Expr[Unit](body)
   }
 
diff --git a/test/files/run/macro-expand-overload/Impls_1.scala b/test/files/run/macro-expand-overload/Impls_1.scala
index f7c240d9ca..1c672f6040 100644
--- a/test/files/run/macro-expand-overload/Impls_1.scala
+++ b/test/files/run/macro-expand-overload/Impls_1.scala
@@ -4,7 +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), newTermName("println")), List(Literal(Constant(tag)), Literal(Constant(prefix.toString)), x.tree))
+    val body = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant(tag)), Literal(Constant(prefix.toString)), x.tree))
     c.Expr[Unit](body)
   }
 
diff --git a/test/files/run/macro-expand-override/Impls_1.scala b/test/files/run/macro-expand-override/Impls_1.scala
index ec93dd4111..69ef57d18d 100644
--- a/test/files/run/macro-expand-override/Impls_1.scala
+++ b/test/files/run/macro-expand-override/Impls_1.scala
@@ -4,7 +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), newTermName("println")), List(Literal(Constant(tag)), Literal(Constant(prefix.toString)), x.tree))
+    val body = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant(tag)), Literal(Constant(prefix.toString)), x.tree))
     c.Expr[Unit](body)
   }
 
diff --git a/test/files/run/macro-expand-recursive/Impls_1.scala b/test/files/run/macro-expand-recursive/Impls_1.scala
index 61db5c4a9b..47dd398454 100644
--- a/test/files/run/macro-expand-recursive/Impls_1.scala
+++ b/test/files/run/macro-expand-recursive/Impls_1.scala
@@ -3,13 +3,13 @@ import scala.reflect.macros.{Context => Ctx}
 object Impls {
   def foo(c: Ctx) = {
     import c.universe._
-    val body = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("it works"))))
+    val body = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("it works"))))
     c.Expr[Unit](body)
   }
 
   def fooFoo(c: Ctx) = {
     import c.universe._
-    val body = Select(Ident(newTermName("Macros")), newTermName("foo"))
+    val body = Select(Ident(TermName("Macros")), TermName("foo"))
     c.Expr[Unit](body)
   }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-expand-tparams-explicit/Impls_1.scala b/test/files/run/macro-expand-tparams-explicit/Impls_1.scala
index 72b420d92f..f748ab855f 100644
--- a/test/files/run/macro-expand-tparams-explicit/Impls_1.scala
+++ b/test/files/run/macro-expand-tparams-explicit/Impls_1.scala
@@ -5,7 +5,7 @@ object Impls {
   def foo[U: c.WeakTypeTag](c: Ctx) = {
     import c.universe._
     val U = implicitly[c.WeakTypeTag[U]]
-    val body = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(U.toString))))
+    val body = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant(U.toString))))
     c.Expr[Unit](body)
   }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-expand-tparams-implicit/Impls_1.scala b/test/files/run/macro-expand-tparams-implicit/Impls_1.scala
index 33770516df..c729aada51 100644
--- a/test/files/run/macro-expand-tparams-implicit/Impls_1.scala
+++ b/test/files/run/macro-expand-tparams-implicit/Impls_1.scala
@@ -5,7 +5,7 @@ object Impls {
   def foo[U: c.WeakTypeTag](c: Ctx)(x: c.Expr[U]) = {
     import c.universe._
     val U = implicitly[c.WeakTypeTag[U]]
-    val body = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(U.toString))))
+    val body = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant(U.toString))))
     c.Expr[Unit](body)
   }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-expand-tparams-optional/Impls_1.scala b/test/files/run/macro-expand-tparams-optional/Impls_1.scala
index 3b829e2e09..ace7a6cd26 100644
--- a/test/files/run/macro-expand-tparams-optional/Impls_1.scala
+++ b/test/files/run/macro-expand-tparams-optional/Impls_1.scala
@@ -3,7 +3,7 @@ import scala.reflect.macros.{Context => Ctx}
 object Impls {
   def foo[U](c: Ctx) = {
     import c.universe._
-    val body = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("don't know U"))))
+    val body = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("don't know U"))))
     c.Expr[Unit](body)
   }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-expand-tparams-prefix-a/Impls_1.scala b/test/files/run/macro-expand-tparams-prefix-a/Impls_1.scala
index 33770516df..c729aada51 100644
--- a/test/files/run/macro-expand-tparams-prefix-a/Impls_1.scala
+++ b/test/files/run/macro-expand-tparams-prefix-a/Impls_1.scala
@@ -5,7 +5,7 @@ object Impls {
   def foo[U: c.WeakTypeTag](c: Ctx)(x: c.Expr[U]) = {
     import c.universe._
     val U = implicitly[c.WeakTypeTag[U]]
-    val body = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(U.toString))))
+    val body = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant(U.toString))))
     c.Expr[Unit](body)
   }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-expand-tparams-prefix-b/Impls_1.scala b/test/files/run/macro-expand-tparams-prefix-b/Impls_1.scala
index 9378e67712..8880d13b04 100644
--- a/test/files/run/macro-expand-tparams-prefix-b/Impls_1.scala
+++ b/test/files/run/macro-expand-tparams-prefix-b/Impls_1.scala
@@ -6,7 +6,7 @@ object Impls {
     import c.universe._
     val T = implicitly[c.WeakTypeTag[T]]
     val U = implicitly[c.WeakTypeTag[U]]
-    val body = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(T.toString + " " + U.toString))))
+    val body = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant(T.toString + " " + U.toString))))
     c.Expr[Unit](body)
   }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-expand-tparams-prefix-c1/Impls_1.scala b/test/files/run/macro-expand-tparams-prefix-c1/Impls_1.scala
index afdd7d4f7a..2df42e969f 100644
--- a/test/files/run/macro-expand-tparams-prefix-c1/Impls_1.scala
+++ b/test/files/run/macro-expand-tparams-prefix-c1/Impls_1.scala
@@ -5,9 +5,9 @@ object Impls {
   def foo[T, U: c.WeakTypeTag, V](c: Ctx)(implicit T: c.WeakTypeTag[T], V: c.WeakTypeTag[V]): c.Expr[Unit] = {
     import c.universe._
     c.Expr(Block(List(
-      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(T.toString)))),
-      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(implicitly[c.WeakTypeTag[U]].toString)))),
-      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(V.toString))))),
+      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(()))))
   }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-expand-tparams-prefix-c2/Impls_Macros_1.scala b/test/files/run/macro-expand-tparams-prefix-c2/Impls_Macros_1.scala
index 3c2838208a..08817708d4 100644
--- a/test/files/run/macro-expand-tparams-prefix-c2/Impls_Macros_1.scala
+++ b/test/files/run/macro-expand-tparams-prefix-c2/Impls_Macros_1.scala
@@ -5,9 +5,9 @@ object Impls {
   def foo[T, U: c.WeakTypeTag, V](c: Ctx)(implicit T: c.WeakTypeTag[T], V: c.WeakTypeTag[V]): c.Expr[Unit] = {
     import c.universe._
     c.Expr(Block(List(
-      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(T.toString)))),
-      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(implicitly[c.WeakTypeTag[U]].toString)))),
-      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(V.toString))))),
+      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(()))))
   }
 }
diff --git a/test/files/run/macro-expand-tparams-prefix-d1/Impls_1.scala b/test/files/run/macro-expand-tparams-prefix-d1/Impls_1.scala
index afdd7d4f7a..2df42e969f 100644
--- a/test/files/run/macro-expand-tparams-prefix-d1/Impls_1.scala
+++ b/test/files/run/macro-expand-tparams-prefix-d1/Impls_1.scala
@@ -5,9 +5,9 @@ object Impls {
   def foo[T, U: c.WeakTypeTag, V](c: Ctx)(implicit T: c.WeakTypeTag[T], V: c.WeakTypeTag[V]): c.Expr[Unit] = {
     import c.universe._
     c.Expr(Block(List(
-      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(T.toString)))),
-      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(implicitly[c.WeakTypeTag[U]].toString)))),
-      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(V.toString))))),
+      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(()))))
   }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-expand-varargs-explicit-over-nonvarargs-bad/Impls_1.scala b/test/files/run/macro-expand-varargs-explicit-over-nonvarargs-bad/Impls_1.scala
index 2ef8f04be9..f6c1d27d54 100644
--- a/test/files/run/macro-expand-varargs-explicit-over-nonvarargs-bad/Impls_1.scala
+++ b/test/files/run/macro-expand-varargs-explicit-over-nonvarargs-bad/Impls_1.scala
@@ -3,7 +3,7 @@ import scala.reflect.macros.{Context => Ctx}
 object Impls {
   def foo(c: Ctx)(xs: c.Expr[Int]*) = {
     import c.universe._
-    val body = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), xs.map(_.tree).toList)
+    val body = Apply(Select(Ident(definitions.PredefModule), TermName("println")), xs.map(_.tree).toList)
     c.Expr[Unit](body)
   }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-expand-varargs-explicit-over-nonvarargs-bad/Macros_Test_2.scala b/test/files/run/macro-expand-varargs-explicit-over-nonvarargs-bad/Macros_Test_2.scala
index c832826d64..b844012d53 100644
--- a/test/files/run/macro-expand-varargs-explicit-over-nonvarargs-bad/Macros_Test_2.scala
+++ b/test/files/run/macro-expand-varargs-explicit-over-nonvarargs-bad/Macros_Test_2.scala
@@ -6,7 +6,7 @@ object Test extends App {
   import scala.reflect.runtime.universe._
   import scala.reflect.runtime.{currentMirror => cm}
   import scala.tools.reflect.ToolBox
-  val tree = Apply(Select(Ident(newTermName("Macros")), newTermName("foo")), List(Typed(Apply(Ident(definitions.ListModule), List(Literal(Constant(1)), Literal(Constant(2)))), Ident(tpnme.WILDCARD_STAR))))
+  val tree = Apply(Select(Ident(TermName("Macros")), TermName("foo")), List(Typed(Apply(Ident(definitions.ListModule), List(Literal(Constant(1)), Literal(Constant(2)))), Ident(tpnme.WILDCARD_STAR))))
   try cm.mkToolBox().eval(tree)
   catch { case ex: Throwable =>  println(ex.getMessage) }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-expand-varargs-explicit-over-nonvarargs-good/Impls_1.scala b/test/files/run/macro-expand-varargs-explicit-over-nonvarargs-good/Impls_1.scala
index 3c7f94f605..363ff0e0aa 100644
--- a/test/files/run/macro-expand-varargs-explicit-over-nonvarargs-good/Impls_1.scala
+++ b/test/files/run/macro-expand-varargs-explicit-over-nonvarargs-good/Impls_1.scala
@@ -7,7 +7,7 @@ object Impls {
       case List(Typed(stripped, Ident(wildstar))) if wildstar == tpnme.WILDCARD_STAR => List(stripped)
       case _ => ???
     }
-    val body = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), stripped_xs)
+    val body = Apply(Select(Ident(definitions.PredefModule), TermName("println")), stripped_xs)
     c.Expr[Unit](body)
   }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-expand-varargs-explicit-over-varargs/Impls_1.scala b/test/files/run/macro-expand-varargs-explicit-over-varargs/Impls_1.scala
index 2066893bdc..0b61ab2f9b 100644
--- a/test/files/run/macro-expand-varargs-explicit-over-varargs/Impls_1.scala
+++ b/test/files/run/macro-expand-varargs-explicit-over-varargs/Impls_1.scala
@@ -7,7 +7,7 @@ object Impls {
 
   def foo(c: Ctx)(xs: c.Expr[Int]*) = {
     import c.universe._
-    val body = Apply(Select(Ident(newTermName("Impls")), newTermName("myprintln")), xs.map(_.tree).toList)
+    val body = Apply(Select(Ident(TermName("Impls")), TermName("myprintln")), xs.map(_.tree).toList)
     c.Expr[Unit](body)
   }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-expand-varargs-implicit-over-nonvarargs/Impls_1.scala b/test/files/run/macro-expand-varargs-implicit-over-nonvarargs/Impls_1.scala
index 2ef8f04be9..f6c1d27d54 100644
--- a/test/files/run/macro-expand-varargs-implicit-over-nonvarargs/Impls_1.scala
+++ b/test/files/run/macro-expand-varargs-implicit-over-nonvarargs/Impls_1.scala
@@ -3,7 +3,7 @@ import scala.reflect.macros.{Context => Ctx}
 object Impls {
   def foo(c: Ctx)(xs: c.Expr[Int]*) = {
     import c.universe._
-    val body = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), xs.map(_.tree).toList)
+    val body = Apply(Select(Ident(definitions.PredefModule), TermName("println")), xs.map(_.tree).toList)
     c.Expr[Unit](body)
   }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-expand-varargs-implicit-over-varargs/Impls_1.scala b/test/files/run/macro-expand-varargs-implicit-over-varargs/Impls_1.scala
index 2066893bdc..0b61ab2f9b 100644
--- a/test/files/run/macro-expand-varargs-implicit-over-varargs/Impls_1.scala
+++ b/test/files/run/macro-expand-varargs-implicit-over-varargs/Impls_1.scala
@@ -7,7 +7,7 @@ object Impls {
 
   def foo(c: Ctx)(xs: c.Expr[Int]*) = {
     import c.universe._
-    val body = Apply(Select(Ident(newTermName("Impls")), newTermName("myprintln")), xs.map(_.tree).toList)
+    val body = Apply(Select(Ident(TermName("Impls")), TermName("myprintln")), xs.map(_.tree).toList)
     c.Expr[Unit](body)
   }
 }
\ No newline at end of file
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 7c40045c0f..95d746980e 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
@@ -7,10 +7,10 @@ object Impls {
     import c.universe._
     val U = implicitly[c.WeakTypeTag[U]]
     val body = Block(List(
-      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("invoking foo_targs...")))),
-      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("type of prefix is: " + prefix.staticType)))),
-      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("type of prefix tree is: " + prefix.tree.tpe)))),
-      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("U is: " + U.tpe))))),
+      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)
   }
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 56c23f5faf..738c88bbc8 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
@@ -4,7 +4,7 @@ object Impls {
   def foo(unconventionalName: Ctx)(x: unconventionalName.Expr[Int]) = {
     import unconventionalName.universe._
     val body = Block(List(
-      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant("invoking foo..."))))),
+      Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant("invoking foo..."))))),
       Literal(Constant(())))
     unconventionalName.Expr[Unit](body)
   }
diff --git a/test/files/run/macro-invalidret-doesnt-conform-to-def-rettype/Test_2.scala b/test/files/run/macro-invalidret-doesnt-conform-to-def-rettype/Test_2.scala
index 0b9986e9f6..61f0bdfadc 100644
--- a/test/files/run/macro-invalidret-doesnt-conform-to-def-rettype/Test_2.scala
+++ b/test/files/run/macro-invalidret-doesnt-conform-to-def-rettype/Test_2.scala
@@ -2,7 +2,7 @@ object Test extends App {
   import scala.reflect.runtime.universe._
   import scala.reflect.runtime.{currentMirror => cm}
   import scala.tools.reflect.ToolBox
-  val tree = Select(Ident(newTermName("Macros")), newTermName("foo"))
+  val tree = Select(Ident(TermName("Macros")), TermName("foo"))
   try cm.mkToolBox().eval(tree)
   catch { case ex: Throwable =>  println(ex.getMessage) }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-invalidret-nontypeable/Impls_Macros_1.scala b/test/files/run/macro-invalidret-nontypeable/Impls_Macros_1.scala
index fb0d55208c..869a5a41fa 100644
--- a/test/files/run/macro-invalidret-nontypeable/Impls_Macros_1.scala
+++ b/test/files/run/macro-invalidret-nontypeable/Impls_Macros_1.scala
@@ -3,7 +3,7 @@ import scala.reflect.macros.{Context => Ctx}
 object Impls {
   def foo(c: Ctx) = {
     import c.universe._
-    val body = Ident(newTermName("IDoNotExist"))
+    val body = Ident(TermName("IDoNotExist"))
     c.Expr[Int](body)
   }
 }
diff --git a/test/files/run/macro-invalidret-nontypeable/Test_2.scala b/test/files/run/macro-invalidret-nontypeable/Test_2.scala
index 0daee49a08..7cd474ff52 100644
--- a/test/files/run/macro-invalidret-nontypeable/Test_2.scala
+++ b/test/files/run/macro-invalidret-nontypeable/Test_2.scala
@@ -2,7 +2,7 @@
   import scala.reflect.runtime.universe._
   import scala.reflect.runtime.{currentMirror => cm}
   import scala.tools.reflect.ToolBox
-  val tree = Select(Ident(newTermName("Macros")), newTermName("foo"))
+  val tree = Select(Ident(TermName("Macros")), TermName("foo"))
   try cm.mkToolBox().eval(tree)
   catch { case ex: Throwable =>  println(ex.getMessage) }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-invalidusage-badret/Test_2.scala b/test/files/run/macro-invalidusage-badret/Test_2.scala
index 5cb0be5ddd..fc71353f54 100644
--- a/test/files/run/macro-invalidusage-badret/Test_2.scala
+++ b/test/files/run/macro-invalidusage-badret/Test_2.scala
@@ -2,7 +2,7 @@ object Test extends App {
   import scala.reflect.runtime.universe._
   import scala.reflect.runtime.{currentMirror => cm}
   import scala.tools.reflect.ToolBox
-  val tree = Typed(Apply(Select(Ident(newTermName("Macros")), newTermName("foo")), List(Literal(Constant(42)))), Ident(newTypeName("String")))
+  val tree = Typed(Apply(Select(Ident(TermName("Macros")), TermName("foo")), List(Literal(Constant(42)))), Ident(TypeName("String")))
   try cm.mkToolBox().eval(tree)
   catch { case ex: Throwable =>  println(ex.getMessage) }
 }
diff --git a/test/files/run/macro-invalidusage-partialapplication-with-tparams/Impls_Macros_1.scala b/test/files/run/macro-invalidusage-partialapplication-with-tparams/Impls_Macros_1.scala
index 4583a726cf..8a93161af5 100644
--- a/test/files/run/macro-invalidusage-partialapplication-with-tparams/Impls_Macros_1.scala
+++ b/test/files/run/macro-invalidusage-partialapplication-with-tparams/Impls_Macros_1.scala
@@ -3,7 +3,7 @@ import scala.reflect.macros.{Context => Ctx}
 object Impls {
   def foo[T: c.WeakTypeTag](c: Ctx)(x: c.Expr[T]) = {
     import c.universe._
-    val body = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(x.tree.toString))))
+    val body = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Literal(Constant(x.tree.toString))))
     c.Expr[Unit](body)
   }
 }
diff --git a/test/files/run/macro-invalidusage-partialapplication-with-tparams/Test_2.scala b/test/files/run/macro-invalidusage-partialapplication-with-tparams/Test_2.scala
index e453d0b70c..9a34c62e0f 100644
--- a/test/files/run/macro-invalidusage-partialapplication-with-tparams/Test_2.scala
+++ b/test/files/run/macro-invalidusage-partialapplication-with-tparams/Test_2.scala
@@ -2,7 +2,7 @@ object Test extends App {
   import scala.reflect.runtime.universe._
   import scala.reflect.runtime.{currentMirror => cm}
   import scala.tools.reflect.ToolBox
-  val tree = Select(Ident(newTermName("Macros")), newTermName("foo"))
+  val tree = Select(Ident(TermName("Macros")), TermName("foo"))
   try cm.mkToolBox().eval(tree)
   catch { case ex: Throwable =>  println(ex.getMessage) }
 }
diff --git a/test/files/run/macro-invalidusage-partialapplication/Impls_Macros_1.scala b/test/files/run/macro-invalidusage-partialapplication/Impls_Macros_1.scala
index 5866469499..3ac9cd2a8d 100644
--- a/test/files/run/macro-invalidusage-partialapplication/Impls_Macros_1.scala
+++ b/test/files/run/macro-invalidusage-partialapplication/Impls_Macros_1.scala
@@ -3,8 +3,8 @@ import scala.reflect.macros.{Context => Ctx}
 object Impls {
   def foo(c: Ctx)(x: c.Expr[Int])(y: c.Expr[Int]) = {
     import c.universe._
-    val sum = Apply(Select(x.tree, newTermName("$plus")), List(y.tree))
-    val body = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(sum))
+    val sum = Apply(Select(x.tree, TermName("$plus")), List(y.tree))
+    val body = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(sum))
     c.Expr[Unit](body)
   }
 }
diff --git a/test/files/run/macro-invalidusage-partialapplication/Test_2.scala b/test/files/run/macro-invalidusage-partialapplication/Test_2.scala
index dc48c127f4..75b8c139d4 100644
--- a/test/files/run/macro-invalidusage-partialapplication/Test_2.scala
+++ b/test/files/run/macro-invalidusage-partialapplication/Test_2.scala
@@ -2,7 +2,7 @@ object Test extends App {
   import scala.reflect.runtime.universe._
   import scala.reflect.runtime.{currentMirror => cm}
   import scala.tools.reflect.ToolBox
-  val tree = Apply(Select(Ident(newTermName("Macros")), newTermName("foo")), List(Literal(Constant(40))))
+  val tree = Apply(Select(Ident(TermName("Macros")), TermName("foo")), List(Literal(Constant(40))))
   try cm.mkToolBox().eval(tree)
   catch { case ex: Throwable =>  println(ex.getMessage) }
 }
diff --git a/test/files/run/macro-openmacros/Impls_Macros_1.scala b/test/files/run/macro-openmacros/Impls_Macros_1.scala
index b863ac048b..50a1782431 100644
--- a/test/files/run/macro-openmacros/Impls_Macros_1.scala
+++ b/test/files/run/macro-openmacros/Impls_Macros_1.scala
@@ -14,7 +14,7 @@ object Macros {
     }
 
     import c.universe._
-    val next = if (c.enclosingMacros.length < 3) c.Expr[Unit](Select(Ident(c.mirror.staticModule("Macros")), newTermName("foo"))) else c.literalUnit
+    val next = if (c.enclosingMacros.length < 3) c.Expr[Unit](Select(Ident(c.mirror.staticModule("Macros")), TermName("foo"))) else c.literalUnit
     c.universe.reify {
       println(c.literal(normalizePaths(c.enclosingMacros.toString)).splice)
       next.splice
diff --git a/test/files/run/macro-range/Common_1.scala b/test/files/run/macro-range/Common_1.scala
index 5c4bc211fc..4083e6126e 100644
--- a/test/files/run/macro-range/Common_1.scala
+++ b/test/files/run/macro-range/Common_1.scala
@@ -43,5 +43,5 @@ abstract class Utils {
     LabelDef(lname, Nil, rhs)
   }
   def makeBinop(left: Tree, op: String, right: Tree): Tree =
-    Apply(Select(left, newTermName(op)), List(right))
+    Apply(Select(left, TermName(op)), List(right))
 }
diff --git a/test/files/run/macro-range/Expansion_Impossible_2.scala b/test/files/run/macro-range/Expansion_Impossible_2.scala
index 57e0cee97f..ca0db48822 100644
--- a/test/files/run/macro-range/Expansion_Impossible_2.scala
+++ b/test/files/run/macro-range/Expansion_Impossible_2.scala
@@ -16,11 +16,11 @@ object Impls {
     //   scala"($_this: RangeDefault).foreach($f)"
     c.Expr(c.prefix.tree match {
       case Apply(Select(New(tpt), initName), List(lo, hi)) if tpt.symbol.fullName == "Range" =>
-        val iname = newTermName("$i")
-        val hname = newTermName("$h")
+        val iname = TermName("$i")
+        val hname = TermName("$h")
         def iref = Ident(iname)
         def href = Ident(hname)
-        val labelname = newTermName("$while")
+        val labelname = TermName("$while")
         val cond = makeBinop(iref, "$less", href)
         val body = Block(
             List(makeApply(f.tree, List(iref))),
@@ -37,8 +37,8 @@ object Impls {
       case _ =>
         Apply(
           Select(
-            Typed(c.prefix.tree, Ident(newTypeName("RangeDefault"))),
-            newTermName("foreach")),
+            Typed(c.prefix.tree, Ident(TypeName("RangeDefault"))),
+            TermName("foreach")),
           List(f.tree))
     })
   }
diff --git a/test/files/run/macro-reflective-ma-normal-mdmi/Impls_Macros_1.scala b/test/files/run/macro-reflective-ma-normal-mdmi/Impls_Macros_1.scala
index fa559334d4..51e0264ed5 100644
--- a/test/files/run/macro-reflective-ma-normal-mdmi/Impls_Macros_1.scala
+++ b/test/files/run/macro-reflective-ma-normal-mdmi/Impls_Macros_1.scala
@@ -3,7 +3,7 @@ import scala.reflect.macros.{Context => Ctx}
 object Impls {
   def foo(c: Ctx)(x: c.Expr[Int]) = {
     import c.universe._
-    val body = Apply(Select(x.tree, newTermName("$plus")), List(Literal(Constant(1))))
+    val body = Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(1))))
     c.Expr[Int](body)
   }
 }
diff --git a/test/files/run/macro-reflective-ma-normal-mdmi/Test_2.scala b/test/files/run/macro-reflective-ma-normal-mdmi/Test_2.scala
index 2e64c01e35..267d1bc7b0 100644
--- a/test/files/run/macro-reflective-ma-normal-mdmi/Test_2.scala
+++ b/test/files/run/macro-reflective-ma-normal-mdmi/Test_2.scala
@@ -2,6 +2,6 @@ object Test extends App {
   import scala.reflect.runtime.universe._
   import scala.reflect.runtime.{currentMirror => cm}
   import scala.tools.reflect.ToolBox
-  val tree = Apply(Select(Ident(newTermName("Macros")), newTermName("foo")), List(Literal(Constant(42))))
+  val tree = Apply(Select(Ident(TermName("Macros")), TermName("foo")), List(Literal(Constant(42))))
   println(cm.mkToolBox().eval(tree))
 }
diff --git a/test/files/run/macro-reflective-mamd-normal-mi/Impls_1.scala b/test/files/run/macro-reflective-mamd-normal-mi/Impls_1.scala
index 5d7e077731..4261a6d45d 100644
--- a/test/files/run/macro-reflective-mamd-normal-mi/Impls_1.scala
+++ b/test/files/run/macro-reflective-mamd-normal-mi/Impls_1.scala
@@ -3,7 +3,7 @@ import scala.reflect.macros.{Context => Ctx}
 object Impls {
   def foo(c: Ctx)(x: c.Expr[Int]) = {
     import c.universe._
-    val body = Apply(Select(x.tree, newTermName("$plus")), List(Literal(Constant(1))))
+    val body = Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(1))))
     c.Expr[Int](body)
   }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-reflective-mamd-normal-mi/Macros_Test_2.scala b/test/files/run/macro-reflective-mamd-normal-mi/Macros_Test_2.scala
index 70560009b1..13cd953bde 100644
--- a/test/files/run/macro-reflective-mamd-normal-mi/Macros_Test_2.scala
+++ b/test/files/run/macro-reflective-mamd-normal-mi/Macros_Test_2.scala
@@ -8,12 +8,12 @@ object Test extends App {
   import scala.reflect.runtime.{currentMirror => cm}
   import scala.tools.reflect.ToolBox
 
-  val macrobody = Select(Ident(newTermName("Impls")), newTermName("foo"))
-  val macroparam = ValDef(NoMods, newTermName("x"), TypeTree(definitions.IntClass.toType), EmptyTree)
-  val macrodef = DefDef(Modifiers(MACRO), newTermName("foo"), Nil, List(List(macroparam)), TypeTree(), macrobody)
+  val macrobody = Select(Ident(TermName("Impls")), TermName("foo"))
+  val macroparam = ValDef(NoMods, TermName("x"), TypeTree(definitions.IntClass.toType), EmptyTree)
+  val macrodef = DefDef(Modifiers(MACRO), TermName("foo"), Nil, List(List(macroparam)), TypeTree(), macrobody)
   val modulector = DefDef(NoMods, nme.CONSTRUCTOR, Nil, List(List()), TypeTree(), Block(List(Apply(Select(Super(This(tpnme.EMPTY), tpnme.EMPTY), nme.CONSTRUCTOR), List())), Literal(Constant(()))))
-  val module = ModuleDef(NoMods, newTermName("Macros"), Template(Nil, emptyValDef, List(modulector, macrodef)))
-  val macroapp = Apply(Select(Ident(newTermName("Macros")), newTermName("foo")), List(Literal(Constant(42))))
+  val module = ModuleDef(NoMods, TermName("Macros"), Template(Nil, emptyValDef, List(modulector, macrodef)))
+  val macroapp = Apply(Select(Ident(TermName("Macros")), TermName("foo")), List(Literal(Constant(42))))
   val tree = Block(List(macrodef, module), macroapp)
   val toolbox = cm.mkToolBox(options = "-language:experimental.macros")
   println(toolbox.eval(tree))
diff --git a/test/files/run/macro-reify-freevars/Test_2.scala b/test/files/run/macro-reify-freevars/Test_2.scala
index 7af9d89bdb..c2d0118e17 100644
--- a/test/files/run/macro-reify-freevars/Test_2.scala
+++ b/test/files/run/macro-reify-freevars/Test_2.scala
@@ -2,10 +2,10 @@ object Test extends App {
   import scala.reflect.runtime.universe._
   import scala.reflect.runtime.{currentMirror => cm}
   import scala.tools.reflect.ToolBox
-  val q = New(AppliedTypeTree(Select(Select(Select(Ident(newTermName("scala")), newTermName("collection")), newTermName("slick")), newTypeName("Queryable")), List(Ident(newTermName("Int")))))
-  val x = ValDef(NoMods, newTermName("x"), Ident(newTermName("Int")), EmptyTree)
-  val fn = Function(List(x), Apply(Select(Ident(newTermName("x")), newTermName("$plus")), List(Literal(Constant("5")))))
-  val tree = Apply(Select(q, newTermName("map")), List(fn))
+  val q = New(AppliedTypeTree(Select(Select(Select(Ident(TermName("scala")), TermName("collection")), TermName("slick")), TypeName("Queryable")), List(Ident(TermName("Int")))))
+  val x = ValDef(NoMods, TermName("x"), Ident(TermName("Int")), EmptyTree)
+  val fn = Function(List(x), Apply(Select(Ident(TermName("x")), TermName("$plus")), List(Literal(Constant("5")))))
+  val tree = Apply(Select(q, TermName("map")), List(fn))
   try cm.mkToolBox().eval(tree)
   catch { case ex: Throwable =>  println(ex.getMessage) }
 }
\ No newline at end of file
diff --git a/test/files/run/macro-reify-nested-a/Impls_Macros_1.scala b/test/files/run/macro-reify-nested-a/Impls_Macros_1.scala
index b4351c2c53..bb6a45e11e 100644
--- a/test/files/run/macro-reify-nested-a/Impls_Macros_1.scala
+++ b/test/files/run/macro-reify-nested-a/Impls_Macros_1.scala
@@ -28,7 +28,7 @@ object QueryableMacros{
     val foo = c.Expr[ru.Expr[Queryable[S]]](
     c.reifyTree( mkRuntimeUniverseRef, EmptyTree, c.typeCheck(
       Utils[c.type](c).removeDoubleReify(
-        Apply(Select(c.prefix.tree, newTermName( name )), List( projection.tree ))
+        Apply(Select(c.prefix.tree, TermName( name )), List( projection.tree ))
        ).asInstanceOf[Tree]
       )))
     c.universe.reify{ Queryable.factory[S]( foo.splice )}
diff --git a/test/files/run/macro-reify-nested-b/Impls_Macros_1.scala b/test/files/run/macro-reify-nested-b/Impls_Macros_1.scala
index b4351c2c53..bb6a45e11e 100644
--- a/test/files/run/macro-reify-nested-b/Impls_Macros_1.scala
+++ b/test/files/run/macro-reify-nested-b/Impls_Macros_1.scala
@@ -28,7 +28,7 @@ object QueryableMacros{
     val foo = c.Expr[ru.Expr[Queryable[S]]](
     c.reifyTree( mkRuntimeUniverseRef, EmptyTree, c.typeCheck(
       Utils[c.type](c).removeDoubleReify(
-        Apply(Select(c.prefix.tree, newTermName( name )), List( projection.tree ))
+        Apply(Select(c.prefix.tree, TermName( name )), List( projection.tree ))
        ).asInstanceOf[Tree]
       )))
     c.universe.reify{ Queryable.factory[S]( foo.splice )}
diff --git a/test/files/run/macro-reify-splice-outside-reify/Test_2.scala b/test/files/run/macro-reify-splice-outside-reify/Test_2.scala
index 54bd03fcd2..dbc17e7c15 100644
--- a/test/files/run/macro-reify-splice-outside-reify/Test_2.scala
+++ b/test/files/run/macro-reify-splice-outside-reify/Test_2.scala
@@ -2,7 +2,7 @@ object Test extends App {
   import scala.reflect.runtime.universe._
   import scala.reflect.runtime.{currentMirror => cm}
   import scala.tools.reflect.ToolBox
-  val tree = Apply(Select(Ident(newTermName("Macros")), newTermName("foo")), List(Literal(Constant(42))))
+  val tree = Apply(Select(Ident(TermName("Macros")), TermName("foo")), List(Literal(Constant(42))))
   try println(cm.mkToolBox().eval(tree))
   catch { case ex: Throwable =>  println(ex.getMessage) }
 }
diff --git a/test/files/run/macro-reify-tagless-a/Test_2.scala b/test/files/run/macro-reify-tagless-a/Test_2.scala
index 584c4bdf5b..afb418a755 100644
--- a/test/files/run/macro-reify-tagless-a/Test_2.scala
+++ b/test/files/run/macro-reify-tagless-a/Test_2.scala
@@ -6,9 +6,9 @@ object Test extends App {
   import scala.reflect.runtime.{currentMirror => cm}
   import scala.tools.reflect.ToolBox
   val tpt = AppliedTypeTree(Ident(definitions.ListClass), List(Ident(definitions.StringClass)))
-  val rhs = Apply(Select(Ident(newTermName("Macros")), newTermName("foo")), List(Literal(Constant("hello world"))))
-  val list = ValDef(NoMods, newTermName("list"), tpt, rhs)
-  val tree = Block(List(list), Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Ident(list.name))))
+  val rhs = Apply(Select(Ident(TermName("Macros")), TermName("foo")), List(Literal(Constant("hello world"))))
+  val list = ValDef(NoMods, TermName("list"), tpt, rhs)
+  val tree = Block(List(list), Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Ident(list.name))))
   try cm.mkToolBox().eval(tree)
   catch { case ex: Throwable =>  println(ex.getMessage) }
 }
diff --git a/test/files/run/macro-reify-type/Macros_1.scala b/test/files/run/macro-reify-type/Macros_1.scala
index 06de05735d..c4d1d9f8ad 100644
--- a/test/files/run/macro-reify-type/Macros_1.scala
+++ b/test/files/run/macro-reify-type/Macros_1.scala
@@ -8,7 +8,7 @@ object StaticReflect {
     import c.universe._
 
     val nameName: TermName = name.tree match {
-      case Literal(Constant(str: String)) => newTermName(str)
+      case Literal(Constant(str: String)) => TermName(str)
       case _                              => c.error(c.enclosingPosition, s"Method name not constant.") ; return reify(ru.NoType)
     }
     val clazz  = weakTypeOf[A]
@@ -17,8 +17,8 @@ object StaticReflect {
       case NoSymbol => c.error(c.enclosingPosition, s"No member called $nameName in $clazz.") ; reify(ru.NoType)
       case member   =>
         val mtpe  = member typeSignatureIn clazz
-        val mtag  = c.reifyType(treeBuild.mkRuntimeUniverseRef, Select(treeBuild.mkRuntimeUniverseRef, newTermName("rootMirror")), mtpe)
-        val mtree = Select(mtag, newTermName("tpe"))
+        val mtag  = c.reifyType(treeBuild.mkRuntimeUniverseRef, Select(treeBuild.mkRuntimeUniverseRef, TermName("rootMirror")), mtpe)
+        val mtree = Select(mtag, TermName("tpe"))
 
         c.Expr[ru.Type](mtree)
     }
diff --git a/test/files/run/macro-reify-type/Test_2.scala b/test/files/run/macro-reify-type/Test_2.scala
index 9beaf98681..1f35973531 100644
--- a/test/files/run/macro-reify-type/Test_2.scala
+++ b/test/files/run/macro-reify-type/Test_2.scala
@@ -7,10 +7,10 @@ object Test extends App {
   //val $m: $u.Mirror = scala.reflect.runtime.universe.rootMirror;
   //import $u._, $m._, Flag._
   //val tpe = {
-  //  val symdef$B2 = build.newNestedSymbol(build.selectTerm(staticClass("scala.collection.TraversableLike"), "map"), newTypeName("B"), NoPosition, DEFERRED | PARAM, false);
-  //  val symdef$That2 = build.newNestedSymbol(build.selectTerm(staticClass("scala.collection.TraversableLike"), "map"), newTypeName("That"), NoPosition, DEFERRED | PARAM, false);
-  //  val symdef$f2 = build.newNestedSymbol(build.selectTerm(staticClass("scala.collection.TraversableLike"), "map"), newTermName("f"), NoPosition, PARAM, false);
-  //  val symdef$bf2 = build.newNestedSymbol(build.selectTerm(staticClass("scala.collection.TraversableLike"), "map"), newTermName("bf"), NoPosition, IMPLICIT | PARAM, false);
+  //  val symdef$B2 = build.newNestedSymbol(build.selectTerm(staticClass("scala.collection.TraversableLike"), "map"), TypeName("B"), NoPosition, DEFERRED | PARAM, false);
+  //  val symdef$That2 = build.newNestedSymbol(build.selectTerm(staticClass("scala.collection.TraversableLike"), "map"), TypeName("That"), NoPosition, DEFERRED | PARAM, false);
+  //  val symdef$f2 = build.newNestedSymbol(build.selectTerm(staticClass("scala.collection.TraversableLike"), "map"), TermName("f"), NoPosition, PARAM, false);
+  //  val symdef$bf2 = build.newNestedSymbol(build.selectTerm(staticClass("scala.collection.TraversableLike"), "map"), TermName("bf"), NoPosition, IMPLICIT | PARAM, false);
   //  build.setTypeSignature(symdef$B2, TypeBounds(staticClass("scala.Nothing").asType.toTypeConstructor, staticClass("scala.Any").asType.toTypeConstructor));
   //  build.setTypeSignature(symdef$That2, TypeBounds(staticClass("scala.Nothing").asType.toTypeConstructor, staticClass("scala.Any").asType.toTypeConstructor));
   //  build.setTypeSignature(symdef$f2, TypeRef(ThisType(staticPackage("scala").asModule.moduleClass), staticClass("scala.Function1"), List(staticClass("scala.Int").asType.toTypeConstructor, TypeRef(NoPrefix, symdef$B2, List()))));
diff --git a/test/files/run/macro-reify-unreify/Macros_1.scala b/test/files/run/macro-reify-unreify/Macros_1.scala
index 9f04c13014..25ed352cca 100644
--- a/test/files/run/macro-reify-unreify/Macros_1.scala
+++ b/test/files/run/macro-reify-unreify/Macros_1.scala
@@ -9,7 +9,7 @@ object Macros {
       import treeBuild._
 
       val world = c.reifyTree(mkRuntimeUniverseRef, EmptyTree, s.tree)
-      val greeting = c.reifyTree(mkRuntimeUniverseRef, EmptyTree, c.typeCheck(Apply(Select(Literal(Constant("hello ")), newTermName("$plus")), List(c.unreifyTree(world)))))
+      val greeting = c.reifyTree(mkRuntimeUniverseRef, EmptyTree, c.typeCheck(Apply(Select(Literal(Constant("hello ")), TermName("$plus")), List(c.unreifyTree(world)))))
       val typedGreeting = c.Expr[String](greeting)
 
       c.universe.reify {
diff --git a/test/files/run/macro-repl-basic.check b/test/files/run/macro-repl-basic.check
index 7deed4a878..5323f429da 100644
--- a/test/files/run/macro-repl-basic.check
+++ b/test/files/run/macro-repl-basic.check
@@ -14,19 +14,19 @@ scala>
 scala> object Impls {
   def foo(c: Ctx)(x: c.Expr[Int]) = {
     import c.universe._
-    val body = Apply(Select(x.tree, newTermName("$plus")), List(Literal(Constant(1))))
+    val body = Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(1))))
     c.Expr[Int](body)
   }
 
   def bar(c: Ctx)(x: c.Expr[Int]) = {
     import c.universe._
-    val body = Apply(Select(x.tree, newTermName("$plus")), List(Literal(Constant(2))))
+    val body = Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(2))))
     c.Expr[Int](body)
   }
 
   def quux(c: Ctx)(x: c.Expr[Int]) = {
     import c.universe._
-    val body = Apply(Select(x.tree, newTermName("$plus")), List(Literal(Constant(3))))
+    val body = Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(3))))
     c.Expr[Int](body)
   }
 }
diff --git a/test/files/run/macro-repl-basic.scala b/test/files/run/macro-repl-basic.scala
index eae1febb3a..3c22c13dc7 100644
--- a/test/files/run/macro-repl-basic.scala
+++ b/test/files/run/macro-repl-basic.scala
@@ -8,19 +8,19 @@ object Test extends ReplTest {
     |object Impls {
     |  def foo(c: Ctx)(x: c.Expr[Int]) = {
     |    import c.universe._
-    |    val body = Apply(Select(x.tree, newTermName("$plus")), List(Literal(Constant(1))))
+    |    val body = Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(1))))
     |    c.Expr[Int](body)
     |  }
     |
     |  def bar(c: Ctx)(x: c.Expr[Int]) = {
     |    import c.universe._
-    |    val body = Apply(Select(x.tree, newTermName("$plus")), List(Literal(Constant(2))))
+    |    val body = Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(2))))
     |    c.Expr[Int](body)
     |  }
     |
     |  def quux(c: Ctx)(x: c.Expr[Int]) = {
     |    import c.universe._
-    |    val body = Apply(Select(x.tree, newTermName("$plus")), List(Literal(Constant(3))))
+    |    val body = Apply(Select(x.tree, TermName("$plus")), List(Literal(Constant(3))))
     |    c.Expr[Int](body)
     |  }
     |}
diff --git a/test/files/run/macro-typecheck-implicitsdisabled/Impls_Macros_1.scala b/test/files/run/macro-typecheck-implicitsdisabled/Impls_Macros_1.scala
index 633cb930fc..dbeb7efbc0 100644
--- a/test/files/run/macro-typecheck-implicitsdisabled/Impls_Macros_1.scala
+++ b/test/files/run/macro-typecheck-implicitsdisabled/Impls_Macros_1.scala
@@ -4,7 +4,7 @@ object Macros {
   def impl_with_implicits_enabled(c: Context) = {
     import c.universe._
 
-    val tree1 = Apply(Select(Literal(Constant(1)), newTermName("$minus$greater")), List(Literal(Constant(2))))
+    val tree1 = Apply(Select(Literal(Constant(1)), TermName("$minus$greater")), List(Literal(Constant(2))))
     val ttree1 = c.typeCheck(tree1, withImplicitViewsDisabled = false)
     c.literal(ttree1.toString)
   }
@@ -15,7 +15,7 @@ object Macros {
     import c.universe._
 
     try {
-      val tree2 = Apply(Select(Literal(Constant(1)), newTermName("$minus$greater")), List(Literal(Constant(2))))
+      val tree2 = Apply(Select(Literal(Constant(1)), TermName("$minus$greater")), List(Literal(Constant(2))))
       val ttree2 = c.typeCheck(tree2, withImplicitViewsDisabled = true)
       c.literal(ttree2.toString)
     } catch {
diff --git a/test/files/run/macro-typecheck-macrosdisabled/Impls_Macros_1.scala b/test/files/run/macro-typecheck-macrosdisabled/Impls_Macros_1.scala
index f693ad78cc..ff535fea8d 100644
--- a/test/files/run/macro-typecheck-macrosdisabled/Impls_Macros_1.scala
+++ b/test/files/run/macro-typecheck-macrosdisabled/Impls_Macros_1.scala
@@ -4,8 +4,8 @@ object Macros {
   def impl_with_macros_enabled(c: Context) = {
     import c.universe._
 
-    val ru = Select(Select(Select(Select(Ident(newTermName("scala")), newTermName("reflect")), newTermName("runtime")), newTermName("package")), newTermName("universe"))
-    val tree1 = Apply(Select(ru, newTermName("reify")), List(Literal(Constant(2))))
+    val ru = Select(Select(Select(Select(Ident(TermName("scala")), TermName("reflect")), TermName("runtime")), TermName("package")), TermName("universe"))
+    val tree1 = Apply(Select(ru, TermName("reify")), List(Literal(Constant(2))))
     val ttree1 = c.typeCheck(tree1, withMacrosDisabled = false)
     c.literal(ttree1.toString)
   }
@@ -21,7 +21,7 @@ object Macros {
     val ru = build.newFreeTerm("ru", scala.reflect.runtime.universe)
     build.setTypeSignature(ru, rutpe)
 
-    val tree2 = Apply(Select(Ident(ru), newTermName("reify")), List(Literal(Constant(2))))
+    val tree2 = Apply(Select(Ident(ru), TermName("reify")), List(Literal(Constant(2))))
     val ttree2 = c.typeCheck(tree2, withMacrosDisabled = true)
     c.literal(ttree2.toString)
   }
diff --git a/test/files/run/macro-typecheck-macrosdisabled2.check b/test/files/run/macro-typecheck-macrosdisabled2.check
index 7bdd1d6a3a..b958a95552 100644
--- a/test/files/run/macro-typecheck-macrosdisabled2.check
+++ b/test/files/run/macro-typecheck-macrosdisabled2.check
@@ -10,7 +10,7 @@
       def apply[U >: Nothing <: scala.reflect.api.Universe with Singleton]($m$untyped: scala.reflect.api.Mirror[U]): U#Tree = {
         val $u: U = $m$untyped.universe;
         val $m: $u.Mirror = $m$untyped.asInstanceOf[$u.Mirror];
-        $u.Apply.apply($u.Select.apply($u.Select.apply($u.build.Ident($m.staticPackage("scala")), $u.newTermName("Array")), $u.newTermName("apply")), scala.collection.immutable.List.apply[$u.Literal]($u.Literal.apply($u.Constant.apply(2))))
+        $u.Apply.apply($u.Select.apply($u.Select.apply($u.build.Ident($m.staticPackage("scala")), $u.TermName.apply("Array")), $u.TermName.apply("apply")), scala.collection.immutable.List.apply[$u.Literal]($u.Literal.apply($u.Constant.apply(2))))
       }
     };
     new $treecreator1()
diff --git a/test/files/run/macro-typecheck-macrosdisabled2/Impls_Macros_1.scala b/test/files/run/macro-typecheck-macrosdisabled2/Impls_Macros_1.scala
index 1dbf5a1a87..a96e0c53b6 100644
--- a/test/files/run/macro-typecheck-macrosdisabled2/Impls_Macros_1.scala
+++ b/test/files/run/macro-typecheck-macrosdisabled2/Impls_Macros_1.scala
@@ -4,8 +4,8 @@ object Macros {
   def impl_with_macros_enabled(c: Context) = {
     import c.universe._
 
-    val ru = Select(Select(Select(Select(Ident(newTermName("scala")), newTermName("reflect")), newTermName("runtime")), newTermName("package")), newTermName("universe"))
-    val tree1 = Apply(Select(ru, newTermName("reify")), List(Apply(Select(Ident(newTermName("scala")), newTermName("Array")), List(Literal(Constant(2))))))
+    val ru = Select(Select(Select(Select(Ident(TermName("scala")), TermName("reflect")), TermName("runtime")), TermName("package")), TermName("universe"))
+    val tree1 = Apply(Select(ru, TermName("reify")), List(Apply(Select(Ident(TermName("scala")), TermName("Array")), List(Literal(Constant(2))))))
     val ttree1 = c.typeCheck(tree1, withMacrosDisabled = false)
     c.literal(ttree1.toString)
   }
@@ -21,7 +21,7 @@ object Macros {
     val ru = build.newFreeTerm("ru", scala.reflect.runtime.universe)
     build.setTypeSignature(ru, rutpe)
 
-    val tree2 = Apply(Select(Ident(ru), newTermName("reify")), List(Apply(Select(Ident(newTermName("scala")), newTermName("Array")), List(Literal(Constant(2))))))
+    val tree2 = Apply(Select(Ident(ru), TermName("reify")), List(Apply(Select(Ident(TermName("scala")), TermName("Array")), List(Literal(Constant(2))))))
     val ttree2 = c.typeCheck(tree2, withMacrosDisabled = true)
     c.literal(ttree2.toString)
   }
diff --git a/test/files/run/patmat_unapp_abstype-old.check b/test/files/run/patmat_unapp_abstype-old.check
deleted file mode 100644
index 72239d16cd..0000000000
--- a/test/files/run/patmat_unapp_abstype-old.check
+++ /dev/null
@@ -1,4 +0,0 @@
-TypeRef
-none of the above
-Bar
-Foo
diff --git a/test/files/run/patmat_unapp_abstype-old.flags b/test/files/run/patmat_unapp_abstype-old.flags
deleted file mode 100644
index ba80cad69b..0000000000
--- a/test/files/run/patmat_unapp_abstype-old.flags
+++ /dev/null
@@ -1 +0,0 @@
--Xoldpatmat
diff --git a/test/files/run/patmat_unapp_abstype-old.scala b/test/files/run/patmat_unapp_abstype-old.scala
deleted file mode 100644
index 45496f08a2..0000000000
--- a/test/files/run/patmat_unapp_abstype-old.scala
+++ /dev/null
@@ -1,83 +0,0 @@
-// abstract types and extractors, oh my!
-trait TypesAPI {
-  trait Type
-
-  // an alternative fix (implemented in the virtual pattern matcher, is to replace the isInstanceOf by a manifest-based run-time test)
-  // that's what typeRefMani is for
-  type TypeRef <: Type //; implicit def typeRefMani: Manifest[TypeRef]
-  val TypeRef: TypeRefExtractor; trait TypeRefExtractor {
-    def apply(x: Int): TypeRef
-    def unapply(x: TypeRef): Option[(Int)]
-  }
-
-  // just for illustration, should follow the same pattern as TypeRef
-  case class MethodType(n: Int) extends Type
-}
-
-// user should not be exposed to the implementation
-trait TypesUser extends TypesAPI {
-  def shouldNotCrash(tp: Type): Unit = {
-    tp match {
-      case TypeRef(x) => println("TypeRef") 
-      // the above checks tp.isInstanceOf[TypeRef], which is erased to tp.isInstanceOf[Type]
-      //   before calling TypeRef.unapply(tp), which will then crash unless tp.isInstanceOf[TypesImpl#TypeRef] (which is not implied by tp.isInstanceOf[Type])
-      // tp.isInstanceOf[TypesImpl#TypeRef] is equivalent to classOf[TypesImpl#TypeRef].isAssignableFrom(tp.getClass)
-      // this is equivalent to manifest
-      // it is NOT equivalent to manifest[Type] <:< typeRefMani
-      case MethodType(x) => println("MethodType")
-      case _ => println("none of the above")
-    }
-  }
-}
-
-trait TypesImpl extends TypesAPI {
-  object TypeRef extends TypeRefExtractor  // this will have a bridged unapply(x: Type) = unapply(x.asInstanceOf[TypeRef])
-  case class TypeRef(n: Int) extends Type // this has a bridge from TypesAPI#Type to TypesImpl#TypeRef 
-  // --> the cast in the bridge will fail because the pattern matcher can't type test against the abstract types in TypesUser
-  //lazy val typeRefMani = manifest[TypeRef]
-}
-
-trait Foos {
- trait Bar
- type Foo <: Bar
- trait FooExtractor {
-   def unapply(foo: Foo): Option[Int]
- }
- val Foo: FooExtractor
-}
-
-trait RealFoos extends Foos {
- class Foo(val x: Int) extends Bar
- object Foo extends FooExtractor {
-   def unapply(foo: Foo): Option[Int] = Some(foo.x)
- }
-}
-
-trait Intermed extends Foos {
- def crash(bar: Bar): Unit =
-   bar match {
-     case Foo(x) => println("Foo")
-     case _ => println("Bar")
-   }
-}
-
-object TestUnappStaticallyKnownSynthetic extends TypesImpl with TypesUser {
-  def test() = {
-    shouldNotCrash(TypeRef(10)) // should and does print "TypeRef"
-    // once  #1697/#2337 are fixed, this should generate the correct output
-    shouldNotCrash(MethodType(10)) // should print "MethodType" but prints "none of the above" -- good one, pattern matcher!
-  }
-}
-
-object TestUnappDynamicSynth extends RealFoos with Intermed {
- case class FooToo(n: Int) extends Bar
- def test() = {
-   crash(FooToo(10))
-   crash(new Foo(5))
- }
-}
-
-object Test extends App {
-  TestUnappStaticallyKnownSynthetic.test()
-  TestUnappDynamicSynth.test()
-}
diff --git a/test/files/run/reflection-allmirrors-tostring.scala b/test/files/run/reflection-allmirrors-tostring.scala
index 73afff291c..0ca387a6b1 100644
--- a/test/files/run/reflection-allmirrors-tostring.scala
+++ b/test/files/run/reflection-allmirrors-tostring.scala
@@ -26,18 +26,18 @@ object Test extends App {
   println(cm.reflect(new C))
 
   val im = cm.reflect(new C)
-  println(im.reflectField(typeOf[C].member(newTermName("f1")).asTerm))
-  println(im.reflectField(typeOf[C].member(newTermName("f2")).asTerm))
-  println(im.reflectMethod(typeOf[C].member(newTermName("m1")).asMethod))
-  println(im.reflectMethod(typeOf[C].member(newTermName("m2")).asMethod))
-  println(im.reflectMethod(typeOf[C].member(newTermName("m3")).asMethod))
-  println(im.reflectMethod(typeOf[C].member(newTermName("m4")).asMethod))
-  println(im.reflectMethod(typeOf[C].member(newTermName("m5")).asMethod))
-  println(im.reflectClass(typeOf[C].member(newTypeName("C")).asClass))
-  println(im.reflectModule(typeOf[C].member(newTermName("M")).asModule))
+  println(im.reflectField(typeOf[C].member(TermName("f1")).asTerm))
+  println(im.reflectField(typeOf[C].member(TermName("f2")).asTerm))
+  println(im.reflectMethod(typeOf[C].member(TermName("m1")).asMethod))
+  println(im.reflectMethod(typeOf[C].member(TermName("m2")).asMethod))
+  println(im.reflectMethod(typeOf[C].member(TermName("m3")).asMethod))
+  println(im.reflectMethod(typeOf[C].member(TermName("m4")).asMethod))
+  println(im.reflectMethod(typeOf[C].member(TermName("m5")).asMethod))
+  println(im.reflectClass(typeOf[C].member(TypeName("C")).asClass))
+  println(im.reflectModule(typeOf[C].member(TermName("M")).asModule))
 
   val c = cm.staticClass("C")
-  val cc = typeOf[C].member(newTypeName("C")).asClass
+  val cc = typeOf[C].member(TypeName("C")).asClass
   println(cm.reflectClass(c).reflectConstructor(c.typeSignature.member(nme.CONSTRUCTOR).asMethod))
   println(im.reflectClass(cc).reflectConstructor(cc.typeSignature.member(nme.CONSTRUCTOR).asMethod))
 }
\ No newline at end of file
diff --git a/test/files/run/reflection-enclosed-basic.scala b/test/files/run/reflection-enclosed-basic.scala
index 1dcb6c2a27..7b9e0c20dc 100644
--- a/test/files/run/reflection-enclosed-basic.scala
+++ b/test/files/run/reflection-enclosed-basic.scala
@@ -12,7 +12,7 @@ private object B6 extends B2 { override def toString = "B6"; override def foo =
 object Test extends App {
   def testMethodInvocation(instance: Any) = {
     val instanceMirror = cm.reflect(instance)
-    val method = instanceMirror.symbol.typeSignature.declaration(newTermName("foo")).asMethod
+    val method = instanceMirror.symbol.typeSignature.declaration(TermName("foo")).asMethod
     val methodMirror = instanceMirror.reflectMethod(method)
     println(methodMirror())
   }
@@ -20,7 +20,7 @@ object Test extends App {
   def testNestedClass(name: String) = {
     val sym = cm.staticClass(name)
     println(sym)
-    val ctor = sym.typeSignature.declaration(newTermName("<init>")).asMethod
+    val ctor = sym.typeSignature.declaration(nme.CONSTRUCTOR).asMethod
     val ctorMirror = cm.reflectClass(sym).reflectConstructor(ctor)
     val instance = ctorMirror()
     println(instance)
diff --git a/test/files/run/reflection-enclosed-inner-basic.scala b/test/files/run/reflection-enclosed-inner-basic.scala
index 2b2c701993..c1cf9bc336 100644
--- a/test/files/run/reflection-enclosed-inner-basic.scala
+++ b/test/files/run/reflection-enclosed-inner-basic.scala
@@ -18,15 +18,15 @@ object Test extends App {
 
   def testMethodInvocation(instance: Any) = {
     val instanceMirror = cm.reflect(instance)
-    val method = instanceMirror.symbol.typeSignature.declaration(newTermName("foo")).asMethod
+    val method = instanceMirror.symbol.typeSignature.declaration(TermName("foo")).asMethod
     val methodMirror = instanceMirror.reflectMethod(method)
     println(methodMirror())
   }
 
   def testInnerClass(name: String) = {
-    val sym = b.typeSignature.declaration(newTypeName(name)).asClass
+    val sym = b.typeSignature.declaration(TypeName(name)).asClass
     println(sym)
-    val ctor = sym.typeSignature.declaration(newTermName("<init>")).asMethod
+    val ctor = sym.typeSignature.declaration(nme.CONSTRUCTOR).asMethod
     val ctorMirror = cm.reflect(new B).reflectClass(sym).reflectConstructor(ctor)
     val instance = ctorMirror()
     println(instance)
@@ -37,7 +37,7 @@ object Test extends App {
   testInnerClass("B2")
 
   def testInnerModule(name: String) = {
-    val sym = b.typeSignature.declaration(newTermName(name)).asModule
+    val sym = b.typeSignature.declaration(TermName(name)).asModule
     println(sym)
     val moduleMirror = cm.reflect(new B).reflectModule(sym)
     val instance = moduleMirror.instance
diff --git a/test/files/run/reflection-enclosed-inner-inner-basic.scala b/test/files/run/reflection-enclosed-inner-inner-basic.scala
index 1b9e19d37d..8a73fac522 100644
--- a/test/files/run/reflection-enclosed-inner-inner-basic.scala
+++ b/test/files/run/reflection-enclosed-inner-inner-basic.scala
@@ -20,15 +20,15 @@ object Test extends App {
 
   def testMethodInvocation(instance: Any) = {
     val instanceMirror = cm.reflect(instance)
-    val method = instanceMirror.symbol.typeSignature.declaration(newTermName("foo")).asMethod
+    val method = instanceMirror.symbol.typeSignature.declaration(TermName("foo")).asMethod
     val methodMirror = instanceMirror.reflectMethod(method)
     println(methodMirror())
   }
 
   def testInnerClass(name: String) = {
-    val sym = b.typeSignature.declaration(newTypeName(name)).asClass
+    val sym = b.typeSignature.declaration(TypeName(name)).asClass
     println(sym)
-    val ctor = sym.typeSignature.declaration(newTermName("<init>")).asMethod
+    val ctor = sym.typeSignature.declaration(nme.CONSTRUCTOR).asMethod
     val outer1 = new B
     val outer2 = new outer1.BB
     val ctorMirror = cm.reflect(outer2).reflectClass(sym).reflectConstructor(ctor)
@@ -41,7 +41,7 @@ object Test extends App {
   testInnerClass("B2")
 
   def testInnerModule(name: String) = {
-    val sym = b.typeSignature.declaration(newTermName(name)).asModule
+    val sym = b.typeSignature.declaration(TermName(name)).asModule
     println(sym)
     val outer1 = new B
     val outer2 = new outer1.BB
diff --git a/test/files/run/reflection-enclosed-inner-nested-basic.scala b/test/files/run/reflection-enclosed-inner-nested-basic.scala
index 2800ee2548..6c2fc6df7a 100644
--- a/test/files/run/reflection-enclosed-inner-nested-basic.scala
+++ b/test/files/run/reflection-enclosed-inner-nested-basic.scala
@@ -21,15 +21,15 @@ object Test extends App {
 
   def testMethodInvocation(instance: Any) = {
     val instanceMirror = cm.reflect(instance)
-    val method = instanceMirror.symbol.typeSignature.declaration(newTermName("foo")).asMethod
+    val method = instanceMirror.symbol.typeSignature.declaration(TermName("foo")).asMethod
     val methodMirror = instanceMirror.reflectMethod(method)
     println(methodMirror())
   }
 
   def testNestedClass(name: String) = {
-    val sym = b.typeSignature.declaration(newTypeName(name)).asClass
+    val sym = b.typeSignature.declaration(TypeName(name)).asClass
     println(sym)
-    val ctor = sym.typeSignature.declaration(newTermName("<init>")).asMethod
+    val ctor = sym.typeSignature.declaration(nme.CONSTRUCTOR).asMethod
     val ctorMirror = cm.reflect(outer1.BB).reflectClass(sym).reflectConstructor(ctor)
     val instance = ctorMirror()
     println(instance)
@@ -40,7 +40,7 @@ object Test extends App {
   testNestedClass("B2")
 
   def testNestedModule(name: String) = {
-    val sym = b.typeSignature.declaration(newTermName(name)).asModule
+    val sym = b.typeSignature.declaration(TermName(name)).asModule
     println(sym)
     val moduleMirror = cm.reflect(outer1.BB).reflectModule(sym)
     val instance = moduleMirror.instance
diff --git a/test/files/run/reflection-enclosed-nested-basic.scala b/test/files/run/reflection-enclosed-nested-basic.scala
index 8b740c2da2..180ac4ebee 100644
--- a/test/files/run/reflection-enclosed-nested-basic.scala
+++ b/test/files/run/reflection-enclosed-nested-basic.scala
@@ -18,15 +18,15 @@ object Test extends App {
 
   def testMethodInvocation(instance: Any) = {
     val instanceMirror = cm.reflect(instance)
-    val method = instanceMirror.symbol.typeSignature.declaration(newTermName("foo")).asMethod
+    val method = instanceMirror.symbol.typeSignature.declaration(TermName("foo")).asMethod
     val methodMirror = instanceMirror.reflectMethod(method)
     println(methodMirror())
   }
 
   def testNestedClass(name: String) = {
-    val sym = b.typeSignature.declaration(newTypeName(name)).asClass
+    val sym = b.typeSignature.declaration(TypeName(name)).asClass
     println(sym)
-    val ctor = sym.typeSignature.declaration(newTermName("<init>")).asMethod
+    val ctor = sym.typeSignature.declaration(nme.CONSTRUCTOR).asMethod
     val ctorMirror = cm.reflectClass(sym).reflectConstructor(ctor)
     val instance = ctorMirror()
     println(instance)
@@ -37,7 +37,7 @@ object Test extends App {
   testNestedClass("B2")
 
   def testNestedModule(name: String) = {
-    val sym = b.typeSignature.declaration(newTermName(name)).asModule
+    val sym = b.typeSignature.declaration(TermName(name)).asModule
     println(sym)
     val moduleMirror = cm.reflectModule(sym)
     val instance = moduleMirror.instance
diff --git a/test/files/run/reflection-enclosed-nested-inner-basic.scala b/test/files/run/reflection-enclosed-nested-inner-basic.scala
index 7466733d37..2558b8035a 100644
--- a/test/files/run/reflection-enclosed-nested-inner-basic.scala
+++ b/test/files/run/reflection-enclosed-nested-inner-basic.scala
@@ -20,15 +20,15 @@ object Test extends App {
 
   def testMethodInvocation(instance: Any) = {
     val instanceMirror = cm.reflect(instance)
-    val method = instanceMirror.symbol.typeSignature.declaration(newTermName("foo")).asMethod
+    val method = instanceMirror.symbol.typeSignature.declaration(TermName("foo")).asMethod
     val methodMirror = instanceMirror.reflectMethod(method)
     println(methodMirror())
   }
 
   def testInnerClass(name: String) = {
-    val sym = b.typeSignature.declaration(newTypeName(name)).asClass
+    val sym = b.typeSignature.declaration(TypeName(name)).asClass
     println(sym)
-    val ctor = sym.typeSignature.declaration(newTermName("<init>")).asMethod
+    val ctor = sym.typeSignature.declaration(nme.CONSTRUCTOR).asMethod
     val ctorMirror = cm.reflect(new B.BB).reflectClass(sym).reflectConstructor(ctor)
     val instance = ctorMirror()
     println(instance)
@@ -39,7 +39,7 @@ object Test extends App {
   testInnerClass("B2")
 
   def testInnerModule(name: String) = {
-    val sym = b.typeSignature.declaration(newTermName(name)).asModule
+    val sym = b.typeSignature.declaration(TermName(name)).asModule
     println(sym)
     val moduleMirror = cm.reflect(new B.BB).reflectModule(sym)
     val instance = moduleMirror.instance
diff --git a/test/files/run/reflection-enclosed-nested-nested-basic.scala b/test/files/run/reflection-enclosed-nested-nested-basic.scala
index 8335ea482a..b4711c9a8c 100644
--- a/test/files/run/reflection-enclosed-nested-nested-basic.scala
+++ b/test/files/run/reflection-enclosed-nested-nested-basic.scala
@@ -20,15 +20,15 @@ object Test extends App {
 
   def testMethodInvocation(instance: Any) = {
     val instanceMirror = cm.reflect(instance)
-    val method = instanceMirror.symbol.typeSignature.declaration(newTermName("foo")).asMethod
+    val method = instanceMirror.symbol.typeSignature.declaration(TermName("foo")).asMethod
     val methodMirror = instanceMirror.reflectMethod(method)
     println(methodMirror())
   }
 
   def testNestedClass(name: String) = {
-    val sym = b.typeSignature.declaration(newTypeName(name)).asClass
+    val sym = b.typeSignature.declaration(TypeName(name)).asClass
     println(sym)
-    val ctor = sym.typeSignature.declaration(newTermName("<init>")).asMethod
+    val ctor = sym.typeSignature.declaration(nme.CONSTRUCTOR).asMethod
     val ctorMirror = cm.reflectClass(sym).reflectConstructor(ctor)
     val instance = ctorMirror()
     println(instance)
@@ -39,7 +39,7 @@ object Test extends App {
   testNestedClass("B2")
 
   def testNestedModule(name: String) = {
-    val sym = b.typeSignature.declaration(newTermName(name)).asModule
+    val sym = b.typeSignature.declaration(TermName(name)).asModule
     println(sym)
     val moduleMirror = cm.reflectModule(sym)
     val instance = moduleMirror.instance
diff --git a/test/files/run/reflection-equality.check b/test/files/run/reflection-equality.check
index 17c1f6dd70..b3b66f48d6 100644
--- a/test/files/run/reflection-equality.check
+++ b/test/files/run/reflection-equality.check
@@ -24,12 +24,12 @@ cs: reflect.runtime.universe.ClassSymbol = class X
 
 scala> val ts: Type = cs.typeSignature
 ts: reflect.runtime.universe.Type = 
-java.lang.Object {
+scala.AnyRef {
   def <init>(): X
   def methodIntIntInt(x: scala.Int,y: scala.Int): scala.Int
 }
 
-scala> val ms: MethodSymbol = ts.declaration(newTermName("methodIntIntInt")).asMethod
+scala> val ms: MethodSymbol = ts.declaration(TermName("methodIntIntInt")).asMethod
 ms: reflect.runtime.universe.MethodSymbol = method methodIntIntInt
 
 scala> val MethodType( _, t1 ) = ms.typeSignature
diff --git a/test/files/run/reflection-equality.scala b/test/files/run/reflection-equality.scala
index 8fc82721e7..40f116bb53 100644
--- a/test/files/run/reflection-equality.scala
+++ b/test/files/run/reflection-equality.scala
@@ -11,7 +11,7 @@ object Test extends ReplTest {
     |def im: InstanceMirror = cm.reflect(new X)
     |val cs: ClassSymbol = im.symbol
     |val ts: Type = cs.typeSignature
-    |val ms: MethodSymbol = ts.declaration(newTermName("methodIntIntInt")).asMethod
+    |val ms: MethodSymbol = ts.declaration(TermName("methodIntIntInt")).asMethod
     |val MethodType( _, t1 ) = ms.typeSignature
     |val t2 = typeOf[scala.Int]
     |t1 == t2
diff --git a/test/files/run/reflection-fieldmirror-accessorsareokay.scala b/test/files/run/reflection-fieldmirror-accessorsareokay.scala
index 16354025f3..3926ab7835 100644
--- a/test/files/run/reflection-fieldmirror-accessorsareokay.scala
+++ b/test/files/run/reflection-fieldmirror-accessorsareokay.scala
@@ -24,6 +24,6 @@ object Test extends App {
     }
   }
 
-  test(cs.typeSignature.declaration(newTermName("x")).asTerm)
-  test(cs.typeSignature.declaration(newTermName("x_$eq")).asTerm)
+  test(cs.typeSignature.declaration(TermName("x")).asTerm)
+  test(cs.typeSignature.declaration(TermName("x_$eq")).asTerm)
 }
diff --git a/test/files/run/reflection-fieldmirror-ctorparam.scala b/test/files/run/reflection-fieldmirror-ctorparam.scala
index b9d50fe97b..608adad27b 100644
--- a/test/files/run/reflection-fieldmirror-ctorparam.scala
+++ b/test/files/run/reflection-fieldmirror-ctorparam.scala
@@ -10,7 +10,7 @@ object Test extends App {
 
   val im: InstanceMirror = cm.reflect(a)
   val cs = im.symbol
-  val f = cs.typeSignature.declaration(newTermName("x")).asTerm
+  val f = cs.typeSignature.declaration(TermName("x")).asTerm
   try {
     val fm: FieldMirror = im.reflectField(f)
     println(fm.get)
diff --git a/test/files/run/reflection-fieldmirror-getsetval.scala b/test/files/run/reflection-fieldmirror-getsetval.scala
index 67c54d9708..9cacb7080b 100644
--- a/test/files/run/reflection-fieldmirror-getsetval.scala
+++ b/test/files/run/reflection-fieldmirror-getsetval.scala
@@ -10,7 +10,7 @@ object Test extends App {
 
   val im: InstanceMirror = cm.reflect(a)
   val cs = im.symbol
-  val f = cs.typeSignature.declaration(newTermName("x" + nme.LOCAL_SUFFIX_STRING)).asTerm
+  val f = cs.typeSignature.declaration(TermName("x" + nme.LOCAL_SUFFIX_STRING)).asTerm
   val fm: FieldMirror = im.reflectField(f)
   try {
     println(fm.get)
diff --git a/test/files/run/reflection-fieldmirror-getsetvar.scala b/test/files/run/reflection-fieldmirror-getsetvar.scala
index abcf396dd1..52c13a73bb 100644
--- a/test/files/run/reflection-fieldmirror-getsetvar.scala
+++ b/test/files/run/reflection-fieldmirror-getsetvar.scala
@@ -10,7 +10,7 @@ object Test extends App {
 
   val im: InstanceMirror = cm.reflect(a)
   val cs = im.symbol
-  val f = cs.typeSignature.declaration(newTermName("x" + nme.LOCAL_SUFFIX_STRING)).asTerm
+  val f = cs.typeSignature.declaration(TermName("x" + nme.LOCAL_SUFFIX_STRING)).asTerm
   val fm: FieldMirror = im.reflectField(f)
   println(fm.get)
   fm.set(2)
diff --git a/test/files/run/reflection-fieldmirror-nmelocalsuffixstring.scala b/test/files/run/reflection-fieldmirror-nmelocalsuffixstring.scala
index 2b4a9bb55e..e070cdcfa3 100644
--- a/test/files/run/reflection-fieldmirror-nmelocalsuffixstring.scala
+++ b/test/files/run/reflection-fieldmirror-nmelocalsuffixstring.scala
@@ -10,7 +10,7 @@ object Test extends App {
 
   val im: InstanceMirror = cm.reflect(a)
   val cs = im.symbol
-  val f = cs.typeSignature.declaration(newTermName("x" + nme.LOCAL_SUFFIX_STRING)).asTerm
+  val f = cs.typeSignature.declaration(TermName("x" + nme.LOCAL_SUFFIX_STRING)).asTerm
   val fm: FieldMirror = im.reflectField(f)
   println(fm.symbol.isVar)
 }
diff --git a/test/files/run/reflection-fieldmirror-privatethis.scala b/test/files/run/reflection-fieldmirror-privatethis.scala
index ab838dbb1b..89948772b1 100644
--- a/test/files/run/reflection-fieldmirror-privatethis.scala
+++ b/test/files/run/reflection-fieldmirror-privatethis.scala
@@ -10,7 +10,7 @@ object Test extends App {
 
   val im: InstanceMirror = cm.reflect(a)
   val cs = im.symbol
-  val f = cs.typeSignature.declaration(newTermName("x")).asTerm
+  val f = cs.typeSignature.declaration(TermName("x")).asTerm
   val fm: FieldMirror = im.reflectField(f)
   println(fm.symbol.isVar)
   println(fm.get)
diff --git a/test/files/run/reflection-fieldsymbol-navigation.scala b/test/files/run/reflection-fieldsymbol-navigation.scala
index 4448724988..33dc18a7e3 100644
--- a/test/files/run/reflection-fieldsymbol-navigation.scala
+++ b/test/files/run/reflection-fieldsymbol-navigation.scala
@@ -5,7 +5,7 @@ class C {
 }
 
 object Test extends App {
-  val x = typeOf[C].member(newTermName("x")).asTerm
+  val x = typeOf[C].member(TermName("x")).asTerm
   println(x)
   println(x.isVar)
   println(x.accessed)
diff --git a/test/files/run/reflection-implClass.scala b/test/files/run/reflection-implClass.scala
index b3c0081ccf..db211fd9a8 100644
--- a/test/files/run/reflection-implClass.scala
+++ b/test/files/run/reflection-implClass.scala
@@ -10,19 +10,19 @@ object Test extends App with Outer {
   import scala.reflect.runtime.universe._
   import scala.reflect.runtime.{currentMirror => cm}
 
-  assert(cm.classSymbol(classTag[Foo].runtimeClass).typeSignature.declaration(newTermName("bar")).typeSignature ==
-    cm.classSymbol(classTag[Bar].runtimeClass).typeSignature.declaration(newTermName("foo")).typeSignature)
+  assert(cm.classSymbol(classTag[Foo].runtimeClass).typeSignature.declaration(TermName("bar")).typeSignature ==
+    cm.classSymbol(classTag[Bar].runtimeClass).typeSignature.declaration(TermName("foo")).typeSignature)
 
   val s1 = implClass(classTag[Foo].runtimeClass)
   assert(s1 != NoSymbol)
   assert(s1.typeSignature != NoType)
   assert(s1.companionSymbol.typeSignature != NoType)
-  assert(s1.companionSymbol.typeSignature.declaration(newTermName("bar")) != NoSymbol)
+  assert(s1.companionSymbol.typeSignature.declaration(TermName("bar")) != NoSymbol)
   val s2 = implClass(classTag[Bar].runtimeClass)
   assert(s2 != NoSymbol)
   assert(s2.typeSignature != NoType)
   assert(s2.companionSymbol.typeSignature != NoType)
-  assert(s2.companionSymbol.typeSignature.declaration(newTermName("foo")) != NoSymbol)
+  assert(s2.companionSymbol.typeSignature.declaration(TermName("foo")) != NoSymbol)
   def implClass(clazz: Class[_]) = {
     val implClass = Class.forName(clazz.getName + "$class")
     cm.classSymbol(implClass)
diff --git a/test/files/run/reflection-magicsymbols-invoke.scala b/test/files/run/reflection-magicsymbols-invoke.scala
index 5f39370708..ff3992709f 100644
--- a/test/files/run/reflection-magicsymbols-invoke.scala
+++ b/test/files/run/reflection-magicsymbols-invoke.scala
@@ -28,7 +28,7 @@ object Test extends App {
         val ctor = tpe.declaration(nme.CONSTRUCTOR).asMethod
         cm.reflectClass(ctor.owner.asClass).reflectConstructor(ctor)(args: _*)
       } else {
-        val meth = tpe.declaration(newTermName(method).encodedName.toTermName).asMethod
+        val meth = tpe.declaration(TermName(method).encodedName.toTermName).asMethod
         cm.reflect(receiver).reflectMethod(meth)(args: _*)
       }
     })
@@ -54,7 +54,7 @@ object Test extends App {
   println("it's important to print the list of AnyVal's members")
   println("if some of them change (possibly, adding and/or removing magic symbols), we must update this test")
   typeOf[AnyVal].declarations.toList.sortBy(key).foreach(sym => println(key(sym)))
-  test(typeOf[AnyVal], null, "<init>")
+  test(typeOf[AnyVal], null, nme.CONSTRUCTOR.toString)
   test(typeOf[AnyVal], 2, "getClass")
 
   println("============\nAnyRef")
diff --git a/test/files/run/reflection-magicsymbols-repl.check b/test/files/run/reflection-magicsymbols-repl.check
index d3cd26f25f..85a1f63f01 100644
--- a/test/files/run/reflection-magicsymbols-repl.check
+++ b/test/files/run/reflection-magicsymbols-repl.check
@@ -19,7 +19,7 @@ scala> class A {
 defined class A
 
 scala> def test(n: Int): Unit = {
-  val sig = typeOf[A] member newTermName("foo" + n) typeSignature
+  val sig = typeOf[A] member TermName("foo" + n) typeSignature
   val x = sig.asInstanceOf[MethodType].params.head
   println(x.typeSignature)
 }
diff --git a/test/files/run/reflection-magicsymbols-repl.scala b/test/files/run/reflection-magicsymbols-repl.scala
index 26127b8661..6a432c2664 100644
--- a/test/files/run/reflection-magicsymbols-repl.scala
+++ b/test/files/run/reflection-magicsymbols-repl.scala
@@ -14,7 +14,7 @@ object Test extends ReplTest {
     |  def foo8(x: Singleton) = ???
     |}
     |def test(n: Int): Unit = {
-    |  val sig = typeOf[A] member newTermName("foo" + n) typeSignature
+    |  val sig = typeOf[A] member TermName("foo" + n) typeSignature
     |  val x = sig.asInstanceOf[MethodType].params.head
     |  println(x.typeSignature)
     |}
diff --git a/test/files/run/reflection-magicsymbols-vanilla.scala b/test/files/run/reflection-magicsymbols-vanilla.scala
index 32819dcc46..26b70460eb 100644
--- a/test/files/run/reflection-magicsymbols-vanilla.scala
+++ b/test/files/run/reflection-magicsymbols-vanilla.scala
@@ -12,7 +12,7 @@ class A {
 object Test extends App {
   import scala.reflect.runtime.universe._
   def test(n: Int): Unit = {
-    val sig = typeOf[A] member newTermName("foo" + n) typeSignature
+    val sig = typeOf[A] member TermName("foo" + n) typeSignature
     val x = sig.asInstanceOf[MethodType].params.head
     println(x.typeSignature)
   }
diff --git a/test/files/run/reflection-methodsymbol-params.scala b/test/files/run/reflection-methodsymbol-params.scala
index 45b1f9628f..baad8d6b9b 100644
--- a/test/files/run/reflection-methodsymbol-params.scala
+++ b/test/files/run/reflection-methodsymbol-params.scala
@@ -13,12 +13,12 @@ class C {
 }
 
 object Test extends App {
-  println(typeOf[C].member(newTermName("x1")).asMethod.paramss)
-  println(typeOf[C].member(newTermName("x2")).asMethod.paramss)
-  println(typeOf[C].member(newTermName("x3")).asMethod.paramss)
-  println(typeOf[C].member(newTermName("x4")).asMethod.paramss)
-  println(typeOf[C].member(newTermName("y1")).asMethod.paramss)
-  println(typeOf[C].member(newTermName("y2")).asMethod.paramss)
-  println(typeOf[C].member(newTermName("y3")).asMethod.paramss)
-  println(typeOf[C].member(newTermName("y4")).asMethod.paramss)
+  println(typeOf[C].member(TermName("x1")).asMethod.paramss)
+  println(typeOf[C].member(TermName("x2")).asMethod.paramss)
+  println(typeOf[C].member(TermName("x3")).asMethod.paramss)
+  println(typeOf[C].member(TermName("x4")).asMethod.paramss)
+  println(typeOf[C].member(TermName("y1")).asMethod.paramss)
+  println(typeOf[C].member(TermName("y2")).asMethod.paramss)
+  println(typeOf[C].member(TermName("y3")).asMethod.paramss)
+  println(typeOf[C].member(TermName("y4")).asMethod.paramss)
 }
\ No newline at end of file
diff --git a/test/files/run/reflection-methodsymbol-returntype.scala b/test/files/run/reflection-methodsymbol-returntype.scala
index 392754dbe4..74a9e5dac0 100644
--- a/test/files/run/reflection-methodsymbol-returntype.scala
+++ b/test/files/run/reflection-methodsymbol-returntype.scala
@@ -13,12 +13,12 @@ class C {
 }
 
 object Test extends App {
-  println(typeOf[C].member(newTermName("x1")).asMethod.returnType)
-  println(typeOf[C].member(newTermName("x2")).asMethod.returnType)
-  println(typeOf[C].member(newTermName("x3")).asMethod.returnType)
-  println(typeOf[C].member(newTermName("x4")).asMethod.returnType)
-  println(typeOf[C].member(newTermName("y1")).asMethod.returnType)
-  println(typeOf[C].member(newTermName("y2")).asMethod.returnType)
-  println(typeOf[C].member(newTermName("y3")).asMethod.returnType)
-  println(typeOf[C].member(newTermName("y4")).asMethod.returnType)
+  println(typeOf[C].member(TermName("x1")).asMethod.returnType)
+  println(typeOf[C].member(TermName("x2")).asMethod.returnType)
+  println(typeOf[C].member(TermName("x3")).asMethod.returnType)
+  println(typeOf[C].member(TermName("x4")).asMethod.returnType)
+  println(typeOf[C].member(TermName("y1")).asMethod.returnType)
+  println(typeOf[C].member(TermName("y2")).asMethod.returnType)
+  println(typeOf[C].member(TermName("y3")).asMethod.returnType)
+  println(typeOf[C].member(TermName("y4")).asMethod.returnType)
 }
\ No newline at end of file
diff --git a/test/files/run/reflection-methodsymbol-typeparams.scala b/test/files/run/reflection-methodsymbol-typeparams.scala
index bb0a3c3aec..56d37ebeaa 100644
--- a/test/files/run/reflection-methodsymbol-typeparams.scala
+++ b/test/files/run/reflection-methodsymbol-typeparams.scala
@@ -13,12 +13,12 @@ class C {
 }
 
 object Test extends App {
-  println(typeOf[C].member(newTermName("x1")).asMethod.typeParams)
-  println(typeOf[C].member(newTermName("x2")).asMethod.typeParams)
-  println(typeOf[C].member(newTermName("x3")).asMethod.typeParams)
-  println(typeOf[C].member(newTermName("x4")).asMethod.typeParams)
-  println(typeOf[C].member(newTermName("y1")).asMethod.typeParams)
-  println(typeOf[C].member(newTermName("y2")).asMethod.typeParams)
-  println(typeOf[C].member(newTermName("y3")).asMethod.typeParams)
-  println(typeOf[C].member(newTermName("y4")).asMethod.typeParams)
+  println(typeOf[C].member(TermName("x1")).asMethod.typeParams)
+  println(typeOf[C].member(TermName("x2")).asMethod.typeParams)
+  println(typeOf[C].member(TermName("x3")).asMethod.typeParams)
+  println(typeOf[C].member(TermName("x4")).asMethod.typeParams)
+  println(typeOf[C].member(TermName("y1")).asMethod.typeParams)
+  println(typeOf[C].member(TermName("y2")).asMethod.typeParams)
+  println(typeOf[C].member(TermName("y3")).asMethod.typeParams)
+  println(typeOf[C].member(TermName("y4")).asMethod.typeParams)
 }
\ No newline at end of file
diff --git a/test/files/run/reflection-repl-classes.check b/test/files/run/reflection-repl-classes.check
index 2dd96a93bf..606d67ce5e 100644
--- a/test/files/run/reflection-repl-classes.check
+++ b/test/files/run/reflection-repl-classes.check
@@ -19,7 +19,7 @@ scala> object defs {
   val cm = reflect.runtime.currentMirror
   val u = cm.universe
   val im = cm.reflect(new B)
-  val method = im.symbol.typeSignature.member(u.newTermName("foo")).asMethod
+  val method = im.symbol.typeSignature.member(u.TermName("foo")).asMethod
   val mm = im.reflectMethod(method)
 }
 defined module defs
diff --git a/test/files/run/reflection-repl-classes.scala b/test/files/run/reflection-repl-classes.scala
index 80e332cde3..4bfb980498 100644
--- a/test/files/run/reflection-repl-classes.scala
+++ b/test/files/run/reflection-repl-classes.scala
@@ -12,7 +12,7 @@ object Test extends ReplTest {
     |  val cm = reflect.runtime.currentMirror
     |  val u = cm.universe
     |  val im = cm.reflect(new B)
-    |  val method = im.symbol.typeSignature.member(u.newTermName("foo")).asMethod
+    |  val method = im.symbol.typeSignature.member(u.TermName("foo")).asMethod
     |  val mm = im.reflectMethod(method)
     |}
     |import defs._
diff --git a/test/files/run/reflection-sanitychecks.scala b/test/files/run/reflection-sanitychecks.scala
index f817f23731..6d3daff1f7 100644
--- a/test/files/run/reflection-sanitychecks.scala
+++ b/test/files/run/reflection-sanitychecks.scala
@@ -32,14 +32,14 @@ object Test extends App {
   def test(tpe: Type): Unit = {
     def failsafe(action: => Any): Any = try action catch { case ex: Throwable => ex.toString }
     println(s"=========members of ${tpe.typeSymbol.name} in a mirror of D=========")
-    println("field #1: " + failsafe(im.reflectField(tpe.member(newTermName("foo")).asTerm).get))
-    println("method #1: " + failsafe(im.reflectMethod(tpe.member(newTermName("bar")).asMethod)()))
-    println("field #2: " + failsafe(im.reflectField(tpe.member(newTermName("quux")).asTerm).get))
-    println("method #2: " + failsafe(im.reflectMethod(tpe.member(newTermName("baz")).asMethod)()))
-    println("constructor #1: " + failsafe(cm.reflectClass(im.symbol).reflectConstructor(tpe.member(newTermName("bar")).asMethod)()))
-    println("constructor #2: " + failsafe(cm.reflectClass(im.symbol).reflectConstructor(tpe.member(newTermName("<init>")).asMethod)()))
-    println("class: " + failsafe(im.reflectClass(tpe.member(newTypeName("C")).asClass).reflectConstructor(typeOf[C].member(newTypeName("C")).asClass.typeSignature.member(newTermName("<init>")).asMethod)()))
-    println("object: " + failsafe(im.reflectModule(tpe.member(newTermName("O")).asModule).instance))
+    println("field #1: " + failsafe(im.reflectField(tpe.member(TermName("foo")).asTerm).get))
+    println("method #1: " + failsafe(im.reflectMethod(tpe.member(TermName("bar")).asMethod)()))
+    println("field #2: " + failsafe(im.reflectField(tpe.member(TermName("quux")).asTerm).get))
+    println("method #2: " + failsafe(im.reflectMethod(tpe.member(TermName("baz")).asMethod)()))
+    println("constructor #1: " + failsafe(cm.reflectClass(im.symbol).reflectConstructor(tpe.member(TermName("bar")).asMethod)()))
+    println("constructor #2: " + failsafe(cm.reflectClass(im.symbol).reflectConstructor(tpe.member(TermName("<init>")).asMethod)()))
+    println("class: " + failsafe(im.reflectClass(tpe.member(TypeName("C")).asClass).reflectConstructor(typeOf[C].member(TypeName("C")).asClass.typeSignature.member(nme.CONSTRUCTOR).asMethod)()))
+    println("object: " + failsafe(im.reflectModule(tpe.member(TermName("O")).asModule).instance))
     println()
   }
 
diff --git a/test/files/run/reflection-valueclasses-derived.scala b/test/files/run/reflection-valueclasses-derived.scala
index 6b08f987ba..8d25e2929c 100644
--- a/test/files/run/reflection-valueclasses-derived.scala
+++ b/test/files/run/reflection-valueclasses-derived.scala
@@ -6,7 +6,7 @@ class C(val x: Int) extends AnyVal {
 }
 
 object Test extends App {
-  println(cm.reflect(new C(2)).reflectMethod(typeOf[C].member(newTermName("foo")).asMethod)(2))
-  println(cm.reflect(new C(2)).reflectMethod(typeOf[C].member(newTermName("getClass")).asMethod)())
-  println(cm.reflect(new C(2)).reflectMethod(typeOf[C].member(newTermName("toString")).asMethod)())
+  println(cm.reflect(new C(2)).reflectMethod(typeOf[C].member(TermName("foo")).asMethod)(2))
+  println(cm.reflect(new C(2)).reflectMethod(typeOf[C].member(TermName("getClass")).asMethod)())
+  println(cm.reflect(new C(2)).reflectMethod(typeOf[C].member(TermName("toString")).asMethod)())
 }
\ No newline at end of file
diff --git a/test/files/run/reflection-valueclasses-magic.scala b/test/files/run/reflection-valueclasses-magic.scala
index c4a26e460a..33d4634397 100644
--- a/test/files/run/reflection-valueclasses-magic.scala
+++ b/test/files/run/reflection-valueclasses-magic.scala
@@ -44,7 +44,7 @@ object Test extends App {
           val realex = scala.ExceptionUtils.unwrapThrowable(ex)
           println(realex.getClass + ": " + realex.getMessage)
       }
-    val meth = tpe.declaration(newTermName(method).encodedName.toTermName)
+    val meth = tpe.declaration(TermName(method).encodedName.toTermName)
     val testees = if (meth.isMethod) List(meth.asMethod) else meth.asTerm.alternatives.map(_.asMethod)
     testees foreach (testee => {
       val convertedArgs = args.zipWithIndex.map { case (arg, i) => convert(arg, testee.paramss.flatten.apply(i).typeSignature) }
diff --git a/test/files/run/reflection-valueclasses-standard.scala b/test/files/run/reflection-valueclasses-standard.scala
index 18a3d1fa04..b6b5a2ede2 100644
--- a/test/files/run/reflection-valueclasses-standard.scala
+++ b/test/files/run/reflection-valueclasses-standard.scala
@@ -5,8 +5,8 @@ import scala.reflect.{ClassTag, classTag}
 object Test extends App {
   def test[T: ClassTag: TypeTag](x: T) = {
     println(s"========${classTag[T].runtimeClass}========")
-    println(cm.reflect(x).reflectMethod(typeOf[T].member(newTermName("getClass")).asMethod)())
-    println(cm.reflect(x).reflectMethod(typeOf[T].member(newTermName("toString")).asMethod)())
+    println(cm.reflect(x).reflectMethod(typeOf[T].member(TermName("getClass")).asMethod)())
+    println(cm.reflect(x).reflectMethod(typeOf[T].member(TermName("toString")).asMethod)())
   }
 
   test(2.toByte)
diff --git a/test/files/run/reify-aliases.check b/test/files/run/reify-aliases.check
index aa846b9bc6..da784227af 100644
--- a/test/files/run/reify-aliases.check
+++ b/test/files/run/reify-aliases.check
@@ -1 +1 @@
-TypeRef(SingleType(ThisType(scala), scala.Predef), newTypeName("String"), List())
+TypeRef(SingleType(ThisType(scala), scala.Predef), TypeName("String"), List())
diff --git a/test/files/run/reify_copypaste1.scala b/test/files/run/reify_copypaste1.scala
index c597b7af19..b2eef28026 100644
--- a/test/files/run/reify_copypaste1.scala
+++ b/test/files/run/reify_copypaste1.scala
@@ -9,8 +9,8 @@ object Test extends App {
   val output = new java.io.ByteArrayOutputStream()
   System.setOut(new java.io.PrintStream(output))
   val toolBox = currentMirror.mkToolBox(options = "-Yreify-copypaste")
-  val reify = Select(Select(Select(Select(Ident(ScalaPackage), newTermName("reflect")), newTermName("runtime")), newTermName("universe")), newTermName("reify"))
-  val reifee = Block(List(ValDef(Modifiers(LAZY), newTermName("x"), TypeTree(), Apply(Ident(ListModule), List(Literal(Constant(1)), Literal(Constant(2)))))), Ident(newTermName("x")))
+  val reify = Select(Select(Select(Select(Ident(ScalaPackage), TermName("reflect")), TermName("runtime")), TermName("universe")), TermName("reify"))
+  val reifee = Block(List(ValDef(Modifiers(LAZY), TermName("x"), TypeTree(), Apply(Ident(ListModule), List(Literal(Constant(1)), Literal(Constant(2)))))), Ident(TermName("x")))
   toolBox.eval(Apply(reify, List(reifee)))
   val Block(List(tpeCopypaste), exprCopypaste @ ModuleDef(_, _, Template(_, _, (_ :: stats) :+ expr))) = toolBox.parse(output.toString())
   output.reset()
diff --git a/test/files/run/reify_newimpl_22.check b/test/files/run/reify_newimpl_22.check
index dcb3e2889b..e68fe2f6b1 100644
--- a/test/files/run/reify_newimpl_22.check
+++ b/test/files/run/reify_newimpl_22.check
@@ -19,7 +19,7 @@ scala> {
   }
   println(code.eval)
 }
-<console>:15: free term: Ident(newTermName("x")) defined by res0  in <console>:14:21
+<console>:15: free term: Ident(TermName("x")) defined by res0  in <console>:14:21
                 val code = reify {
                                  ^
 2
diff --git a/test/files/run/reify_newimpl_23.check b/test/files/run/reify_newimpl_23.check
index 882124657e..38c95646a8 100644
--- a/test/files/run/reify_newimpl_23.check
+++ b/test/files/run/reify_newimpl_23.check
@@ -18,7 +18,7 @@ scala> def foo[T]{
   }
   println(code.eval)
 }
-<console>:13: free type: Ident(newTypeName("T")) defined by foo in <console>:12:16
+<console>:13: free type: Ident(TypeName("T")) defined by foo in <console>:12:16
          val code = reify {
                           ^
 foo: [T]=> Unit
diff --git a/test/files/run/reify_newimpl_25.check b/test/files/run/reify_newimpl_25.check
index d1028b94c7..86f6abce02 100644
--- a/test/files/run/reify_newimpl_25.check
+++ b/test/files/run/reify_newimpl_25.check
@@ -9,7 +9,7 @@ scala> {
   val tt = implicitly[TypeTag[x.type]]
   println(tt)
 }
-<console>:11: free term: Ident(newTermName("x")) defined by res0  in <console>:10:21
+<console>:11: free term: Ident(TermName("x")) defined by res0  in <console>:10:21
                 val tt = implicitly[TypeTag[x.type]]
                                    ^
 TypeTag[x.type]
diff --git a/test/files/run/reify_newimpl_26.check b/test/files/run/reify_newimpl_26.check
index 347f6365aa..d3e2540de0 100644
--- a/test/files/run/reify_newimpl_26.check
+++ b/test/files/run/reify_newimpl_26.check
@@ -8,7 +8,7 @@ scala> def foo[T]{
   val tt = implicitly[WeakTypeTag[List[T]]]
   println(tt)
 }
-<console>:9: free type: Ident(newTypeName("T")) defined by foo in <console>:7:16
+<console>:9: free type: Ident(TypeName("T")) defined by foo in <console>:7:16
          val tt = implicitly[WeakTypeTag[List[T]]]
                             ^
 foo: [T]=> Unit
diff --git a/test/files/run/reify_printf.scala b/test/files/run/reify_printf.scala
index 272856b962..9932a58dfa 100644
--- a/test/files/run/reify_printf.scala
+++ b/test/files/run/reify_printf.scala
@@ -23,7 +23,7 @@ object Test extends App {
    */
 
   var i = 0
-  def gensym(name: String) = { i += 1; newTermName(name + i) }
+  def gensym(name: String) = { i += 1; TermName(name + i) }
 
   def createTempValDef( value : Tree, tpe : Type ) : (Option[Tree],Tree) = {
     val local = gensym("temp")
@@ -59,10 +59,10 @@ object Test extends App {
       Apply(
         Select(
           Select(
-            Ident( newTermName("scala") )
-            , newTermName("Predef")
+            Ident( TermName("scala") )
+            , TermName("Predef")
           )
-          , newTermName("print")
+          , TermName("print")
         )
         , List(ref)
       ): Tree
diff --git a/test/files/run/repl-colon-type.check b/test/files/run/repl-colon-type.check
index 7716221f54..4cd0e1d588 100644
--- a/test/files/run/repl-colon-type.check
+++ b/test/files/run/repl-colon-type.check
@@ -75,10 +75,10 @@ scala> :type -v List(1,2,3) filter _
 
 // Internal Type structure
 TypeRef(
-  TypeSymbol(abstract trait Function1[-T1, +R] extends Object)
+  TypeSymbol(abstract trait Function1[-T1, +R] extends AnyRef)
   args = List(
     TypeRef(
-      TypeSymbol(abstract trait Function1[-T1, +R] extends Object)
+      TypeSymbol(abstract trait Function1[-T1, +R] extends AnyRef)
       args = List(
         TypeRef(TypeSymbol(final abstract class Int extends AnyVal))
         TypeRef(
@@ -145,7 +145,7 @@ Int => Iterator[List[Nothing]]
 
 // Internal Type structure
 TypeRef(
-  TypeSymbol(abstract trait Function1[-T1, +R] extends Object)
+  TypeSymbol(abstract trait Function1[-T1, +R] extends AnyRef)
   args = List(
     TypeRef(TypeSymbol(final abstract class Int extends AnyVal))
     TypeRef(
@@ -178,7 +178,7 @@ PolyType(
   typeParams = List(TypeParam(T <: AnyVal))
   resultType = NullaryMethodType(
     TypeRef(
-      TypeSymbol(abstract trait Function1[-T1, +R] extends Object)
+      TypeSymbol(abstract trait Function1[-T1, +R] extends AnyRef)
       args = List(
         TypeRef(TypeSymbol(final abstract class Int extends AnyVal))
         TypeRef(
diff --git a/test/files/run/repl-parens.check b/test/files/run/repl-parens.check
index 4b7ce6b059..15f4b4524a 100644
--- a/test/files/run/repl-parens.check
+++ b/test/files/run/repl-parens.check
@@ -66,7 +66,7 @@ scala> 55 ; () => 5
 res13: () => Int = <function0>
 
 scala> () => { class X ; new X }
-res14: () => Object = <function0>
+res14: () => AnyRef = <function0>
 
 scala> 
 
diff --git a/test/files/run/showraw_aliases.check b/test/files/run/showraw_aliases.check
index aebd354031..d6a198b1cb 100644
--- a/test/files/run/showraw_aliases.check
+++ b/test/files/run/showraw_aliases.check
@@ -1,2 +1,2 @@
-Block(List(Import(Select(Select(Ident(scala), scala.reflect), scala.reflect.runtime), List(ImportSelector(newTermName("universe"), <offset>, newTermName("ru"), <offset>)))), Select(Select(Select(Select(Ident(scala), scala.reflect), scala.reflect.runtime), scala.reflect.runtime.package), [newTermName("universe") aka newTermName("ru")]))
-Block(List(Import(Select(Select(Ident(scala#<id>), scala.reflect#<id>), scala.reflect.runtime#<id>), List(ImportSelector(newTermName("universe"), <offset>, newTermName("ru"), <offset>)))), Select(Select(Select(Select(Ident(scala#<id>), scala.reflect#<id>), scala.reflect.runtime#<id>), scala.reflect.runtime.package#<id>), [newTermName("universe")#<id> aka newTermName("ru")]))
+Block(List(Import(Select(Select(Ident(scala), scala.reflect), scala.reflect.runtime), List(ImportSelector(TermName("universe"), <offset>, TermName("ru"), <offset>)))), Select(Select(Select(Select(Ident(scala), scala.reflect), scala.reflect.runtime), scala.reflect.runtime.package), [TermName("universe") aka TermName("ru")]))
+Block(List(Import(Select(Select(Ident(scala#<id>), scala.reflect#<id>), scala.reflect.runtime#<id>), List(ImportSelector(TermName("universe"), <offset>, TermName("ru"), <offset>)))), Select(Select(Select(Select(Ident(scala#<id>), scala.reflect#<id>), scala.reflect.runtime#<id>), scala.reflect.runtime.package#<id>), [TermName("universe")#<id> aka TermName("ru")]))
diff --git a/test/files/run/showraw_mods.check b/test/files/run/showraw_mods.check
index 7fca027614..3ec868542d 100644
--- a/test/files/run/showraw_mods.check
+++ b/test/files/run/showraw_mods.check
@@ -1 +1 @@
-Block(List(ClassDef(Modifiers(ABSTRACT | DEFAULTPARAM/TRAIT), newTypeName("C"), List(), Template(List(Ident(newTypeName("AnyRef"))), emptyValDef, List(DefDef(Modifiers(), newTermName("$init$"), List(), List(List()), TypeTree(), Block(List(), Literal(Constant(())))), ValDef(Modifiers(PRIVATE | LOCAL), newTermName("x"), TypeTree(), Literal(Constant(2))), ValDef(Modifiers(MUTABLE), newTermName("y"), TypeTree(), Select(This(newTypeName("C")), newTermName("x"))), ValDef(Modifiers(LAZY), newTermName("z"), TypeTree(), Select(This(newTypeName("C")), newTermName("y"))))))), Literal(Constant(())))
+Block(List(ClassDef(Modifiers(ABSTRACT | DEFAULTPARAM/TRAIT), TypeName("C"), List(), Template(List(Ident(TypeName("AnyRef"))), emptyValDef, List(DefDef(Modifiers(), TermName("$init$"), List(), List(List()), TypeTree(), Block(List(), Literal(Constant(())))), ValDef(Modifiers(PRIVATE | LOCAL), TermName("x"), TypeTree(), Literal(Constant(2))), ValDef(Modifiers(MUTABLE), TermName("y"), TypeTree(), Select(This(TypeName("C")), TermName("x"))), ValDef(Modifiers(LAZY), TermName("z"), TypeTree(), Select(This(TypeName("C")), TermName("y"))))))), Literal(Constant(())))
diff --git a/test/files/run/showraw_tree.check b/test/files/run/showraw_tree.check
index dca272684e..0416b12568 100644
--- a/test/files/run/showraw_tree.check
+++ b/test/files/run/showraw_tree.check
@@ -1,2 +1,2 @@
-Apply(Select(New(AppliedTypeTree(Ident(scala.collection.immutable.HashMap), List(Ident(newTypeName("String")), Ident(newTypeName("String"))))), nme.CONSTRUCTOR), List())
-Apply(Select(New(AppliedTypeTree(Ident(scala.collection.mutable.HashMap), List(Ident(newTypeName("String")), Ident(newTypeName("String"))))), nme.CONSTRUCTOR), List())
+Apply(Select(New(AppliedTypeTree(Ident(scala.collection.immutable.HashMap), List(Ident(TypeName("String")), Ident(TypeName("String"))))), nme.CONSTRUCTOR), List())
+Apply(Select(New(AppliedTypeTree(Ident(scala.collection.mutable.HashMap), List(Ident(TypeName("String")), Ident(TypeName("String"))))), nme.CONSTRUCTOR), List())
diff --git a/test/files/run/showraw_tree_ids.check b/test/files/run/showraw_tree_ids.check
index d25599c7fc..6e17bf2fb4 100644
--- a/test/files/run/showraw_tree_ids.check
+++ b/test/files/run/showraw_tree_ids.check
@@ -1,2 +1,2 @@
-Apply(Select(New(AppliedTypeTree(Ident(scala.collection.immutable.HashMap#<id>), List(Ident(newTypeName("String")#<id>), Ident(newTypeName("String")#<id>)))), nme.CONSTRUCTOR), List())
-Apply(Select(New(AppliedTypeTree(Ident(scala.collection.mutable.HashMap#<id>), List(Ident(newTypeName("String")#<id>), Ident(newTypeName("String")#<id>)))), nme.CONSTRUCTOR), List())
+Apply(Select(New(AppliedTypeTree(Ident(scala.collection.immutable.HashMap#<id>), List(Ident(TypeName("String")#<id>), Ident(TypeName("String")#<id>)))), nme.CONSTRUCTOR), List())
+Apply(Select(New(AppliedTypeTree(Ident(scala.collection.mutable.HashMap#<id>), List(Ident(TypeName("String")#<id>), Ident(TypeName("String")#<id>)))), nme.CONSTRUCTOR), List())
diff --git a/test/files/run/showraw_tree_kinds.check b/test/files/run/showraw_tree_kinds.check
index d0d4cd0058..16147a64f4 100644
--- a/test/files/run/showraw_tree_kinds.check
+++ b/test/files/run/showraw_tree_kinds.check
@@ -1,2 +1,2 @@
-Apply(Select(New(AppliedTypeTree(Ident(scala.collection.immutable.HashMap#CLS), List(Ident(newTypeName("String")#TPE), Ident(newTypeName("String")#TPE)))), nme.CONSTRUCTOR), List())
-Apply(Select(New(AppliedTypeTree(Ident(scala.collection.mutable.HashMap#CLS), List(Ident(newTypeName("String")#TPE), Ident(newTypeName("String")#TPE)))), nme.CONSTRUCTOR), List())
+Apply(Select(New(AppliedTypeTree(Ident(scala.collection.immutable.HashMap#CLS), List(Ident(TypeName("String")#TPE), Ident(TypeName("String")#TPE)))), nme.CONSTRUCTOR), List())
+Apply(Select(New(AppliedTypeTree(Ident(scala.collection.mutable.HashMap#CLS), List(Ident(TypeName("String")#TPE), Ident(TypeName("String")#TPE)))), nme.CONSTRUCTOR), List())
diff --git a/test/files/run/showraw_tree_types_ids.check b/test/files/run/showraw_tree_types_ids.check
index 92ee45a1e6..c98b16e956 100644
--- a/test/files/run/showraw_tree_types_ids.check
+++ b/test/files/run/showraw_tree_types_ids.check
@@ -1,10 +1,10 @@
-Apply[1](Select[2](New[1](TypeTree[1]().setOriginal(AppliedTypeTree(Ident[3](scala.collection.immutable.HashMap#<id>), List(TypeTree[4]().setOriginal(Ident[4](newTypeName("String")#<id>)), TypeTree[4]().setOriginal(Ident[4](newTypeName("String")#<id>)))))), nme.CONSTRUCTOR#<id>), List())
-[1] TypeRef(ThisType(scala.collection.immutable#<id>), scala.collection.immutable.HashMap#<id>, List(TypeRef(ThisType(scala.Predef#<id>), newTypeName("String")#<id>, List()), TypeRef(ThisType(scala.Predef#<id>), newTypeName("String")#<id>, List())))
-[2] MethodType(List(), TypeRef(ThisType(scala.collection.immutable#<id>), scala.collection.immutable.HashMap#<id>, List(TypeRef(ThisType(scala.Predef#<id>), newTypeName("String")#<id>, List()), TypeRef(ThisType(scala.Predef#<id>), newTypeName("String")#<id>, List()))))
+Apply[1](Select[2](New[1](TypeTree[1]().setOriginal(AppliedTypeTree(Ident[3](scala.collection.immutable.HashMap#<id>), List(TypeTree[4]().setOriginal(Ident[4](TypeName("String")#<id>)), TypeTree[4]().setOriginal(Ident[4](TypeName("String")#<id>)))))), nme.CONSTRUCTOR#<id>), List())
+[1] TypeRef(ThisType(scala.collection.immutable#<id>), scala.collection.immutable.HashMap#<id>, List(TypeRef(ThisType(scala.Predef#<id>), TypeName("String")#<id>, List()), TypeRef(ThisType(scala.Predef#<id>), TypeName("String")#<id>, List())))
+[2] MethodType(List(), TypeRef(ThisType(scala.collection.immutable#<id>), scala.collection.immutable.HashMap#<id>, List(TypeRef(ThisType(scala.Predef#<id>), TypeName("String")#<id>, List()), TypeRef(ThisType(scala.Predef#<id>), TypeName("String")#<id>, List()))))
 [3] TypeRef(ThisType(scala.collection.immutable#<id>), scala.collection.immutable.HashMap#<id>, List())
-[4] TypeRef(ThisType(scala.Predef#<id>), newTypeName("String")#<id>, List())
-Apply[5](Select[6](New[5](TypeTree[5]().setOriginal(AppliedTypeTree(Ident[7](scala.collection.mutable.HashMap#<id>), List(TypeTree[4]().setOriginal(Ident[4](newTypeName("String")#<id>)), TypeTree[4]().setOriginal(Ident[4](newTypeName("String")#<id>)))))), nme.CONSTRUCTOR#<id>), List())
-[4] TypeRef(ThisType(scala.Predef#<id>), newTypeName("String")#<id>, List())
-[5] TypeRef(ThisType(scala.collection.mutable#<id>), scala.collection.mutable.HashMap#<id>, List(TypeRef(ThisType(scala.Predef#<id>), newTypeName("String")#<id>, List()), TypeRef(ThisType(scala.Predef#<id>), newTypeName("String")#<id>, List())))
-[6] MethodType(List(), TypeRef(ThisType(scala.collection.mutable#<id>), scala.collection.mutable.HashMap#<id>, List(TypeRef(ThisType(scala.Predef#<id>), newTypeName("String")#<id>, List()), TypeRef(ThisType(scala.Predef#<id>), newTypeName("String")#<id>, List()))))
+[4] TypeRef(ThisType(scala.Predef#<id>), TypeName("String")#<id>, List())
+Apply[5](Select[6](New[5](TypeTree[5]().setOriginal(AppliedTypeTree(Ident[7](scala.collection.mutable.HashMap#<id>), List(TypeTree[4]().setOriginal(Ident[4](TypeName("String")#<id>)), TypeTree[4]().setOriginal(Ident[4](TypeName("String")#<id>)))))), nme.CONSTRUCTOR#<id>), List())
+[4] TypeRef(ThisType(scala.Predef#<id>), TypeName("String")#<id>, List())
+[5] TypeRef(ThisType(scala.collection.mutable#<id>), scala.collection.mutable.HashMap#<id>, List(TypeRef(ThisType(scala.Predef#<id>), TypeName("String")#<id>, List()), TypeRef(ThisType(scala.Predef#<id>), TypeName("String")#<id>, List())))
+[6] MethodType(List(), TypeRef(ThisType(scala.collection.mutable#<id>), scala.collection.mutable.HashMap#<id>, List(TypeRef(ThisType(scala.Predef#<id>), TypeName("String")#<id>, List()), TypeRef(ThisType(scala.Predef#<id>), TypeName("String")#<id>, List()))))
 [7] TypeRef(ThisType(scala.collection.mutable#<id>), scala.collection.mutable.HashMap#<id>, List())
diff --git a/test/files/run/showraw_tree_types_typed.check b/test/files/run/showraw_tree_types_typed.check
index c6c20409dc..30dda7d18b 100644
--- a/test/files/run/showraw_tree_types_typed.check
+++ b/test/files/run/showraw_tree_types_typed.check
@@ -1,10 +1,10 @@
-Apply[1](Select[2](New[1](TypeTree[1]().setOriginal(AppliedTypeTree(Ident[3](scala.collection.immutable.HashMap), List(TypeTree[4]().setOriginal(Ident[4](newTypeName("String"))), TypeTree[4]().setOriginal(Ident[4](newTypeName("String"))))))), nme.CONSTRUCTOR), List())
-[1] TypeRef(ThisType(scala.collection.immutable), scala.collection.immutable.HashMap, List(TypeRef(ThisType(scala.Predef), newTypeName("String"), List()), TypeRef(ThisType(scala.Predef), newTypeName("String"), List())))
-[2] MethodType(List(), TypeRef(ThisType(scala.collection.immutable), scala.collection.immutable.HashMap, List(TypeRef(ThisType(scala.Predef), newTypeName("String"), List()), TypeRef(ThisType(scala.Predef), newTypeName("String"), List()))))
+Apply[1](Select[2](New[1](TypeTree[1]().setOriginal(AppliedTypeTree(Ident[3](scala.collection.immutable.HashMap), List(TypeTree[4]().setOriginal(Ident[4](TypeName("String"))), TypeTree[4]().setOriginal(Ident[4](TypeName("String"))))))), nme.CONSTRUCTOR), List())
+[1] TypeRef(ThisType(scala.collection.immutable), scala.collection.immutable.HashMap, List(TypeRef(ThisType(scala.Predef), TypeName("String"), List()), TypeRef(ThisType(scala.Predef), TypeName("String"), List())))
+[2] MethodType(List(), TypeRef(ThisType(scala.collection.immutable), scala.collection.immutable.HashMap, List(TypeRef(ThisType(scala.Predef), TypeName("String"), List()), TypeRef(ThisType(scala.Predef), TypeName("String"), List()))))
 [3] TypeRef(ThisType(scala.collection.immutable), scala.collection.immutable.HashMap, List())
-[4] TypeRef(ThisType(scala.Predef), newTypeName("String"), List())
-Apply[5](Select[6](New[5](TypeTree[5]().setOriginal(AppliedTypeTree(Ident[7](scala.collection.mutable.HashMap), List(TypeTree[4]().setOriginal(Ident[4](newTypeName("String"))), TypeTree[4]().setOriginal(Ident[4](newTypeName("String"))))))), nme.CONSTRUCTOR), List())
-[4] TypeRef(ThisType(scala.Predef), newTypeName("String"), List())
-[5] TypeRef(ThisType(scala.collection.mutable), scala.collection.mutable.HashMap, List(TypeRef(ThisType(scala.Predef), newTypeName("String"), List()), TypeRef(ThisType(scala.Predef), newTypeName("String"), List())))
-[6] MethodType(List(), TypeRef(ThisType(scala.collection.mutable), scala.collection.mutable.HashMap, List(TypeRef(ThisType(scala.Predef), newTypeName("String"), List()), TypeRef(ThisType(scala.Predef), newTypeName("String"), List()))))
+[4] TypeRef(ThisType(scala.Predef), TypeName("String"), List())
+Apply[5](Select[6](New[5](TypeTree[5]().setOriginal(AppliedTypeTree(Ident[7](scala.collection.mutable.HashMap), List(TypeTree[4]().setOriginal(Ident[4](TypeName("String"))), TypeTree[4]().setOriginal(Ident[4](TypeName("String"))))))), nme.CONSTRUCTOR), List())
+[4] TypeRef(ThisType(scala.Predef), TypeName("String"), List())
+[5] TypeRef(ThisType(scala.collection.mutable), scala.collection.mutable.HashMap, List(TypeRef(ThisType(scala.Predef), TypeName("String"), List()), TypeRef(ThisType(scala.Predef), TypeName("String"), List())))
+[6] MethodType(List(), TypeRef(ThisType(scala.collection.mutable), scala.collection.mutable.HashMap, List(TypeRef(ThisType(scala.Predef), TypeName("String"), List()), TypeRef(ThisType(scala.Predef), TypeName("String"), List()))))
 [7] TypeRef(ThisType(scala.collection.mutable), scala.collection.mutable.HashMap, List())
diff --git a/test/files/run/showraw_tree_types_untyped.check b/test/files/run/showraw_tree_types_untyped.check
index dca272684e..0416b12568 100644
--- a/test/files/run/showraw_tree_types_untyped.check
+++ b/test/files/run/showraw_tree_types_untyped.check
@@ -1,2 +1,2 @@
-Apply(Select(New(AppliedTypeTree(Ident(scala.collection.immutable.HashMap), List(Ident(newTypeName("String")), Ident(newTypeName("String"))))), nme.CONSTRUCTOR), List())
-Apply(Select(New(AppliedTypeTree(Ident(scala.collection.mutable.HashMap), List(Ident(newTypeName("String")), Ident(newTypeName("String"))))), nme.CONSTRUCTOR), List())
+Apply(Select(New(AppliedTypeTree(Ident(scala.collection.immutable.HashMap), List(Ident(TypeName("String")), Ident(TypeName("String"))))), nme.CONSTRUCTOR), List())
+Apply(Select(New(AppliedTypeTree(Ident(scala.collection.mutable.HashMap), List(Ident(TypeName("String")), Ident(TypeName("String"))))), nme.CONSTRUCTOR), List())
diff --git a/test/files/run/showraw_tree_ultimate.check b/test/files/run/showraw_tree_ultimate.check
index 46ccd4df8f..991ecc5410 100644
--- a/test/files/run/showraw_tree_ultimate.check
+++ b/test/files/run/showraw_tree_ultimate.check
@@ -1,10 +1,10 @@
-Apply[1](Select[2](New[1](TypeTree[1]().setOriginal(AppliedTypeTree(Ident[3](scala.collection.immutable.HashMap#<id>#CLS), List(TypeTree[4]().setOriginal(Ident[4](newTypeName("String")#<id>#TPE)), TypeTree[4]().setOriginal(Ident[4](newTypeName("String")#<id>#TPE)))))), nme.CONSTRUCTOR#<id>#PCTOR), List())
-[1] TypeRef(ThisType(scala.collection.immutable#<id>#PK), scala.collection.immutable.HashMap#<id>#CLS, List(TypeRef(ThisType(scala.Predef#<id>#MODC), newTypeName("String")#<id>#TPE, List()), TypeRef(ThisType(scala.Predef#<id>#MODC), newTypeName("String")#<id>#TPE, List())))
-[2] MethodType(List(), TypeRef(ThisType(scala.collection.immutable#<id>#PK), scala.collection.immutable.HashMap#<id>#CLS, List(TypeRef(ThisType(scala.Predef#<id>#MODC), newTypeName("String")#<id>#TPE, List()), TypeRef(ThisType(scala.Predef#<id>#MODC), newTypeName("String")#<id>#TPE, List()))))
+Apply[1](Select[2](New[1](TypeTree[1]().setOriginal(AppliedTypeTree(Ident[3](scala.collection.immutable.HashMap#<id>#CLS), List(TypeTree[4]().setOriginal(Ident[4](TypeName("String")#<id>#TPE)), TypeTree[4]().setOriginal(Ident[4](TypeName("String")#<id>#TPE)))))), nme.CONSTRUCTOR#<id>#PCTOR), List())
+[1] TypeRef(ThisType(scala.collection.immutable#<id>#PK), scala.collection.immutable.HashMap#<id>#CLS, List(TypeRef(ThisType(scala.Predef#<id>#MODC), TypeName("String")#<id>#TPE, List()), TypeRef(ThisType(scala.Predef#<id>#MODC), TypeName("String")#<id>#TPE, List())))
+[2] MethodType(List(), TypeRef(ThisType(scala.collection.immutable#<id>#PK), scala.collection.immutable.HashMap#<id>#CLS, List(TypeRef(ThisType(scala.Predef#<id>#MODC), TypeName("String")#<id>#TPE, List()), TypeRef(ThisType(scala.Predef#<id>#MODC), TypeName("String")#<id>#TPE, List()))))
 [3] TypeRef(ThisType(scala.collection.immutable#<id>#PK), scala.collection.immutable.HashMap#<id>#CLS, List())
-[4] TypeRef(ThisType(scala.Predef#<id>#MODC), newTypeName("String")#<id>#TPE, List())
-Apply[5](Select[6](New[5](TypeTree[5]().setOriginal(AppliedTypeTree(Ident[7](scala.collection.mutable.HashMap#<id>#CLS), List(TypeTree[4]().setOriginal(Ident[4](newTypeName("String")#<id>#TPE)), TypeTree[4]().setOriginal(Ident[4](newTypeName("String")#<id>#TPE)))))), nme.CONSTRUCTOR#<id>#CTOR), List())
-[4] TypeRef(ThisType(scala.Predef#<id>#MODC), newTypeName("String")#<id>#TPE, List())
-[5] TypeRef(ThisType(scala.collection.mutable#<id>#PK), scala.collection.mutable.HashMap#<id>#CLS, List(TypeRef(ThisType(scala.Predef#<id>#MODC), newTypeName("String")#<id>#TPE, List()), TypeRef(ThisType(scala.Predef#<id>#MODC), newTypeName("String")#<id>#TPE, List())))
-[6] MethodType(List(), TypeRef(ThisType(scala.collection.mutable#<id>#PK), scala.collection.mutable.HashMap#<id>#CLS, List(TypeRef(ThisType(scala.Predef#<id>#MODC), newTypeName("String")#<id>#TPE, List()), TypeRef(ThisType(scala.Predef#<id>#MODC), newTypeName("String")#<id>#TPE, List()))))
+[4] TypeRef(ThisType(scala.Predef#<id>#MODC), TypeName("String")#<id>#TPE, List())
+Apply[5](Select[6](New[5](TypeTree[5]().setOriginal(AppliedTypeTree(Ident[7](scala.collection.mutable.HashMap#<id>#CLS), List(TypeTree[4]().setOriginal(Ident[4](TypeName("String")#<id>#TPE)), TypeTree[4]().setOriginal(Ident[4](TypeName("String")#<id>#TPE)))))), nme.CONSTRUCTOR#<id>#CTOR), List())
+[4] TypeRef(ThisType(scala.Predef#<id>#MODC), TypeName("String")#<id>#TPE, List())
+[5] TypeRef(ThisType(scala.collection.mutable#<id>#PK), scala.collection.mutable.HashMap#<id>#CLS, List(TypeRef(ThisType(scala.Predef#<id>#MODC), TypeName("String")#<id>#TPE, List()), TypeRef(ThisType(scala.Predef#<id>#MODC), TypeName("String")#<id>#TPE, List())))
+[6] MethodType(List(), TypeRef(ThisType(scala.collection.mutable#<id>#PK), scala.collection.mutable.HashMap#<id>#CLS, List(TypeRef(ThisType(scala.Predef#<id>#MODC), TypeName("String")#<id>#TPE, List()), TypeRef(ThisType(scala.Predef#<id>#MODC), TypeName("String")#<id>#TPE, List()))))
 [7] TypeRef(ThisType(scala.collection.mutable#<id>#PK), scala.collection.mutable.HashMap#<id>#CLS, List())
diff --git a/test/files/run/t3835.scala b/test/files/run/t3835.scala
index c120a61f6e..766b6ddc2e 100644
--- a/test/files/run/t3835.scala
+++ b/test/files/run/t3835.scala
@@ -1,6 +1,6 @@
 object Test extends App {
   // work around optimizer bug SI-5672  -- generates wrong bytecode for switches in arguments
-  // virtpatmat happily emits a switch for a one-case switch, whereas -Xoldpatmat did not
+  // virtpatmat happily emits a switch for a one-case switch
   // this is not the focus of this test, hence the temporary workaround
   def a = (1, 2, 3) match { case (r, \u03b8, \u03c6) => r + \u03b8 + \u03c6 }
   println(a)
diff --git a/test/files/run/t4172.check b/test/files/run/t4172.check
index f16c9e5151..94cdff4870 100644
--- a/test/files/run/t4172.check
+++ b/test/files/run/t4172.check
@@ -5,7 +5,7 @@ scala>
 
 scala>     val c = { class C { override def toString = "C" }; ((new C, new C { def f = 2 })) }
 warning: there were 1 feature warnings; re-run with -feature for details
-c: (C, C{def f: Int}) forSome { type C <: Object } = (C,C)
+c: (C, C{def f: Int}) forSome { type C <: AnyRef } = (C,C)
 
 scala> 
 
diff --git a/test/files/run/t5256a.check b/test/files/run/t5256a.check
index 7e60139db3..09b5a02831 100644
--- a/test/files/run/t5256a.check
+++ b/test/files/run/t5256a.check
@@ -1,6 +1,6 @@
 class A
 A
-Object {
+AnyRef {
   def <init>(): A
   def foo: Nothing
 }
diff --git a/test/files/run/t5256b.check b/test/files/run/t5256b.check
index a80df6eb30..ca93aaa706 100644
--- a/test/files/run/t5256b.check
+++ b/test/files/run/t5256b.check
@@ -1,6 +1,6 @@
 class A
 Test.A
-Object {
+AnyRef {
   def <init>(): Test.A
   def foo: Nothing
 }
diff --git a/test/files/run/t5256d.check b/test/files/run/t5256d.check
index 9742ae572e..b7617e80a2 100644
--- a/test/files/run/t5256d.check
+++ b/test/files/run/t5256d.check
@@ -22,7 +22,7 @@ scala> println(c.fullName)
 $line8.$read.$iw.$iw.$iw.$iw.A
 
 scala> println(c.typeSignature)
-java.lang.Object {
+scala.AnyRef {
   def <init>(): A
   def foo: scala.Nothing
 }
diff --git a/test/files/run/t5256e.check b/test/files/run/t5256e.check
index 011115720c..ed3513183e 100644
--- a/test/files/run/t5256e.check
+++ b/test/files/run/t5256e.check
@@ -1,6 +1,6 @@
 class A
 Test.C.A
-Object {
+AnyRef {
   def <init>(): C.this.A
   def foo: Nothing
 }
diff --git a/test/files/run/t5256f.check b/test/files/run/t5256f.check
index e0fec85596..6a89d0b86a 100644
--- a/test/files/run/t5256f.check
+++ b/test/files/run/t5256f.check
@@ -1,12 +1,12 @@
 class A1
 Test.A1
-Object {
+AnyRef {
   def <init>(): Test.A1
   def foo: Nothing
 }
 class A2
 Test.A2
-Object {
+AnyRef {
   def <init>(): Test.this.A2
   def foo: Nothing
 }
diff --git a/test/files/run/t5418b.check b/test/files/run/t5418b.check
index 48d82a2aae..f036a4be84 100644
--- a/test/files/run/t5418b.check
+++ b/test/files/run/t5418b.check
@@ -1,2 +1,2 @@
 new Object().getClass()
-TypeRef(ThisType(java.lang), java.lang.Class, List(TypeRef(NoPrefix, newTypeName("?0"), List())))
+TypeRef(ThisType(java.lang), java.lang.Class, List(TypeRef(NoPrefix, TypeName("?0"), List())))
diff --git a/test/files/run/t6178.scala b/test/files/run/t6178.scala
index 0b4cf0bbf5..41e148af91 100644
--- a/test/files/run/t6178.scala
+++ b/test/files/run/t6178.scala
@@ -2,6 +2,6 @@ import scala.reflect.runtime.universe._
 import scala.reflect.runtime.{currentMirror => cm}
 
 object Test extends App {
-  val plus = typeOf[java.lang.String].member(newTermName("$plus")).asMethod
+  val plus = typeOf[java.lang.String].member(TermName("$plus")).asMethod
   println(cm.reflect("").reflectMethod(plus).apply("2"))
 }
\ No newline at end of file
diff --git a/test/files/run/t6181.scala b/test/files/run/t6181.scala
index fb23eaff63..eaa7340178 100644
--- a/test/files/run/t6181.scala
+++ b/test/files/run/t6181.scala
@@ -3,6 +3,6 @@ import scala.reflect.runtime.{currentMirror => cm}
 
 object Test extends App {
   class C { def test(x: => Int) = println(x) }
-  val mm = cm.reflect(new C).reflectMethod(typeOf[C].member(newTermName("test")).asMethod)
+  val mm = cm.reflect(new C).reflectMethod(typeOf[C].member(TermName("test")).asMethod)
   mm(2)
 }
\ No newline at end of file
diff --git a/test/files/run/t6199-mirror.scala b/test/files/run/t6199-mirror.scala
index 772a384542..3fda56bf7c 100644
--- a/test/files/run/t6199-mirror.scala
+++ b/test/files/run/t6199-mirror.scala
@@ -3,5 +3,5 @@ import scala.reflect.runtime.{currentMirror => cm}
 
 object Test extends App {
   class C { def foo = () }
-  println(cm.reflect(new C).reflectMethod(typeOf[C].member(newTermName("foo")).asMethod)())
+  println(cm.reflect(new C).reflectMethod(typeOf[C].member(TermName("foo")).asMethod)())
 }
\ No newline at end of file
diff --git a/test/files/run/t6392b.check b/test/files/run/t6392b.check
index e9c7ecaa34..2afc48495f 100644
--- a/test/files/run/t6392b.check
+++ b/test/files/run/t6392b.check
@@ -1 +1 @@
-ModuleDef(Modifiers(), newTermName("C"), Template(List(Select(Ident(scala#PK), newTypeName("AnyRef")#TPE)), emptyValDef, List(DefDef(Modifiers(), nme.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(Apply(Select(Super(This(newTypeName("C")), tpnme.EMPTY), nme.CONSTRUCTOR#PCTOR), List())), Literal(Constant(())))))))
+ModuleDef(Modifiers(), TermName("C"), Template(List(Select(Ident(scala#PK), TypeName("AnyRef")#TPE)), emptyValDef, List(DefDef(Modifiers(), nme.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(Apply(Select(Super(This(TypeName("C")), tpnme.EMPTY), nme.CONSTRUCTOR#PCTOR), List())), Literal(Constant(())))))))
diff --git a/test/files/run/toolbox_typecheck_implicitsdisabled.scala b/test/files/run/toolbox_typecheck_implicitsdisabled.scala
index 8a3d433142..95a7056279 100644
--- a/test/files/run/toolbox_typecheck_implicitsdisabled.scala
+++ b/test/files/run/toolbox_typecheck_implicitsdisabled.scala
@@ -7,16 +7,16 @@ object Test extends App {
   val toolbox = cm.mkToolBox()
 
   val tree1 = Block(List(
-    Import(Select(Ident(newTermName("scala")), newTermName("Predef")), List(ImportSelector(nme.WILDCARD, -1, null, -1)))),
-    Apply(Select(Literal(Constant(1)), newTermName("$minus$greater")), List(Literal(Constant(2))))
+    Import(Select(Ident(TermName("scala")), TermName("Predef")), List(ImportSelector(nme.WILDCARD, -1, null, -1)))),
+    Apply(Select(Literal(Constant(1)), TermName("$minus$greater")), List(Literal(Constant(2))))
   )
   val ttree1 = toolbox.typeCheck(tree1, withImplicitViewsDisabled = false)
   println(ttree1)
 
   try {
     val tree2 = Block(List(
-      Import(Select(Ident(newTermName("scala")), newTermName("Predef")), List(ImportSelector(nme.WILDCARD, -1, null, -1)))),
-      Apply(Select(Literal(Constant(1)), newTermName("$minus$greater")), List(Literal(Constant(2))))
+      Import(Select(Ident(TermName("scala")), TermName("Predef")), List(ImportSelector(nme.WILDCARD, -1, null, -1)))),
+      Apply(Select(Literal(Constant(1)), TermName("$minus$greater")), List(Literal(Constant(2))))
     )
     val ttree2 = toolbox.typeCheck(tree2, withImplicitViewsDisabled = true)
     println(ttree2)
diff --git a/test/files/run/toolbox_typecheck_macrosdisabled.scala b/test/files/run/toolbox_typecheck_macrosdisabled.scala
index 51eb63f294..1f7fda8575 100644
--- a/test/files/run/toolbox_typecheck_macrosdisabled.scala
+++ b/test/files/run/toolbox_typecheck_macrosdisabled.scala
@@ -15,11 +15,11 @@ object Test extends App {
   val ru = build.newFreeTerm("ru", scala.reflect.runtime.universe)
   build.setTypeSignature(ru, rutpe)
 
-  val tree1 = Apply(Select(Ident(ru), newTermName("reify")), List(Literal(Constant(2))))
+  val tree1 = Apply(Select(Ident(ru), TermName("reify")), List(Literal(Constant(2))))
   val ttree1 = toolbox.typeCheck(tree1, withMacrosDisabled = false)
   println(ttree1)
 
-  val tree2 = Apply(Select(Ident(ru), newTermName("reify")), List(Literal(Constant(2))))
+  val tree2 = Apply(Select(Ident(ru), TermName("reify")), List(Literal(Constant(2))))
   val ttree2 = toolbox.typeCheck(tree2, withMacrosDisabled = true)
   println(ttree2)
 }
diff --git a/test/files/run/toolbox_typecheck_macrosdisabled2.check b/test/files/run/toolbox_typecheck_macrosdisabled2.check
index f5c9b6eeab..74dfb03666 100644
--- a/test/files/run/toolbox_typecheck_macrosdisabled2.check
+++ b/test/files/run/toolbox_typecheck_macrosdisabled2.check
@@ -19,7 +19,7 @@
       def apply[U <: scala.reflect.api.Universe with Singleton]($m$untyped: scala.reflect.api.Mirror[U]): U#Tree = {
         val $u: U = $m$untyped.universe;
         val $m: $u.Mirror = $m$untyped.asInstanceOf[$u.Mirror];
-        $u.Apply.apply($u.Select.apply($u.Select.apply($u.build.Ident($m.staticPackage("scala")), $u.newTermName("Array")), $u.newTermName("apply")), scala.collection.immutable.List.apply[$u.Literal]($u.Literal.apply($u.Constant.apply(2))))
+        $u.Apply.apply($u.Select.apply($u.Select.apply($u.build.Ident($m.staticPackage("scala")), $u.TermName.apply("Array")), $u.TermName.apply("apply")), scala.collection.immutable.List.apply[$u.Literal]($u.Literal.apply($u.Constant.apply(2))))
       }
     };
     new $treecreator1()
diff --git a/test/files/run/toolbox_typecheck_macrosdisabled2.scala b/test/files/run/toolbox_typecheck_macrosdisabled2.scala
index 74fd09d9fd..7bfe3ba8a4 100644
--- a/test/files/run/toolbox_typecheck_macrosdisabled2.scala
+++ b/test/files/run/toolbox_typecheck_macrosdisabled2.scala
@@ -15,11 +15,11 @@ object Test extends App {
   val ru = build.newFreeTerm("ru", scala.reflect.runtime.universe)
   build.setTypeSignature(ru, rutpe)
 
-  val tree1 = Apply(Select(Ident(ru), newTermName("reify")), List(Apply(Select(Ident(newTermName("scala")), newTermName("Array")), List(Literal(Constant(2))))))
+  val tree1 = Apply(Select(Ident(ru), TermName("reify")), List(Apply(Select(Ident(TermName("scala")), TermName("Array")), List(Literal(Constant(2))))))
   val ttree1 = toolbox.typeCheck(tree1, withMacrosDisabled = false)
   println(ttree1)
 
-  val tree2 = Apply(Select(Ident(ru), newTermName("reify")), List(Apply(Select(Ident(newTermName("scala")), newTermName("Array")), List(Literal(Constant(2))))))
+  val tree2 = Apply(Select(Ident(ru), TermName("reify")), List(Apply(Select(Ident(TermName("scala")), TermName("Array")), List(Literal(Constant(2))))))
   val ttree2 = toolbox.typeCheck(tree2, withMacrosDisabled = true)
   println(ttree2)
 }
diff --git a/test/files/scalacheck/ReflectionExtractors.scala b/test/files/scalacheck/ReflectionExtractors.scala
new file mode 100644
index 0000000000..a2615feb3e
--- /dev/null
+++ b/test/files/scalacheck/ReflectionExtractors.scala
@@ -0,0 +1,52 @@
+import org.scalacheck._
+import Prop._
+import Gen._
+import Arbitrary._
+
+import scala.reflect.runtime.universe._
+import Flag._
+
+object Test extends Properties("reflection extractors") {
+
+  val genFlag = oneOf(
+    TRAIT, INTERFACE, MUTABLE, MACRO, DEFERRED, ABSTRACT, FINAL, SEALED,
+    IMPLICIT, LAZY, OVERRIDE, PRIVATE, PROTECTED, LOCAL, CASE, ABSOVERRIDE,
+    BYNAMEPARAM, PARAM, COVARIANT, CONTRAVARIANT, DEFAULTPARAM, PRESUPER,
+    DEFAULTINIT
+  )
+  val genModifiers =
+    for(flag <- genFlag; privateWithin <- genName)
+      yield Modifiers(flag, privateWithin, Nil)
+  val genTermName = for(name <- arbitrary[String]) yield TermName(name)
+  val genTypeName = for(name <- arbitrary[String]) yield TypeName(name)
+  val genName = oneOf(genTermName, genTypeName)
+
+  implicit val arbTermName: Arbitrary[TermName] = Arbitrary(genTermName)
+  implicit val arbTypeName: Arbitrary[TypeName] = Arbitrary(genTypeName)
+  implicit val arbName: Arbitrary[Name] = Arbitrary(genName)
+  implicit val arbMods: Arbitrary[Modifiers] = Arbitrary(genModifiers)
+
+  property("extract term name") = forAll { (name: TermName) =>
+    val TermName(s) = name
+    s == name.toString
+  }
+
+  property("extract type name") = forAll { (name: TypeName) =>
+    val TypeName(s) = name
+    s == name.toString
+  }
+
+  property("extract term or type name") = forAll { (name: Name) =>
+    name match {
+      case TermName(s) => s == name.toString
+      case TypeName(s) => s == name.toString
+    }
+  }
+
+  property("extract modifiers") = forAll { (mods: Modifiers) =>
+    val Modifiers(flags, priv, annots) = mods
+    flags == mods.flags &&
+    priv == mods.privateWithin &&
+    annots == mods.annotations
+  }
+}
\ No newline at end of file
diff --git a/test/files/scalap/abstractClass/result.test b/test/files/scalap/abstractClass/result.test
index 9163346fc6..ef1daac23d 100644
--- a/test/files/scalap/abstractClass/result.test
+++ b/test/files/scalap/abstractClass/result.test
@@ -1,4 +1,4 @@
-abstract class AbstractClass extends java.lang.Object {
+abstract class AbstractClass extends scala.AnyRef {
   def this() = { /* compiled code */ }
   def foo : scala.Predef.String
 }
diff --git a/test/files/scalap/abstractMethod/result.test b/test/files/scalap/abstractMethod/result.test
index 90f572f258..40fa02d408 100644
--- a/test/files/scalap/abstractMethod/result.test
+++ b/test/files/scalap/abstractMethod/result.test
@@ -1,4 +1,4 @@
-trait AbstractMethod extends java.lang.Object {
+trait AbstractMethod extends scala.AnyRef {
   def $init$() : scala.Unit = { /* compiled code */ }
   def arity : scala.Int
   def isCool : scala.Boolean = { /* compiled code */ }
diff --git a/test/files/scalap/cbnParam/result.test b/test/files/scalap/cbnParam/result.test
index fbe035d63c..52ecb6ae66 100644
--- a/test/files/scalap/cbnParam/result.test
+++ b/test/files/scalap/cbnParam/result.test
@@ -1,3 +1,3 @@
-class CbnParam extends java.lang.Object {
+class CbnParam extends scala.AnyRef {
   def this(s : => scala.Predef.String) = { /* compiled code */ }
 }
diff --git a/test/files/scalap/classPrivate/result.test b/test/files/scalap/classPrivate/result.test
index 5f2e1cc00e..ab2d40cdaf 100644
--- a/test/files/scalap/classPrivate/result.test
+++ b/test/files/scalap/classPrivate/result.test
@@ -1,7 +1,7 @@
-class ClassPrivate extends java.lang.Object {
+class ClassPrivate extends scala.AnyRef {
   def this() = { /* compiled code */ }
   def baz : scala.Int = { /* compiled code */ }
-  class Outer extends java.lang.Object {
+  class Outer extends scala.AnyRef {
     def this() = { /* compiled code */ }
     private[ClassPrivate] def qux : scala.Int = { /* compiled code */ }
   }
diff --git a/test/files/scalap/classWithExistential/result.test b/test/files/scalap/classWithExistential/result.test
index b8ce005da9..caee3fd6de 100644
--- a/test/files/scalap/classWithExistential/result.test
+++ b/test/files/scalap/classWithExistential/result.test
@@ -1,4 +1,4 @@
-class ClassWithExistential extends java.lang.Object {
+class ClassWithExistential extends scala.AnyRef {
   def this() = { /* compiled code */ }
   def foo[A, B] : scala.Function1[A, B forSome {type A <: scala.Seq[scala.Int]; type B >: scala.Predef.String}] = { /* compiled code */ }
 }
diff --git a/test/files/scalap/classWithSelfAnnotation/result.test b/test/files/scalap/classWithSelfAnnotation/result.test
index df7bd86643..82bbd9e8df 100644
--- a/test/files/scalap/classWithSelfAnnotation/result.test
+++ b/test/files/scalap/classWithSelfAnnotation/result.test
@@ -1,4 +1,4 @@
-class ClassWithSelfAnnotation extends java.lang.Object {
+class ClassWithSelfAnnotation extends scala.AnyRef {
  this : ClassWithSelfAnnotation with java.lang.CharSequence =>
   def this() = { /* compiled code */ }
   def foo : scala.Int = { /* compiled code */ }
diff --git a/test/files/scalap/covariantParam/result.test b/test/files/scalap/covariantParam/result.test
index 2f52f1f28e..f7a3c98966 100644
--- a/test/files/scalap/covariantParam/result.test
+++ b/test/files/scalap/covariantParam/result.test
@@ -1,4 +1,4 @@
-class CovariantParam[+A] extends java.lang.Object {
+class CovariantParam[+A] extends scala.AnyRef {
   def this() = { /* compiled code */ }
   def foo[A](a : A) : scala.Int = { /* compiled code */ }
 }
diff --git a/test/files/scalap/defaultParameter/result.test b/test/files/scalap/defaultParameter/result.test
index 38bf6ac4e3..0c775ea7b5 100644
--- a/test/files/scalap/defaultParameter/result.test
+++ b/test/files/scalap/defaultParameter/result.test
@@ -1,3 +1,3 @@
-trait DefaultParameter extends java.lang.Object {
+trait DefaultParameter extends scala.AnyRef {
   def foo(s : scala.Predef.String) : scala.Unit
-}
\ No newline at end of file
+}
diff --git a/test/files/scalap/implicitParam/result.test b/test/files/scalap/implicitParam/result.test
index 0ea212dda6..a2cfd6092d 100644
--- a/test/files/scalap/implicitParam/result.test
+++ b/test/files/scalap/implicitParam/result.test
@@ -1,4 +1,4 @@
-class ImplicitParam extends java.lang.Object {
+class ImplicitParam extends scala.AnyRef {
   def this() = { /* compiled code */ }
   def foo(i : scala.Int)(implicit f : scala.Float, d : scala.Double) : scala.Int = { /* compiled code */ }
 }
diff --git a/test/files/scalap/packageObject/result.test b/test/files/scalap/packageObject/result.test
index 94c6a01b08..5732d92958 100644
--- a/test/files/scalap/packageObject/result.test
+++ b/test/files/scalap/packageObject/result.test
@@ -1,4 +1,4 @@
-package object PackageObject extends java.lang.Object {
+package object PackageObject extends scala.AnyRef {
   def this() = { /* compiled code */ }
   type A = scala.Predef.String
   def foo(i : scala.Int) : scala.Int = { /* compiled code */ }
diff --git a/test/files/scalap/paramClauses/result.test b/test/files/scalap/paramClauses/result.test
index dc4397386c..3a141e8faf 100644
--- a/test/files/scalap/paramClauses/result.test
+++ b/test/files/scalap/paramClauses/result.test
@@ -1,4 +1,4 @@
-class ParamClauses extends java.lang.Object {
+class ParamClauses extends scala.AnyRef {
   def this() = { /* compiled code */ }
   def foo(i : scala.Int)(s : scala.Predef.String)(t : scala.Double) : scala.Int = { /* compiled code */ }
 }
diff --git a/test/files/scalap/paramNames/result.test b/test/files/scalap/paramNames/result.test
index 4d3c7d0c1e..85e37f858d 100644
--- a/test/files/scalap/paramNames/result.test
+++ b/test/files/scalap/paramNames/result.test
@@ -1,4 +1,4 @@
-class ParamNames extends java.lang.Object {
+class ParamNames extends scala.AnyRef {
   def this() = { /* compiled code */ }
   def foo(s : => scala.Seq[scala.Int], s2 : => scala.Seq[scala.Any]) : scala.Unit = { /* compiled code */ }
 }
diff --git a/test/files/scalap/sequenceParam/result.test b/test/files/scalap/sequenceParam/result.test
index ed47c094fe..142d92fea3 100644
--- a/test/files/scalap/sequenceParam/result.test
+++ b/test/files/scalap/sequenceParam/result.test
@@ -1,3 +1,3 @@
-class SequenceParam extends java.lang.Object {
+class SequenceParam extends scala.AnyRef {
   def this(s : scala.Predef.String, i : scala.Int*) = { /* compiled code */ }
 }
diff --git a/test/files/scalap/simpleClass/result.test b/test/files/scalap/simpleClass/result.test
index 905046ce52..4fdf25d1cf 100644
--- a/test/files/scalap/simpleClass/result.test
+++ b/test/files/scalap/simpleClass/result.test
@@ -1,4 +1,4 @@
-class SimpleClass extends java.lang.Object {
+class SimpleClass extends scala.AnyRef {
   def this() = { /* compiled code */ }
   def foo : scala.Int = { /* compiled code */ }
 }
diff --git a/test/files/scalap/traitObject/result.test b/test/files/scalap/traitObject/result.test
index d0521043c8..104ba14f1a 100644
--- a/test/files/scalap/traitObject/result.test
+++ b/test/files/scalap/traitObject/result.test
@@ -1,8 +1,8 @@
-trait TraitObject extends java.lang.Object {
+trait TraitObject extends scala.AnyRef {
   def $init$() : scala.Unit = { /* compiled code */ }
   def foo : scala.Int = { /* compiled code */ }
 }
-object TraitObject extends java.lang.Object {
+object TraitObject extends scala.AnyRef {
   def this() = { /* compiled code */ }
   def bar : scala.Int = { /* compiled code */ }
 }
diff --git a/test/files/scalap/typeAnnotations/result.test b/test/files/scalap/typeAnnotations/result.test
index d28712f12b..407b0235c6 100644
--- a/test/files/scalap/typeAnnotations/result.test
+++ b/test/files/scalap/typeAnnotations/result.test
@@ -1,4 +1,4 @@
-abstract class TypeAnnotations[@scala.specialized R] extends java.lang.Object {
+abstract class TypeAnnotations[@scala.specialized R] extends scala.AnyRef {
   def this() = { /* compiled code */ }
   @scala.specialized
   val x : scala.Int = { /* compiled code */ }
diff --git a/test/files/scalap/valAndVar/result.test b/test/files/scalap/valAndVar/result.test
index 90081acade..e940da9801 100644
--- a/test/files/scalap/valAndVar/result.test
+++ b/test/files/scalap/valAndVar/result.test
@@ -1,4 +1,4 @@
-class ValAndVar extends java.lang.Object {
+class ValAndVar extends scala.AnyRef {
   def this() = { /* compiled code */ }
   val foo : java.lang.String = { /* compiled code */ }
   var bar : scala.Int = { /* compiled code */ }
diff --git a/test/files/scalap/wildcardType/result.test b/test/files/scalap/wildcardType/result.test
index 28147b6605..e43261db32 100644
--- a/test/files/scalap/wildcardType/result.test
+++ b/test/files/scalap/wildcardType/result.test
@@ -1,3 +1,3 @@
-class WildcardType extends java.lang.Object {
+class WildcardType extends scala.AnyRef {
   def this(f : scala.Function1[scala.Int, _]) = { /* compiled code */ }
 }
diff --git a/test/osgi/src/BasicReflection.scala b/test/osgi/src/BasicReflection.scala
index 8a0a05d531..68fedb7c83 100644
--- a/test/osgi/src/BasicReflection.scala
+++ b/test/osgi/src/BasicReflection.scala
@@ -1,10 +1,10 @@
 package tools.test.osgi
 package reflection
 package basic
- 
+
 import org.junit.Assert._
 import org.ops4j.pax.exam.CoreOptions._
- 
+
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.ops4j.pax.exam
@@ -41,15 +41,15 @@ object M
 class BasicReflectionTest extends ScalaOsgiHelper {
 
   @Configuration
-  def config(): Array[exam.Option] = 
+  def config(): Array[exam.Option] =
     justReflectionOptions
 
   // Ensure Pax-exam requires C/M in our module
   def dummy = {
     new C
-    M.toString   
+    M.toString
   }
- 
+
   @Test
   def basicMirrorThroughOsgi(): Unit = {
     // Note for now just assert that we can do this stuff.
@@ -57,10 +57,10 @@ class BasicReflectionTest extends ScalaOsgiHelper {
     val cm = runtimeMirror(classOf[C].getClassLoader)
     val im = cm.reflect(new C)
     assertEquals("Unable to reflect field name!",
-                 "value f1", 
-                 im.reflectField(typeOf[C].member(newTermName("f1")).asTerm).symbol.toString)
+                 "value f1",
+                 im.reflectField(typeOf[C].member(TermName("f1")).asTerm).symbol.toString)
     assertEquals("Unable to reflect value!",
-                 2, 
-                 im.reflectField(typeOf[C].member(newTermName("f1")).asTerm).get)
+                 2,
+                 im.reflectField(typeOf[C].member(TermName("f1")).asTerm).get)
  }
 }
diff --git a/test/pending/run/hk-lub-fail.scala b/test/pending/run/hk-lub-fail.scala
index b58a86ee75..0ac4fdd841 100644
--- a/test/pending/run/hk-lub-fail.scala
+++ b/test/pending/run/hk-lub-fail.scala
@@ -25,12 +25,12 @@ object Test {
 
   // A repl session to get you started.
 /*
-  val quux1 = EmptyPackageClass.tpe.member(newTermName("Quux1"))
-  val quux2 = EmptyPackageClass.tpe.member(newTermName("Quux2"))
+  val quux1 = EmptyPackageClass.tpe.member(TermName("Quux1"))
+  val quux2 = EmptyPackageClass.tpe.member(TermName("Quux2"))
   val tps   = List(quux1, quux2) map (_.tpe)
-  val test  = EmptyPackageClass.tpe.member(newTermName("Test"))
-  val f     = test.tpe.member(newTypeName("F")).tpe
-  
+  val test  = EmptyPackageClass.tpe.member(TermName("Test"))
+  val f     = test.tpe.member(TypeName("F")).tpe
+
   val fn    = f.normalize.asInstanceOf[ExistentialType]
   val fn2   = fn.underlying.asInstanceOf[TypeRef]
 */
diff --git a/test/pending/run/macro-expand-default/Impls_1.scala b/test/pending/run/macro-expand-default/Impls_1.scala
index 7cf8d59c75..bb55f02ab2 100644
--- a/test/pending/run/macro-expand-default/Impls_1.scala
+++ b/test/pending/run/macro-expand-default/Impls_1.scala
@@ -3,8 +3,8 @@ import scala.reflect.macros.{Context => Ctx}
 object Impls {
   def foo(c: Ctx)(x: c.Expr[Int], y: c.Expr[Int]) = {
     import c.universe._
-    val sum = Apply(Select(x.tree, newTermName("$minus")), List(y.tree))
-    val body = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(sum))
+    val sum = Apply(Select(x.tree, TermName("$minus")), List(y.tree))
+    val body = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(sum))
     Expr[Unit](body)
   }
 }
\ No newline at end of file
diff --git a/test/pending/run/macro-expand-macro-has-context-bound/Impls_1.scala b/test/pending/run/macro-expand-macro-has-context-bound/Impls_1.scala
index be00fd0d8a..eed68280cd 100644
--- a/test/pending/run/macro-expand-macro-has-context-bound/Impls_1.scala
+++ b/test/pending/run/macro-expand-macro-has-context-bound/Impls_1.scala
@@ -3,8 +3,8 @@ import scala.reflect.macros.{Context => Ctx}
 object Impls {
   def foo[U](c: Ctx)(x: c.Expr[U])(evidence: c.Expr[Numeric[U]]) = {
     import c.universe._
-    val plusOne = Apply(Select(evidence.tree, newTermName("plus")), List(x.tree, Literal(Constant(1))))
-    val body = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(plusOne))
+    val plusOne = Apply(Select(evidence.tree, TermName("plus")), List(x.tree, Literal(Constant(1))))
+    val body = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(plusOne))
     Expr[Unit](body)
   }
 }
\ No newline at end of file
diff --git a/test/pending/run/macro-expand-named/Impls_1.scala b/test/pending/run/macro-expand-named/Impls_1.scala
index 7cf8d59c75..bb55f02ab2 100644
--- a/test/pending/run/macro-expand-named/Impls_1.scala
+++ b/test/pending/run/macro-expand-named/Impls_1.scala
@@ -3,8 +3,8 @@ import scala.reflect.macros.{Context => Ctx}
 object Impls {
   def foo(c: Ctx)(x: c.Expr[Int], y: c.Expr[Int]) = {
     import c.universe._
-    val sum = Apply(Select(x.tree, newTermName("$minus")), List(y.tree))
-    val body = Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(sum))
+    val sum = Apply(Select(x.tree, TermName("$minus")), List(y.tree))
+    val body = Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(sum))
     Expr[Unit](body)
   }
 }
\ No newline at end of file
diff --git a/test/pending/run/macro-expand-tparams-prefix-e1/Impls_1.scala b/test/pending/run/macro-expand-tparams-prefix-e1/Impls_1.scala
index 26de70cc12..487ac79673 100644
--- a/test/pending/run/macro-expand-tparams-prefix-e1/Impls_1.scala
+++ b/test/pending/run/macro-expand-tparams-prefix-e1/Impls_1.scala
@@ -4,9 +4,9 @@ object Impls {
   def foo[T, U: c.WeakTypeTag, V](c: Ctx)(implicit T: c.WeakTypeTag[T], V: c.WeakTypeTag[V]): c.Expr[Unit] = {
     import c.universe._
     Block(List(
-      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(T.toString)))),
-      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(implicitly[c.WeakTypeTag[U]].toString)))),
-      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(V.toString))))),
+      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(())))
   }
 }
\ No newline at end of file
diff --git a/test/pending/run/macro-expand-tparams-prefix-f1/Impls_1.scala b/test/pending/run/macro-expand-tparams-prefix-f1/Impls_1.scala
index 26de70cc12..487ac79673 100644
--- a/test/pending/run/macro-expand-tparams-prefix-f1/Impls_1.scala
+++ b/test/pending/run/macro-expand-tparams-prefix-f1/Impls_1.scala
@@ -4,9 +4,9 @@ object Impls {
   def foo[T, U: c.WeakTypeTag, V](c: Ctx)(implicit T: c.WeakTypeTag[T], V: c.WeakTypeTag[V]): c.Expr[Unit] = {
     import c.universe._
     Block(List(
-      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(T.toString)))),
-      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(implicitly[c.WeakTypeTag[U]].toString)))),
-      Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Literal(Constant(V.toString))))),
+      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(())))
   }
 }
\ No newline at end of file
diff --git a/test/pending/run/macro-reify-tagless-b/Test_2.scala b/test/pending/run/macro-reify-tagless-b/Test_2.scala
index 10487b1515..09ca6ba30e 100644
--- a/test/pending/run/macro-reify-tagless-b/Test_2.scala
+++ b/test/pending/run/macro-reify-tagless-b/Test_2.scala
@@ -6,8 +6,8 @@ object Test extends App {
   import scala.reflect.runtime.{currentMirror => cm}
   import scala.tools.reflect.ToolBox
   val tpt = AppliedTypeTree(Ident(definitions.ListClass), List(Ident(definitions.StringClass)))
-  val rhs = Apply(Select(Ident(newTermName("Macros")), newTermName("foo")), List(Literal(Constant("hello world"))))
-  val list = ValDef(NoMods, newTermName("list"), tpt, rhs)
-  val tree = Block(list, Apply(Select(Ident(definitions.PredefModule), newTermName("println")), List(Ident(list.name))))
+  val rhs = Apply(Select(Ident(TermName("Macros")), TermName("foo")), List(Literal(Constant("hello world"))))
+  val list = ValDef(NoMods, TermName("list"), tpt, rhs)
+  val tree = Block(list, Apply(Select(Ident(definitions.PredefModule), TermName("println")), List(Ident(list.name))))
   println(cm.mkToolBox().eval(tree))
 }
diff --git a/test/pending/run/t5427a.scala b/test/pending/run/t5427a.scala
index f7cd05158d..a7d20922db 100644
--- a/test/pending/run/t5427a.scala
+++ b/test/pending/run/t5427a.scala
@@ -4,7 +4,7 @@ object Foo { val bar = 2 }
 
 object Test extends App {
   val tpe = getType(Foo)
-  val bar = tpe.nonPrivateMember(newTermName("bar"))
+  val bar = tpe.nonPrivateMember(TermName("bar"))
   val value = getValue(Foo, bar)
   println(value)
 }
\ No newline at end of file
diff --git a/test/pending/run/t5427b.scala b/test/pending/run/t5427b.scala
index e80bd12369..af1ae6ea2f 100644
--- a/test/pending/run/t5427b.scala
+++ b/test/pending/run/t5427b.scala
@@ -5,7 +5,7 @@ class Foo { val bar = 2 }
 object Test extends App {
   val foo = new Foo
   val tpe = getType(foo)
-  val bar = tpe.nonPrivateMember(newTermName("bar"))
+  val bar = tpe.nonPrivateMember(TermName("bar"))
   val value = getValue(foo, bar)
   println(value)
 }
\ No newline at end of file
diff --git a/test/pending/run/t5427c.scala b/test/pending/run/t5427c.scala
index 7095158e85..ba71803080 100644
--- a/test/pending/run/t5427c.scala
+++ b/test/pending/run/t5427c.scala
@@ -5,7 +5,7 @@ class Foo(bar: Int)
 object Test extends App {
   val foo = new Foo(2)
   val tpe = getType(foo)
-  val bar = tpe.nonPrivateMember(newTermName("bar"))
+  val bar = tpe.nonPrivateMember(TermName("bar"))
   bar match {
     case NoSymbol => println("no public member")
     case _ => println("i'm screwed")
diff --git a/test/pending/run/t5427d.scala b/test/pending/run/t5427d.scala
index f0cc07d27e..1d37dbdde3 100644
--- a/test/pending/run/t5427d.scala
+++ b/test/pending/run/t5427d.scala
@@ -5,7 +5,7 @@ class Foo(val bar: Int)
 object Test extends App {
   val foo = new Foo(2)
   val tpe = getType(foo)
-  val bar = tpe.nonPrivateMember(newTermName("bar"))
+  val bar = tpe.nonPrivateMember(TermName("bar"))
   val value = getValue(foo, bar)
   println(value)
 }
\ No newline at end of file