214 files changed, 2301 insertions, 359 deletions
diff --git a/test/files/neg/macro-blackbox-dynamic-materialization/Macros_1.scala b/test/files/neg/macro-blackbox-dynamic-materialization/Macros_1.scala
index 3cfbdf45e9..fc2907b6dc 100644
--- a/test/files/neg/macro-blackbox-dynamic-materialization/Macros_1.scala
+++ b/test/files/neg/macro-blackbox-dynamic-materialization/Macros_1.scala
@@ -18,7 +18,7 @@ object Macros {
   def impl[T: c.WeakTypeTag](c: Context) = {
     import c.universe._
     val tpe = weakTypeOf[T]
-    if (tpe.members.exists(_.typeSignature =:= typeOf[Int]))
+    if (tpe.members.exists(_.info =:= typeOf[Int]))
       c.abort(c.enclosingPosition, "I don't like classes that contain integers")
     q"new Foo[$tpe]{ override def toString = ${tpe.toString} }"
   }
diff --git a/test/files/neg/macro-blackbox-fundep-materialization/Macros_1.scala b/test/files/neg/macro-blackbox-fundep-materialization/Macros_1.scala
index a6f7de23bb..8d776388ee 100644
--- a/test/files/neg/macro-blackbox-fundep-materialization/Macros_1.scala
+++ b/test/files/neg/macro-blackbox-fundep-materialization/Macros_1.scala
@@ -15,12 +15,12 @@ object Iso {
 
     val sym = c.weakTypeOf[T].typeSymbol
     if (!sym.isClass || !sym.asClass.isCaseClass) c.abort(c.enclosingPosition, s"$sym is not a case class")
-    val fields = sym.typeSignature.declarations.toList.collect{ case x: TermSymbol if x.isVal && x.isCaseAccessor => x }
+    val fields = sym.info.decls.toList.collect{ case x: TermSymbol if x.isVal && x.isCaseAccessor => x }
 
     def mkTpt() = {
       val core = Ident(TupleClass(fields.length) orElse UnitClass)
       if (fields.length == 0) core
-      else AppliedTypeTree(core, fields map (f => TypeTree(f.typeSignature)))
+      else AppliedTypeTree(core, fields map (f => TypeTree(f.info)))
     }
 
     def mkFrom() = {
@@ -32,8 +32,8 @@ object Iso {
       List(AppliedTypeTree(Ident(newTypeName("Iso")), List(Ident(sym), mkTpt()))),
       emptyValDef,
       List(
-        DefDef(Modifiers(), nme.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(Apply(Select(Super(This(tpnme.EMPTY), tpnme.EMPTY), nme.CONSTRUCTOR), List())), Literal(Constant(())))),
+        DefDef(Modifiers(), termNames.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(Apply(Select(Super(This(typeNames.EMPTY), typeNames.EMPTY), termNames.CONSTRUCTOR), List())), Literal(Constant(())))),
         DefDef(Modifiers(), newTermName("to"), List(), List(List(ValDef(Modifiers(PARAM), newTermName("f"), Ident(sym), EmptyTree))), TypeTree(), mkFrom()))))
-    c.Expr[Iso[T, U]](Block(List(evidenceClass), Apply(Select(New(Ident(newTypeName("$anon"))), nme.CONSTRUCTOR), List())))
+    c.Expr[Iso[T, U]](Block(List(evidenceClass), Apply(Select(New(Ident(newTypeName("$anon"))), termNames.CONSTRUCTOR), List())))
   }
 }
diff --git a/test/files/neg/macro-divergence-controlled/Impls_Macros_1.scala b/test/files/neg/macro-divergence-controlled/Impls_Macros_1.scala
index 186c285871..5c04503260 100644
--- a/test/files/neg/macro-divergence-controlled/Impls_Macros_1.scala
+++ b/test/files/neg/macro-divergence-controlled/Impls_Macros_1.scala
@@ -9,8 +9,8 @@ object Complex {
   def impl[T: c.WeakTypeTag](c: Context): c.Expr[Complex[T]] = {
     import c.universe._
     val tpe = weakTypeOf[T]
-    for (f <- tpe.declarations.collect{case f: TermSymbol if f.isParamAccessor && !f.isMethod => f}) {
-      val trecur = appliedType(typeOf[Complex[_]], List(f.typeSignature))
+    for (f <- tpe.decls.collect{case f: TermSymbol if f.isParamAccessor && !f.isMethod => f}) {
+      val trecur = appliedType(typeOf[Complex[_]], List(f.info))
       if (c.openImplicits.tail.exists(ic => ic.pt =:= trecur)) c.abort(c.enclosingPosition, "diverging implicit expansion. reported by a macro!")
       val recur = c.inferImplicitValue(trecur, silent = true)
       if (recur == EmptyTree) c.abort(c.enclosingPosition, s"couldn't synthesize $trecur")
diff --git a/test/files/neg/t6323a.check b/test/files/neg/t6323a.check
index b649cfc86f..261a60ef3c 100644
--- a/test/files/neg/t6323a.check
+++ b/test/files/neg/t6323a.check
@@ -6,7 +6,7 @@ t6323a.scala:11: materializing requested reflect.runtime.universe.type.TypeTag[T
                           ^
 t6323a.scala:11: `package`.this.materializeTypeTag[Test](scala.reflect.runtime.`package`.universe) is not a valid implicit value for reflect.runtime.universe.TypeTag[Test] because:
 failed to typecheck the materialized tag:
-cannot create a TypeTag referring to local class Test.Test: use WeakTypeTag instead
+cannot create a TypeTag referring to class Test.Test local to the reifee: use WeakTypeTag instead
       val value = u.typeOf[Test]
                           ^
 t6323a.scala:11: error: No TypeTag available for Test
diff --git a/test/files/neg/t6931.check b/test/files/neg/t6931.check
new file mode 100644
index 0000000000..7cf804a936
--- /dev/null
+++ b/test/files/neg/t6931.check
@@ -0,0 +1,10 @@
+Test_2.scala:3: error: 1
+  err"123"
+      ^
+Test_2.scala:3: error: 2
+  err"123"
+       ^
+Test_2.scala:3: error: 3
+  err"123"
+        ^
+three errors found
diff --git a/test/files/neg/t6931/Macros_1.scala b/test/files/neg/t6931/Macros_1.scala
new file mode 100644
index 0000000000..56da075d1f
--- /dev/null
+++ b/test/files/neg/t6931/Macros_1.scala
@@ -0,0 +1,15 @@
+import scala.language.experimental.macros
+import scala.reflect.macros.blackbox.Context
+
+object Macros {
+  implicit class Error(ctx: StringContext) {
+    def err(args: Any*): Unit = macro impl
+  }
+
+  def impl(c: Context)(args: c.Tree*): c.Tree = {
+    import c.universe._
+    val q"Macros.Error(scala.StringContext.apply($arg)).err()" = c.macroApplication
+    for (i <- 1 to 3) c.error(arg.pos.withPoint(arg.pos.point + i - 1), i.toString)
+    q"()"
+  }
+}
+\ No newline at end of file
diff --git a/test/files/neg/t6931/Test_2.scala b/test/files/neg/t6931/Test_2.scala
new file mode 100644
index 0000000000..6a6f645904
--- /dev/null
+++ b/test/files/neg/t6931/Test_2.scala
@@ -0,0 +1,4 @@
+object Test extends App {
+  import Macros._
+  err"123"
+}
+\ No newline at end of file
diff --git a/test/files/neg/t8104/Macros_1.scala b/test/files/neg/t8104/Macros_1.scala
index 2ad4bc5a99..e135bd807b 100644
--- a/test/files/neg/t8104/Macros_1.scala
+++ b/test/files/neg/t8104/Macros_1.scala
@@ -4,8 +4,8 @@ object Macros {
   def impl[T](c: Context)(implicit T: c.WeakTypeTag[T]) = {
     import c.universe._
     import definitions._
-    val fields = T.tpe.declarations.toList.collect{ case x: TermSymbol if x.isVal && x.isCaseAccessor => x }
-    val Repr = appliedType(TupleClass(fields.length).asType.toType, fields.map(_.typeSignature))
+    val fields = T.tpe.decls.toList.collect{ case x: TermSymbol if x.isVal && x.isCaseAccessor => x }
+    val Repr = appliedType(TupleClass(fields.length).asType.toType, fields.map(_.info))
     q"new Generic[$T]{ type Repr = $Repr }"
   }
 }
 \ No newline at end of file
diff --git a/test/files/neg/t8300-overloading.check b/test/files/neg/t8300-overloading.check
new file mode 100644
index 0000000000..edd34d44bd
--- /dev/null
+++ b/test/files/neg/t8300-overloading.check
@@ -0,0 +1,7 @@
+t8300-overloading.scala:15: error: double definition:
+def foo(name: Test.u.Name): Nothing at line 14 and
+def foo(name: Test.u.TermName): Nothing at line 15
+have same type after erasure: (name: Universe#NameApi)Nothing
+  def foo(name: TermName) = ???
+      ^
+one error found
diff --git a/test/files/neg/t8300-overloading.scala b/test/files/neg/t8300-overloading.scala
new file mode 100644
index 0000000000..eb393155a0
--- /dev/null
+++ b/test/files/neg/t8300-overloading.scala
@@ -0,0 +1,16 @@
+// cf. pos/t8300-overloading.scala
+trait Universe {
+  type Name >: Null <: AnyRef with NameApi
+  trait NameApi
+
+  type TermName >: Null <: Name with TermNameApi
+  trait TermNameApi extends NameApi
+}
+
+object Test extends App {
+  val u: Universe = ???
+  import u._
+
+  def foo(name: Name) = ???
+  def foo(name: TermName) = ???
+}
+\ No newline at end of file
diff --git a/test/files/pos/annotated-treecopy/Impls_Macros_1.scala b/test/files/pos/annotated-treecopy/Impls_Macros_1.scala
index fdf9c72c31..79edbfffd8 100644
--- a/test/files/pos/annotated-treecopy/Impls_Macros_1.scala
+++ b/test/files/pos/annotated-treecopy/Impls_Macros_1.scala
@@ -15,6 +15,7 @@ object Macros {
   def tree_impl[T:c.WeakTypeTag,U:c.WeakTypeTag](c: Context)
       (f:c.Expr[Function1[T,U]]): c.Expr[Function1[T,U]] = {
     import c.universe._
+    import internal._
     val ttag = c.weakTypeTag[U]
     f match {
       case Expr(Function(List(ValDef(_,n,tp,_)),b)) =>
@@ -22,7 +23,7 @@ object Macros {
         var b1 = new Transformer {
           override def transform(tree: Tree): Tree = tree match {
             case Ident(x) if (x==n) => Ident(TermName("_arg"))
-            case tt: TypeTree if tt.original != null => TypeTree(tt.tpe) setOriginal transform(tt.original)
+            case tt: TypeTree if tt.original != null => setOriginal(TypeTree(tt.tpe), transform(tt.original))
             // without the fix to LazyTreeCopier.Annotated, we would need to uncomment the line below to make the macro work
             // that's because the pattern match in the input expression gets expanded into Typed(<x>, TypeTree(<Int @unchecked>))
             // with the original of the TypeTree being Annotated(<@unchecked>, Ident(<x>))
@@ -34,7 +35,7 @@ object Macros {
           }
         }.transform(b)
 
-        val reifiedTree = c.reifyTree(treeBuild.mkRuntimeUniverseRef, EmptyTree, b1)
+        val reifiedTree = c.reifyTree(gen.mkRuntimeUniverseRef, EmptyTree, b1)
         val reifiedExpr = c.Expr[scala.reflect.runtime.universe.Expr[T => U]](reifiedTree)
         val template =
           c.universe.reify(new (T => U) with TypedFunction {
diff --git a/test/files/pos/attachments-typed-another-ident/Impls_1.scala b/test/files/pos/attachments-typed-another-ident/Impls_1.scala
index 8016143a4c..98062a9c76 100644
--- a/test/files/pos/attachments-typed-another-ident/Impls_1.scala
+++ b/test/files/pos/attachments-typed-another-ident/Impls_1.scala
@@ -6,10 +6,11 @@ object MyAttachment
 object Macros {
   def impl(c: Context) = {
     import c.universe._
-    val ident = Ident(TermName("bar")) updateAttachment MyAttachment
-    assert(ident.attachments.get[MyAttachment.type].isDefined, ident.attachments)
+    import internal._
+    val ident = updateAttachment(Ident(TermName("bar")), MyAttachment)
+    assert(attachments(ident).get[MyAttachment.type].isDefined, attachments(ident))
     val typed = c.typecheck(ident)
-    assert(typed.attachments.get[MyAttachment.type].isDefined, typed.attachments)
+    assert(attachments(typed).get[MyAttachment.type].isDefined, attachments(typed))
     c.Expr[Int](typed)
   }
 
diff --git a/test/files/pos/attachments-typed-ident/Impls_1.scala b/test/files/pos/attachments-typed-ident/Impls_1.scala
index af2cc59ecd..25c0891880 100644
--- a/test/files/pos/attachments-typed-ident/Impls_1.scala
+++ b/test/files/pos/attachments-typed-ident/Impls_1.scala
@@ -6,10 +6,11 @@ object MyAttachment
 object Macros {
   def impl(c: Context) = {
     import c.universe._
-    val ident = Ident(TermName("bar")) updateAttachment MyAttachment
-    assert(ident.attachments.get[MyAttachment.type].isDefined, ident.attachments)
+    import internal._
+    val ident = updateAttachment(Ident(TermName("bar")), MyAttachment)
+    assert(attachments(ident).get[MyAttachment.type].isDefined, attachments(ident))
     val typed = c.typecheck(ident)
-    assert(typed.attachments.get[MyAttachment.type].isDefined, typed.attachments)
+    assert(attachments(typed).get[MyAttachment.type].isDefined, attachments(typed))
     c.Expr[Int](typed)
   }
 
diff --git a/test/files/pos/reflection-compat-api-universe.check b/test/files/pos/reflection-compat-api-universe.check
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/test/files/pos/reflection-compat-api-universe.check
diff --git a/test/files/pos/reflection-compat-api-universe.scala b/test/files/pos/reflection-compat-api-universe.scala
new file mode 100644
index 0000000000..0aee8bcda5
--- /dev/null
+++ b/test/files/pos/reflection-compat-api-universe.scala
@@ -0,0 +1,136 @@
+object Test extends App {
+  val u: scala.reflect.api.Universe = ???
+  import u._
+  import scala.reflect.ClassTag
+  import compat._
+
+  val tree: Tree = ???
+  val ttree: TypeTree = ???
+  val stree: SymTree = ???
+  val trees: List[Tree] = ???
+  val mods: Modifiers = ???
+  val impl: Template = ???
+  val vparamss: List[List[ValDef]] = ???
+  val rhs: Tree = ???
+  val sym: Symbol = ???
+  val tsym: TypeSymbol = ???
+  val syms: List[Symbol] = ???
+  val params: List[Symbol] = ???
+  val tparams: List[Symbol] = ???
+  val tpe: Type = ???
+  val tpes: List[Type] = ???
+  val manifest: Manifest[Int] = ???
+  val tag: TypeTag[Int] = ???
+  val mirror: Mirror = ???
+  val decls: Scope = ???
+  val pos: Position = ???
+  val ann: Annotation = ???
+  val anns: List[Annotation] = ???
+  val const: Constant = ???
+  val name: Name = ???
+  val tyname: TypeName = ???
+  val tename: TermName = ???
+  val flags: FlagSet = ???
+  val str: String = ???
+  val i: Int = ???
+  val b: Boolean = ???
+
+  // abstract class BuildApi
+  // abstract class ReferenceToBoxedExtractor
+  // abstract trait AttachableApi
+  // abstract trait FreeTermSymbolApi
+  // abstract trait FreeTypeSymbolApi
+  // abstract trait IdentContextApi
+  // abstract trait ReferenceToBoxedApi
+  // abstract trait SymTreeContextApi
+  // abstract trait SymbolContextApi
+  // abstract trait TreeContextApi
+  // abstract trait TypeTreeContextApi
+  locally(ClassDef(sym, impl): ClassDef)
+  locally(DefDef(sym, mods, vparamss, rhs): DefDef)
+  locally(DefDef(sym, vparamss, rhs): DefDef)
+  locally(DefDef(sym, mods, rhs): DefDef)
+  locally(DefDef(sym, rhs): DefDef)
+  locally(DefDef(sym, (??? : List[List[Symbol]] => Tree)): DefDef)
+  locally(LabelDef(sym, params, rhs): LabelDef)
+  locally(ModuleDef(sym, impl): ModuleDef)
+  locally(TypeDef(sym, rhs): TypeDef)
+  locally(TypeDef(sym): TypeDef)
+  locally(ValDef(sym, rhs): ValDef)
+  locally(ValDef(sym): ValDef)
+  locally(AnnotatedType(anns, tpe): AnnotatedType)
+  locally(BoundedWildcardType(??? : TypeBounds): BoundedWildcardType)
+  locally(TypeBounds(tpe, tpe): TypeBounds)
+  locally(MethodType(params, tpe): MethodType)
+  locally(RefinedType(tpes, decls): RefinedType)
+  locally(RefinedType(tpes, decls, sym): RefinedType)
+  locally(ClassInfoType(tpes, decls, sym): ClassInfoType)
+  locally(SingleType(tpe, sym): Type)
+  locally(TypeRef(tpe, sym, tpes): Type)
+  locally(ExistentialType(syms, tpe): ExistentialType)
+  locally(NullaryMethodType(tpe): NullaryMethodType)
+  locally(ThisType(sym): Type)
+  locally(SuperType(tpe, tpe): Type)
+  locally(PolyType(syms, tpe): PolyType)
+  locally(ConstantType(const): ConstantType)
+  locally(sym.asFreeTerm: FreeTermSymbol)
+  locally(sym.asFreeType: FreeTypeSymbol)
+  locally(existentialAbstraction(tparams, tpe): Type)
+  locally(tree.freeTerms: List[FreeTermSymbol])
+  locally(tree.freeTypes: List[FreeTypeSymbol])
+  locally(intersectionType(tpes): Type)
+  locally(intersectionType(tpes, sym): Type)
+  locally(sym.isErroneous: Boolean)
+  locally(sym.isFreeTerm: Boolean)
+  locally(sym.isFreeType: Boolean)
+  locally(sym.isLocal: Boolean)
+  locally(sym.isOverride: Boolean)
+  locally(tsym.isSkolem: Boolean)
+  locally(manifestToTypeTag(mirror, manifest): scala.reflect.api.Universe#TypeTag[Int])
+  locally(mkImporter(scala.reflect.runtime.universe): Importer{val from: scala.reflect.runtime.universe.type})
+  locally(sym.newClassSymbol(tyname, pos, flags): ClassSymbol)
+  locally(sym.newMethodSymbol(tename, pos, flags): MethodSymbol)
+  locally(sym.newModuleAndClassSymbol(name, pos, flags): (ModuleSymbol, ClassSymbol))
+  locally(newScopeWith(sym, sym, sym): Scope)
+  locally(sym.newTermSymbol(tename, pos, flags): TermSymbol)
+  locally(sym.newTypeSymbol(tyname, pos, flags): TypeSymbol)
+  locally(polyType(tparams, tpe): Type)
+  locally(sym.pos: Position)
+  locally(refinedType(tpes, sym): Type)
+  locally(refinedType(tpes, sym, decls, pos): Type)
+  locally(singleType(tpe, sym): Type)
+  locally(tree.substituteSymbols(syms, syms): Tree)
+  locally(tree.substituteThis(sym, tree): Tree)
+  locally(tree.substituteTypes(syms, tpes): Tree)
+  locally(typeRef(tpe, sym, tpes): Type)
+  locally(typeTagToManifest(mirror, tag): Manifest[Int])
+  locally(FreeTermSymbolTag: ClassTag[FreeTermSymbol])
+  locally((??? : FreeTermSymbol).origin)
+  locally((??? : FreeTermSymbol).value)
+  locally(FreeTypeSymbolTag: ClassTag[FreeTypeSymbol])
+  locally((??? : FreeTypeSymbol).origin)
+  locally(ReferenceToBoxedTag: ClassTag[ReferenceToBoxed])
+  locally(build: BuildApi)
+  locally(ReferenceToBoxed(??? : Ident): ReferenceToBoxed)
+  locally((??? : ReferenceToBoxed).ident: Tree)
+  locally(ReferenceToBoxed.unapply(???): Option[Ident])
+  locally(build.selectType(sym, str): TypeSymbol)
+  locally(build.selectTerm(sym, str): TermSymbol)
+  locally(build.selectOverloadedMethod(sym, str, i): MethodSymbol)
+  locally(build.newNestedSymbol(sym, name, pos, flags, b): Symbol)
+  locally(build.newFreeTerm(str, i): FreeTermSymbol)
+  locally(build.newFreeTerm(str, i, flags, str): FreeTermSymbol)
+  locally(build.newFreeType(str): FreeTypeSymbol)
+  locally(build.newFreeType(str, flags, str): FreeTypeSymbol)
+  locally(build.setTypeSignature(sym, tpe): Symbol)
+  locally(build.setAnnotations(sym, anns): Symbol)
+  locally(build.flagsFromBits(??? : Long): FlagSet)
+  locally(build.emptyValDef: ValDef)
+  locally(build.This(sym): Tree)
+  locally(build.Select(tree, sym): Select)
+  locally(build.Ident(sym): Ident)
+  locally(build.TypeTree(tpe): TypeTree)
+  locally(build.thisPrefix(sym): Type)
+  locally(build.setType(tree, tpe): Tree)
+  locally(build.setSymbol(tree, sym): Tree)
+}
+\ No newline at end of file
diff --git a/test/files/pos/reflection-compat-c.check b/test/files/pos/reflection-compat-c.check
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/test/files/pos/reflection-compat-c.check
diff --git a/test/files/pos/reflection-compat-c.scala b/test/files/pos/reflection-compat-c.scala
new file mode 100644
index 0000000000..73158decdc
--- /dev/null
+++ b/test/files/pos/reflection-compat-c.scala
@@ -0,0 +1,139 @@
+import scala.reflect.macros.Context
+
+object Test extends App {
+  def impl(c: Context) = {
+    import c.universe._
+    import scala.reflect.ClassTag
+    import compat._
+
+    val tree: Tree = ???
+    val ttree: TypeTree = ???
+    val stree: SymTree = ???
+    val trees: List[Tree] = ???
+    val mods: Modifiers = ???
+    val impl: Template = ???
+    val vparamss: List[List[ValDef]] = ???
+    val rhs: Tree = ???
+    val sym: Symbol = ???
+    val tsym: TypeSymbol = ???
+    val syms: List[Symbol] = ???
+    val params: List[Symbol] = ???
+    val tparams: List[Symbol] = ???
+    val tpe: Type = ???
+    val tpes: List[Type] = ???
+    val manifest: Manifest[Int] = ???
+    val tag: TypeTag[Int] = ???
+    val mirror: Mirror = ???
+    val decls: Scope = ???
+    val pos: Position = ???
+    val ann: Annotation = ???
+    val anns: List[Annotation] = ???
+    val const: Constant = ???
+    val name: Name = ???
+    val tyname: TypeName = ???
+    val tename: TermName = ???
+    val flags: FlagSet = ???
+    val str: String = ???
+    val i: Int = ???
+    val b: Boolean = ???
+
+    // abstract class BuildApi
+    // abstract class ReferenceToBoxedExtractor
+    // abstract trait AttachableApi
+    // abstract trait FreeTermSymbolApi
+    // abstract trait FreeTypeSymbolApi
+    // abstract trait IdentContextApi
+    // abstract trait ReferenceToBoxedApi
+    // abstract trait SymTreeContextApi
+    // abstract trait SymbolContextApi
+    // abstract trait TreeContextApi
+    // abstract trait TypeTreeContextApi
+    locally(ClassDef(sym, impl): ClassDef)
+    locally(DefDef(sym, mods, vparamss, rhs): DefDef)
+    locally(DefDef(sym, vparamss, rhs): DefDef)
+    locally(DefDef(sym, mods, rhs): DefDef)
+    locally(DefDef(sym, rhs): DefDef)
+    locally(DefDef(sym, (??? : List[List[Symbol]] => Tree)): DefDef)
+    locally(LabelDef(sym, params, rhs): LabelDef)
+    locally(ModuleDef(sym, impl): ModuleDef)
+    locally(TypeDef(sym, rhs): TypeDef)
+    locally(TypeDef(sym): TypeDef)
+    locally(ValDef(sym, rhs): ValDef)
+    locally(ValDef(sym): ValDef)
+    locally(AnnotatedType(anns, tpe): AnnotatedType)
+    locally(BoundedWildcardType(??? : TypeBounds): BoundedWildcardType)
+    locally(TypeBounds(tpe, tpe): TypeBounds)
+    locally(MethodType(params, tpe): MethodType)
+    locally(RefinedType(tpes, decls): RefinedType)
+    locally(RefinedType(tpes, decls, sym): RefinedType)
+    locally(ClassInfoType(tpes, decls, sym): ClassInfoType)
+    locally(SingleType(tpe, sym): Type)
+    locally(TypeRef(tpe, sym, tpes): Type)
+    locally(ExistentialType(syms, tpe): ExistentialType)
+    locally(NullaryMethodType(tpe): NullaryMethodType)
+    locally(ThisType(sym): Type)
+    locally(SuperType(tpe, tpe): Type)
+    locally(PolyType(syms, tpe): PolyType)
+    locally(ConstantType(const): ConstantType)
+    locally(sym.asFreeTerm: FreeTermSymbol)
+    locally(sym.asFreeType: FreeTypeSymbol)
+    locally(existentialAbstraction(tparams, tpe): Type)
+    locally(tree.freeTerms: List[FreeTermSymbol])
+    locally(tree.freeTypes: List[FreeTypeSymbol])
+    locally(intersectionType(tpes): Type)
+    locally(intersectionType(tpes, sym): Type)
+    locally(sym.isErroneous: Boolean)
+    locally(sym.isFreeTerm: Boolean)
+    locally(sym.isFreeType: Boolean)
+    locally(sym.isLocal: Boolean)
+    locally(sym.isOverride: Boolean)
+    locally(tsym.isSkolem: Boolean)
+    locally(manifestToTypeTag(mirror, manifest): scala.reflect.api.Universe#TypeTag[Int])
+    locally(mkImporter(scala.reflect.runtime.universe): Importer{val from: scala.reflect.runtime.universe.type})
+    locally(sym.newClassSymbol(tyname, pos, flags): ClassSymbol)
+    locally(sym.newMethodSymbol(tename, pos, flags): MethodSymbol)
+    locally(sym.newModuleAndClassSymbol(name, pos, flags): (ModuleSymbol, ClassSymbol))
+    locally(newScopeWith(sym, sym, sym): Scope)
+    locally(sym.newTermSymbol(tename, pos, flags): TermSymbol)
+    locally(sym.newTypeSymbol(tyname, pos, flags): TypeSymbol)
+    locally(polyType(tparams, tpe): Type)
+    locally(sym.pos: Position)
+    locally(refinedType(tpes, sym): Type)
+    locally(refinedType(tpes, sym, decls, pos): Type)
+    locally(singleType(tpe, sym): Type)
+    locally(tree.substituteSymbols(syms, syms): Tree)
+    locally(tree.substituteThis(sym, tree): Tree)
+    locally(tree.substituteTypes(syms, tpes): Tree)
+    locally(typeRef(tpe, sym, tpes): Type)
+    locally(typeTagToManifest(mirror, tag): Manifest[Int])
+    locally(FreeTermSymbolTag: ClassTag[FreeTermSymbol])
+    locally((??? : FreeTermSymbol).origin)
+    locally((??? : FreeTermSymbol).value)
+    locally(FreeTypeSymbolTag: ClassTag[FreeTypeSymbol])
+    locally((??? : FreeTypeSymbol).origin)
+    locally(ReferenceToBoxedTag: ClassTag[ReferenceToBoxed])
+    locally(build: BuildApi)
+    locally(ReferenceToBoxed(??? : Ident): ReferenceToBoxed)
+    locally((??? : ReferenceToBoxed).ident: Tree)
+    locally(ReferenceToBoxed.unapply(???): Option[Ident])
+    locally(build.selectType(sym, str): TypeSymbol)
+    locally(build.selectTerm(sym, str): TermSymbol)
+    locally(build.selectOverloadedMethod(sym, str, i): MethodSymbol)
+    locally(build.newNestedSymbol(sym, name, pos, flags, b): Symbol)
+    locally(build.newFreeTerm(str, i): FreeTermSymbol)
+    locally(build.newFreeTerm(str, i, flags, str): FreeTermSymbol)
+    locally(build.newFreeType(str): FreeTypeSymbol)
+    locally(build.newFreeType(str, flags, str): FreeTypeSymbol)
+    locally(build.setTypeSignature(sym, tpe): Symbol)
+    locally(build.setAnnotations(sym, anns): Symbol)
+    locally(build.flagsFromBits(??? : Long): FlagSet)
+    locally(build.emptyValDef: ValDef)
+    locally(build.This(sym): Tree)
+    locally(build.Select(tree, sym): Select)
+    locally(build.Ident(sym): Ident)
+    locally(build.TypeTree(tpe): TypeTree)
+    locally(build.thisPrefix(sym): Type)
+    locally(build.setType(tree, tpe): Tree)
+    locally(build.setSymbol(tree, sym): Tree)
+  }
+}
+\ No newline at end of file
diff --git a/test/files/pos/reflection-compat-macro-universe.check b/test/files/pos/reflection-compat-macro-universe.check
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/test/files/pos/reflection-compat-macro-universe.check
diff --git a/test/files/pos/reflection-compat-macro-universe.scala b/test/files/pos/reflection-compat-macro-universe.scala
new file mode 100644
index 0000000000..89ca36dab2
--- /dev/null
+++ b/test/files/pos/reflection-compat-macro-universe.scala
@@ -0,0 +1,177 @@
+object Test extends App {
+  val u: scala.reflect.macros.Universe = ???
+  import u._
+  import scala.reflect.macros.Attachments
+  import scala.reflect.ClassTag
+  import compat._
+
+  val tree: Tree = ???
+  val ttree: TypeTree = ???
+  val stree: SymTree = ???
+  val trees: List[Tree] = ???
+  val mods: Modifiers = ???
+  val impl: Template = ???
+  val vparamss: List[List[ValDef]] = ???
+  val rhs: Tree = ???
+  val sym: Symbol = ???
+  val tsym: TypeSymbol = ???
+  val syms: List[Symbol] = ???
+  val params: List[Symbol] = ???
+  val tparams: List[Symbol] = ???
+  val tpe: Type = ???
+  val tpes: List[Type] = ???
+  val manifest: Manifest[Int] = ???
+  val tag: TypeTag[Int] = ???
+  val mirror: Mirror = ???
+  val decls: Scope = ???
+  val pos: Position = ???
+  val ann: Annotation = ???
+  val anns: List[Annotation] = ???
+  val const: Constant = ???
+  val name: Name = ???
+  val tyname: TypeName = ???
+  val tename: TermName = ???
+  val flags: FlagSet = ???
+  val str: String = ???
+  val i: Int = ???
+  val b: Boolean = ???
+
+  // abstract class BuildApi
+  // abstract class ReferenceToBoxedExtractor
+  // abstract trait AttachableApi
+  // abstract trait FreeTermSymbolApi
+  // abstract trait FreeTypeSymbolApi
+  // abstract trait IdentContextApi
+  // abstract trait ReferenceToBoxedApi
+  // abstract trait SymTreeContextApi
+  // abstract trait SymbolContextApi
+  // abstract trait TreeContextApi
+  // abstract trait TypeTreeContextApi
+  locally(ClassDef(sym, impl): ClassDef)
+  locally(DefDef(sym, mods, vparamss, rhs): DefDef)
+  locally(DefDef(sym, vparamss, rhs): DefDef)
+  locally(DefDef(sym, mods, rhs): DefDef)
+  locally(DefDef(sym, rhs): DefDef)
+  locally(DefDef(sym, (??? : List[List[Symbol]] => Tree)): DefDef)
+  locally(LabelDef(sym, params, rhs): LabelDef)
+  locally(ModuleDef(sym, impl): ModuleDef)
+  locally(TypeDef(sym, rhs): TypeDef)
+  locally(TypeDef(sym): TypeDef)
+  locally(ValDef(sym, rhs): ValDef)
+  locally(ValDef(sym): ValDef)
+  locally(AnnotatedType(anns, tpe): AnnotatedType)
+  locally(BoundedWildcardType(??? : TypeBounds): BoundedWildcardType)
+  locally(TypeBounds(tpe, tpe): TypeBounds)
+  locally(MethodType(params, tpe): MethodType)
+  locally(RefinedType(tpes, decls): RefinedType)
+  locally(RefinedType(tpes, decls, sym): RefinedType)
+  locally(ClassInfoType(tpes, decls, sym): ClassInfoType)
+  locally(SingleType(tpe, sym): Type)
+  locally(TypeRef(tpe, sym, tpes): Type)
+  locally(ExistentialType(syms, tpe): ExistentialType)
+  locally(NullaryMethodType(tpe): NullaryMethodType)
+  locally(ThisType(sym): Type)
+  locally(SuperType(tpe, tpe): Type)
+  locally(PolyType(syms, tpe): PolyType)
+  locally(ConstantType(const): ConstantType)
+  locally(sym.asFreeTerm: FreeTermSymbol)
+  locally(sym.asFreeType: FreeTypeSymbol)
+  locally(sym.attachments: Attachments { type Pos = Position })
+  locally(tree.attachments: Attachments { type Pos = Position })
+  locally(captureVariable(sym): Unit)
+  locally(capturedVariableType(sym): Type)
+  locally(sym.deSkolemize: Symbol)
+  locally(tree.defineType(tpe): Tree)
+  locally(existentialAbstraction(tparams, tpe): Type)
+  locally(tree.freeTerms: List[FreeTermSymbol])
+  locally(tree.freeTypes: List[FreeTypeSymbol])
+  locally(intersectionType(tpes): Type)
+  locally(intersectionType(tpes, sym): Type)
+  locally(sym.isErroneous: Boolean)
+  locally(sym.isFreeTerm: Boolean)
+  locally(sym.isFreeType: Boolean)
+  locally(sym.isLocal: Boolean)
+  locally(sym.isOverride: Boolean)
+  locally(tsym.isSkolem: Boolean)
+  locally(manifestToTypeTag(mirror, manifest): scala.reflect.api.Universe#TypeTag[Int])
+  locally(treeBuild.mkAttributedIdent(sym): RefTree)
+  locally(treeBuild.mkAttributedQualifier(tpe): Tree)
+  locally(treeBuild.mkAttributedQualifier(tpe, sym): Tree)
+  locally(treeBuild.mkAttributedRef(tpe, sym): RefTree)
+  locally(treeBuild.mkAttributedRef(sym): RefTree)
+  locally(treeBuild.mkAttributedSelect(tree, sym): RefTree)
+  locally(treeBuild.mkAttributedThis(sym): This)
+  locally(mkImporter(scala.reflect.runtime.universe): Importer{val from: scala.reflect.runtime.universe.type})
+  locally(treeBuild.mkMethodCall(sym, trees): Tree)
+  locally(treeBuild.mkMethodCall(sym, tpes, trees): Tree)
+  locally(treeBuild.mkMethodCall(sym, name, trees): Tree)
+  locally(treeBuild.mkMethodCall(sym, name, tpes, trees): Tree)
+  locally(treeBuild.mkMethodCall(tree, sym, tpes, trees): Tree)
+  locally(treeBuild.mkMethodCall(tree, trees): Tree)
+  locally(treeBuild.mkMethodCall(tree, tpes, trees): Tree)
+  locally(treeBuild.mkNullaryCall(sym, tpes): Tree)
+  locally(treeBuild.mkRuntimeUniverseRef: Tree)
+  locally(treeBuild.mkUnattributedRef(name): RefTree)
+  locally(treeBuild.mkUnattributedRef(sym): RefTree)
+  locally(sym.newClassSymbol(tyname, pos, flags): ClassSymbol)
+  locally(sym.newMethodSymbol(tename, pos, flags): MethodSymbol)
+  locally(sym.newModuleAndClassSymbol(name, pos, flags): (ModuleSymbol, ClassSymbol))
+  locally(newScopeWith(sym, sym, sym): Scope)
+  locally(sym.newTermSymbol(tename, pos, flags): TermSymbol)
+  locally(sym.newTypeSymbol(tyname, pos, flags): TypeSymbol)
+  locally(polyType(tparams, tpe): Type)
+  locally(sym.pos: Position)
+  locally((tree.pos = pos): Unit)
+  locally(referenceCapturedVariable(sym): Tree)
+  locally(refinedType(tpes, sym): Type)
+  locally(refinedType(tpes, sym, decls, pos): Type)
+  locally(sym.removeAttachment[Int]: Symbol)
+  locally(tree.removeAttachment[Int]: Tree)
+  locally(sym.setAnnotations(ann, ann, ann): Symbol)
+  locally(sym.setName(name): Symbol)
+  locally(ttree.setOriginal(tree): TypeTree)
+  locally(tree.setPos(pos): Tree)
+  locally(sym.setPrivateWithin(sym): Symbol)
+  locally(tree.setSymbol(sym): Tree)
+  locally(tree.setType(tpe): Tree)
+  locally(sym.setTypeSignature(tpe): Symbol)
+  locally(singleType(tpe, sym): Type)
+  locally(tree.substituteSymbols(syms, syms): Tree)
+  locally(tree.substituteThis(sym, tree): Tree)
+  locally(tree.substituteTypes(syms, tpes): Tree)
+  locally((tree.symbol = sym): Unit)
+  locally((tree.tpe = tpe): Unit)
+  locally(typeRef(tpe, sym, tpes): Type)
+  locally(typeTagToManifest(mirror, tag): Manifest[Int])
+  locally(sym.updateAttachment(42): Symbol)
+  locally(tree.updateAttachment(42): Tree)
+  locally(FreeTermSymbolTag: ClassTag[FreeTermSymbol])
+  locally((??? : FreeTermSymbol).origin)
+  locally((??? : FreeTermSymbol).value)
+  locally(FreeTypeSymbolTag: ClassTag[FreeTypeSymbol])
+  locally((??? : FreeTypeSymbol).origin)
+  locally(ReferenceToBoxedTag: ClassTag[ReferenceToBoxed])
+  locally(build: BuildApi)
+  locally(ReferenceToBoxed(??? : Ident): ReferenceToBoxed)
+  locally((??? : ReferenceToBoxed).ident: Tree)
+  locally(ReferenceToBoxed.unapply(???): Option[Ident])
+  locally(build.selectType(sym, str): TypeSymbol)
+  locally(build.selectTerm(sym, str): TermSymbol)
+  locally(build.selectOverloadedMethod(sym, str, i): MethodSymbol)
+  locally(build.newNestedSymbol(sym, name, pos, flags, b): Symbol)
+  locally(build.newFreeTerm(str, i): FreeTermSymbol)
+  locally(build.newFreeTerm(str, i, flags, str): FreeTermSymbol)
+  locally(build.newFreeType(str): FreeTypeSymbol)
+  locally(build.newFreeType(str, flags, str): FreeTypeSymbol)
+  locally(build.setTypeSignature(sym, tpe): Symbol)
+  locally(build.setAnnotations(sym, anns): Symbol)
+  locally(build.flagsFromBits(??? : Long): FlagSet)
+  locally(build.emptyValDef: ValDef)
+  locally(build.This(sym): Tree)
+  locally(build.Select(tree, sym): Select)
+  locally(build.Ident(sym): Ident)
+  locally(build.TypeTree(tpe): TypeTree)
+  locally(build.thisPrefix(sym): Type)
+  locally(build.setType(tree, tpe): Tree)
+  locally(build.setSymbol(tree, sym): Tree)
+}
+\ No newline at end of file
diff --git a/test/files/pos/reflection-compat-ru.check b/test/files/pos/reflection-compat-ru.check
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/test/files/pos/reflection-compat-ru.check
diff --git a/test/files/pos/reflection-compat-ru.scala b/test/files/pos/reflection-compat-ru.scala
new file mode 100644
index 0000000000..9ff72d1cf0
--- /dev/null
+++ b/test/files/pos/reflection-compat-ru.scala
@@ -0,0 +1,135 @@
+object Test extends App {
+  import scala.reflect.runtime.universe._
+  import scala.reflect.ClassTag
+  import compat._
+
+  val tree: Tree = ???
+  val ttree: TypeTree = ???
+  val stree: SymTree = ???
+  val trees: List[Tree] = ???
+  val mods: Modifiers = ???
+  val impl: Template = ???
+  val vparamss: List[List[ValDef]] = ???
+  val rhs: Tree = ???
+  val sym: Symbol = ???
+  val tsym: TypeSymbol = ???
+  val syms: List[Symbol] = ???
+  val params: List[Symbol] = ???
+  val tparams: List[Symbol] = ???
+  val tpe: Type = ???
+  val tpes: List[Type] = ???
+  val manifest: Manifest[Int] = ???
+  val tag: TypeTag[Int] = ???
+  val mirror: Mirror = ???
+  val decls: Scope = ???
+  val pos: Position = ???
+  val ann: Annotation = ???
+  val anns: List[Annotation] = ???
+  val const: Constant = ???
+  val name: Name = ???
+  val tyname: TypeName = ???
+  val tename: TermName = ???
+  val flags: FlagSet = ???
+  val str: String = ???
+  val i: Int = ???
+  val b: Boolean = ???
+
+  // abstract class BuildApi
+  // abstract class ReferenceToBoxedExtractor
+  // abstract trait AttachableApi
+  // abstract trait FreeTermSymbolApi
+  // abstract trait FreeTypeSymbolApi
+  // abstract trait IdentContextApi
+  // abstract trait ReferenceToBoxedApi
+  // abstract trait SymTreeContextApi
+  // abstract trait SymbolContextApi
+  // abstract trait TreeContextApi
+  // abstract trait TypeTreeContextApi
+  locally(ClassDef(sym, impl): ClassDef)
+  locally(DefDef(sym, mods, vparamss, rhs): DefDef)
+  locally(DefDef(sym, vparamss, rhs): DefDef)
+  locally(DefDef(sym, mods, rhs): DefDef)
+  locally(DefDef(sym, rhs): DefDef)
+  locally(DefDef(sym, (??? : List[List[Symbol]] => Tree)): DefDef)
+  locally(LabelDef(sym, params, rhs): LabelDef)
+  locally(ModuleDef(sym, impl): ModuleDef)
+  locally(TypeDef(sym, rhs): TypeDef)
+  locally(TypeDef(sym): TypeDef)
+  locally(ValDef(sym, rhs): ValDef)
+  locally(ValDef(sym): ValDef)
+  locally(AnnotatedType(anns, tpe): AnnotatedType)
+  locally(BoundedWildcardType(??? : TypeBounds): BoundedWildcardType)
+  locally(TypeBounds(tpe, tpe): TypeBounds)
+  locally(MethodType(params, tpe): MethodType)
+  locally(RefinedType(tpes, decls): RefinedType)
+  locally(RefinedType(tpes, decls, sym): RefinedType)
+  locally(ClassInfoType(tpes, decls, sym): ClassInfoType)
+  locally(SingleType(tpe, sym): Type)
+  locally(TypeRef(tpe, sym, tpes): Type)
+  locally(ExistentialType(syms, tpe): ExistentialType)
+  locally(NullaryMethodType(tpe): NullaryMethodType)
+  locally(ThisType(sym): Type)
+  locally(SuperType(tpe, tpe): Type)
+  locally(PolyType(syms, tpe): PolyType)
+  locally(ConstantType(const): ConstantType)
+  locally(sym.asFreeTerm: FreeTermSymbol)
+  locally(sym.asFreeType: FreeTypeSymbol)
+  locally(existentialAbstraction(tparams, tpe): Type)
+  locally(tree.freeTerms: List[FreeTermSymbol])
+  locally(tree.freeTypes: List[FreeTypeSymbol])
+  locally(intersectionType(tpes): Type)
+  locally(intersectionType(tpes, sym): Type)
+  locally(sym.isErroneous: Boolean)
+  locally(sym.isFreeTerm: Boolean)
+  locally(sym.isFreeType: Boolean)
+  locally(sym.isLocal: Boolean)
+  locally(sym.isOverride: Boolean)
+  locally(tsym.isSkolem: Boolean)
+  locally(manifestToTypeTag(mirror, manifest): scala.reflect.api.Universe#TypeTag[Int])
+  locally(mkImporter(scala.reflect.runtime.universe): Importer{val from: scala.reflect.runtime.universe.type})
+  locally(sym.newClassSymbol(tyname, pos, flags): ClassSymbol)
+  locally(sym.newMethodSymbol(tename, pos, flags): MethodSymbol)
+  locally(sym.newModuleAndClassSymbol(name, pos, flags): (ModuleSymbol, ClassSymbol))
+  locally(newScopeWith(sym, sym, sym): Scope)
+  locally(sym.newTermSymbol(tename, pos, flags): TermSymbol)
+  locally(sym.newTypeSymbol(tyname, pos, flags): TypeSymbol)
+  locally(polyType(tparams, tpe): Type)
+  locally(sym.pos: Position)
+  locally(refinedType(tpes, sym): Type)
+  locally(refinedType(tpes, sym, decls, pos): Type)
+  locally(singleType(tpe, sym): Type)
+  locally(tree.substituteSymbols(syms, syms): Tree)
+  locally(tree.substituteThis(sym, tree): Tree)
+  locally(tree.substituteTypes(syms, tpes): Tree)
+  locally(typeRef(tpe, sym, tpes): Type)
+  locally(typeTagToManifest(mirror, tag): Manifest[Int])
+  locally(FreeTermSymbolTag: ClassTag[FreeTermSymbol])
+  locally((??? : FreeTermSymbol).origin)
+  locally((??? : FreeTermSymbol).value)
+  locally(FreeTypeSymbolTag: ClassTag[FreeTypeSymbol])
+  locally((??? : FreeTypeSymbol).origin)
+  locally(ReferenceToBoxedTag: ClassTag[ReferenceToBoxed])
+  locally(build: BuildApi)
+  locally(ReferenceToBoxed(??? : Ident): ReferenceToBoxed)
+  locally((??? : ReferenceToBoxed).ident: Tree)
+  locally(ReferenceToBoxed.unapply(???): Option[Ident])
+  locally(build.selectType(sym, str): TypeSymbol)
+  locally(build.selectTerm(sym, str): TermSymbol)
+  locally(build.selectOverloadedMethod(sym, str, i): MethodSymbol)
+  locally(build.newNestedSymbol(sym, name, pos, flags, b): Symbol)
+  locally(build.newFreeTerm(str, i): FreeTermSymbol)
+  locally(build.newFreeTerm(str, i, flags, str): FreeTermSymbol)
+  locally(build.newFreeType(str): FreeTypeSymbol)
+  locally(build.newFreeType(str, flags, str): FreeTypeSymbol)
+  locally(build.setTypeSignature(sym, tpe): Symbol)
+  locally(build.setAnnotations(sym, anns): Symbol)
+  locally(build.flagsFromBits(??? : Long): FlagSet)
+  locally(build.emptyValDef: ValDef)
+  locally(build.This(sym): Tree)
+  locally(build.Select(tree, sym): Select)
+  locally(build.Ident(sym): Ident)
+  locally(build.TypeTree(tpe): TypeTree)
+  locally(build.thisPrefix(sym): Type)
+  locally(build.setType(tree, tpe): Tree)
+  locally(build.setSymbol(tree, sym): Tree)
+}
+\ No newline at end of file
diff --git a/test/files/pos/t1957.scala b/test/files/pos/t1957.scala
index f80cf730ed..711ce17deb 100644
--- a/test/files/pos/t1957.scala
+++ b/test/files/pos/t1957.scala
@@ -23,7 +23,7 @@ object Test {
         final type commonModuleType = Module {type settingsType = self.settingsType}
         type selfType >: self.type <: commonModuleType
 
-        // BTW: if we use the commented out type declarations, the code compiles successfully
+        // BTW: if we use the commented out type decls, the code compiles successfully
         // type gristType = Grist {type settingsType <: self.settingsType; type moduleType <: commonModuleType }
 
         val tools: List[Tool {type settingsType = self.settingsType}]
diff --git a/test/files/pos/t8013/inpervolator_1.scala b/test/files/pos/t8013/inpervolator_1.scala
index 89b7c22709..612e1d727d 100644
--- a/test/files/pos/t8013/inpervolator_1.scala
+++ b/test/files/pos/t8013/inpervolator_1.scala
@@ -18,7 +18,7 @@ object Perverse {
   def pImpl(c: Context)(args: c.Expr[Any]*): c.Expr[String] = {
     import c.universe._
     val macroPos = c.macroApplication.pos
-    val text = macroPos.lineContent substring macroPos.column
+    val text = macroPos.source.lineToString(macroPos.line - 1) substring macroPos.column
     val tt = Literal(Constant(text))
     val tree = q"t8013.Perverse.pervert($tt)"
     c.Expr[String](tree)
diff --git a/test/files/pos/t8187.check b/test/files/pos/t8187.check
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/test/files/pos/t8187.check
diff --git a/test/files/pos/t8187.scala b/test/files/pos/t8187.scala
new file mode 100644
index 0000000000..99b10c6260
--- /dev/null
+++ b/test/files/pos/t8187.scala
@@ -0,0 +1,6 @@
+import scala.reflect.runtime.universe._
+
+object Test extends App {
+  val tyn: TypeName = (??? : TypeSymbol).name
+  val ten: TermName = (??? : TermSymbol).name
+}
+\ No newline at end of file
diff --git a/test/files/pos/t8300-conversions-a.scala b/test/files/pos/t8300-conversions-a.scala
new file mode 100644
index 0000000000..248a8b73b2
--- /dev/null
+++ b/test/files/pos/t8300-conversions-a.scala
@@ -0,0 +1,23 @@
+// cf. pos/t8300-conversions-b.scala
+trait Universe {
+  type Symbol >: Null <: AnyRef with SymbolApi
+  trait SymbolApi
+
+  type TypeSymbol >: Null <: Symbol with TypeSymbolApi
+  trait TypeSymbolApi extends SymbolApi
+
+  type FreeTypeSymbol >: Null <: TypeSymbol with FreeTypeSymbolApi
+  trait FreeTypeSymbolApi extends TypeSymbolApi
+
+  implicit class CompatibleSymbol(sym: Symbol) {
+    def asFreeType: FreeTypeSymbol = ???
+  }
+}
+
+object Test extends App {
+  val u: Universe = ???
+  import u._
+
+  val sym: Symbol = ???
+  sym.asFreeType
+}
+\ No newline at end of file
diff --git a/test/files/pos/t8300-conversions-b.scala b/test/files/pos/t8300-conversions-b.scala
new file mode 100644
index 0000000000..0524ee3683
--- /dev/null
+++ b/test/files/pos/t8300-conversions-b.scala
@@ -0,0 +1,23 @@
+// cf. pos/t8300-conversions-a.scala
+trait Universe {
+  type Symbol >: Null <: AnyRef with SymbolApi
+  trait SymbolApi
+
+  type TypeSymbol >: Null <: TypeSymbolApi with Symbol
+  trait TypeSymbolApi extends SymbolApi
+
+  type FreeTypeSymbol >: Null <: FreeTypeSymbolApi with TypeSymbol
+  trait FreeTypeSymbolApi extends TypeSymbolApi
+
+  implicit class CompatibleSymbol(sym: Symbol) {
+    def asFreeType: FreeTypeSymbol = ???
+  }
+}
+
+object Test extends App {
+  val u: Universe = ???
+  import u._
+
+  val sym: Symbol = ???
+  sym.asFreeType
+}
+\ No newline at end of file
diff --git a/test/files/pos/t8300-overloading.scala b/test/files/pos/t8300-overloading.scala
new file mode 100644
index 0000000000..ae9699ab86
--- /dev/null
+++ b/test/files/pos/t8300-overloading.scala
@@ -0,0 +1,16 @@
+// cf. neg/t8300-overloading.scala
+trait Universe {
+  type Name >: Null <: AnyRef with NameApi
+  trait NameApi
+
+  type TermName >: Null <: TermNameApi with Name
+  trait TermNameApi extends NameApi
+}
+
+object Test extends App {
+  val u: Universe = ???
+  import u._
+
+  def foo(name: Name) = ???
+  def foo(name: TermName) = ???
+}
+\ No newline at end of file
diff --git a/test/files/pos/t8300-patmat-a.scala b/test/files/pos/t8300-patmat-a.scala
new file mode 100644
index 0000000000..4421c0a15e
--- /dev/null
+++ b/test/files/pos/t8300-patmat-a.scala
@@ -0,0 +1,20 @@
+// cf. pos/t8300-patmat-b.scala
+trait Universe {
+  type Name >: Null <: AnyRef with NameApi
+  trait NameApi
+
+  type TermName >: Null <: Name with TermNameApi
+  trait TermNameApi extends NameApi
+}
+
+object Test extends App {
+  val u: Universe = ???
+  import u._
+
+  locally {
+    val ScalaName: TermName = ???
+    ??? match {
+      case ScalaName => ???
+    }
+  }
+}
+\ No newline at end of file
diff --git a/test/files/pos/t8300-patmat-b.scala b/test/files/pos/t8300-patmat-b.scala
new file mode 100644
index 0000000000..c01aeb912d
--- /dev/null
+++ b/test/files/pos/t8300-patmat-b.scala
@@ -0,0 +1,20 @@
+// cf. pos/t8300-patmat-a.scala
+trait Universe {
+  type Name >: Null <: AnyRef with NameApi
+  trait NameApi
+
+  type TermName >: Null <: TermNameApi with Name
+  trait TermNameApi extends NameApi
+}
+
+object Test extends App {
+  val u: Universe = ???
+  import u._
+
+  locally {
+    val ScalaName: TermName = ???
+    ??? match {
+      case ScalaName => ???
+    }
+  }
+}
+\ No newline at end of file
diff --git a/test/files/run/all-overridden.scala b/test/files/run/all-overridden.scala
index 1b798ef748..ff51fa19bf 100644
--- a/test/files/run/all-overridden.scala
+++ b/test/files/run/all-overridden.scala
@@ -6,6 +6,6 @@ object Test {
 
   def main(args: Array[String]): Unit = {
     // We should see g, but not f or $init$.
-    typeOf[Bar].declarations.toList.flatMap(_.allOverriddenSymbols) foreach println
+    typeOf[Bar].decls.toList.flatMap(_.overrides) foreach println
   }
 }
diff --git a/test/files/run/compiler-asSeenFrom.scala b/test/files/run/compiler-asSeenFrom.scala
index 7020469bb2..ea96c6fba7 100644
--- a/test/files/run/compiler-asSeenFrom.scala
+++ b/test/files/run/compiler-asSeenFrom.scala
@@ -2,9 +2,55 @@
  * filter: inliner warning\(s\); re-run with -Yinline-warnings for details
  */
 import scala.tools.nsc._
-import scala.tools.partest.CompilerTest
+import scala.tools.partest.DirectTest
 import scala.collection.{ mutable, immutable, generic }
-import scala.language.postfixOps
+import scala.language.{postfixOps, implicitConversions}
+import scala.reflect.runtime.{universe => ru}
+
+// necessary to avoid bincompat with scala-partest compiled against the old compiler
+abstract class CompilerTest extends DirectTest {
+  def check(source: String, unit: global.CompilationUnit): Unit
+
+  lazy val global: Global = newCompiler()
+  lazy val units: List[global.CompilationUnit] = compilationUnits(global)(sources: _ *)
+  import global._
+  import definitions.{ compilerTypeFromTag }
+
+  override def extraSettings = "-feature -usejavacp -d " + testOutput.path
+
+  def show() = (sources, units).zipped foreach check
+
+  // Override at least one of these...
+  def code = ""
+  def sources: List[String] = List(code)
+
+  // Utility functions
+  class MkType(sym: Symbol) {
+    def apply[M](implicit t: ru.TypeTag[M]): Type =
+      if (sym eq NoSymbol) NoType
+      else appliedType(sym, compilerTypeFromTag(t))
+  }
+  implicit def mkMkType(sym: Symbol) = new MkType(sym)
+
+  def allMembers(root: Symbol): List[Symbol] = {
+    def loop(seen: Set[Symbol], roots: List[Symbol]): List[Symbol] = {
+      val latest = roots flatMap (_.info.members) filterNot (seen contains _)
+      if (latest.isEmpty) seen.toList.sortWith(_ isLess _)
+      else loop(seen ++ latest, latest)
+    }
+    loop(Set(), List(root))
+  }
+
+  class SymsInPackage(pkgName: String) {
+    def pkg     = rootMirror.getPackage(TermName(pkgName))
+    def classes = allMembers(pkg) filter (_.isClass)
+    def modules = allMembers(pkg) filter (_.isModule)
+    def symbols = classes ++ terms filterNot (_ eq NoSymbol)
+    def terms   = allMembers(pkg) filter (s => s.isTerm && !s.isConstructor)
+    def tparams = classes flatMap (_.info.typeParams)
+    def tpes    = symbols map (_.tpe) distinct
+  }
+}
 
 /** It's too messy but it's better than not having it.
  */
diff --git a/test/files/run/existentials-in-compiler.scala b/test/files/run/existentials-in-compiler.scala
index f5a0aa98d0..d019d56b42 100644
--- a/test/files/run/existentials-in-compiler.scala
+++ b/test/files/run/existentials-in-compiler.scala
@@ -75,7 +75,7 @@ package extest {
   """
 
   override def check(source: String, unit: global.CompilationUnit) {
-    getPackage("extest").moduleClass.info.decls.toList.filter(_.isType).map(_.initialize).sortBy(_.name.toString) foreach { clazz =>
+    getPackage(TermName("extest")).moduleClass.info.decls.toList.filter(_.isType).map(_.initialize).sortBy(_.name.toString) foreach { clazz =>
       exitingTyper {
         clazz.info
         println(clazz.defString)
diff --git a/test/files/run/existentials3-new.scala b/test/files/run/existentials3-new.scala
index 6112a7b856..5dfd7fb394 100644
--- a/test/files/run/existentials3-new.scala
+++ b/test/files/run/existentials3-new.scala
@@ -1,5 +1,6 @@
 import scala.language.existentials
 import scala.reflect.runtime.universe._
+import internal._
 
 object Test {
   trait ToS { final override def toString = getClass.getName }
@@ -35,7 +36,7 @@ object Test {
   val g12 = { abstract class A extends Seq[U forSome { type U <: Int }] ; List[A]() }
 
   def printTpe(t: Type) = {
-    val s = if (t.typeSymbol.isFreeType) t.typeSymbol.typeSignature.toString else t.typeSymbol.toString
+    val s = if (isFreeType(t.typeSymbol)) t.typeSymbol.info.toString else t.typeSymbol.toString
     println("%s, t=%s, s=%s".format(t, t.asInstanceOf[Product].productPrefix, s))
   }
   def m[T: TypeTag](x: T) = printTpe(typeOf[T])
diff --git a/test/files/run/fail-non-value-types.scala b/test/files/run/fail-non-value-types.scala
index 51198a5f31..d9a69e17c2 100644
--- a/test/files/run/fail-non-value-types.scala
+++ b/test/files/run/fail-non-value-types.scala
@@ -18,8 +18,8 @@ object Test {
   def tcon[T: TypeTag](args: Type*) = appliedType(typeOf[T].typeConstructor, args.toList)
 
   def cil      = typeOf[CompletelyIndependentList[Int]]
-  def map      = cil.member("map": TermName).asMethod
-  def distinct = cil.member("distinct": TermName).asMethod
+  def map      = cil.member(TermName("map")).asMethod
+  def distinct = cil.member(TermName("distinct")).asMethod
 
   def main(args: Array[String]): Unit = {
     // Need the assert in there to fail.
@@ -32,9 +32,9 @@ object Test {
     // [B <: <?>, That <: <?>](f: <?>)(implicit cbf: <?>)That
     //
 
-    println(map.typeSignature)
-    println(map.typeSignatureIn(cil))
-    println(distinct.typeSignature)
+    println(map.info)
+    println(map.infoIn(cil))
+    println(distinct.info)
     if (failed) sys.exit(1)
   }
 }
diff --git a/test/files/run/freetypes_false_alarm2.scala b/test/files/run/freetypes_false_alarm2.scala
index 3499f13fba..a517f7396b 100644
--- a/test/files/run/freetypes_false_alarm2.scala
+++ b/test/files/run/freetypes_false_alarm2.scala
@@ -1,8 +1,9 @@
 import scala.reflect.runtime.universe._
 import scala.reflect.runtime.{universe => ru}
 import scala.tools.reflect.Eval
+import internal._
 
 object Test extends App {
   val tpe = typeOf[ru.Type]
-  println(tpe.typeSymbol.isFreeType)
+  println(isFreeType(tpe.typeSymbol))
 }
 \ No newline at end of file
diff --git a/test/files/run/interop_typetags_are_manifests.scala b/test/files/run/interop_typetags_are_manifests.scala
index 1aca7f52cc..6dc5437819 100644
--- a/test/files/run/interop_typetags_are_manifests.scala
+++ b/test/files/run/interop_typetags_are_manifests.scala
@@ -1,5 +1,6 @@
 import scala.reflect.runtime.universe._
 import scala.reflect.ClassTag
+import internal._
 
 object Test extends App {
   def typeTagIsManifest[T: TypeTag : ClassTag] = {
diff --git a/test/files/run/macro-divergence-spurious/Impls_Macros_1.scala b/test/files/run/macro-divergence-spurious/Impls_Macros_1.scala
index 85d0f0bb7e..7ac8fccc3a 100644
--- a/test/files/run/macro-divergence-spurious/Impls_Macros_1.scala
+++ b/test/files/run/macro-divergence-spurious/Impls_Macros_1.scala
@@ -10,8 +10,8 @@ object Complex {
   def impl[T: c.WeakTypeTag](c: Context): c.Expr[Complex[T]] = {
     import c.universe._
     val tpe = weakTypeOf[T]
-    for (f <- tpe.declarations.collect{case f: TermSymbol if f.isParamAccessor && !f.isMethod => f}) {
-      val trecur = appliedType(typeOf[Complex[_]], List(f.typeSignature))
+    for (f <- tpe.decls.collect{case f: TermSymbol if f.isParamAccessor && !f.isMethod => f}) {
+      val trecur = appliedType(typeOf[Complex[_]], List(f.info))
       val recur = c.inferImplicitValue(trecur, silent = true)
       if (recur == EmptyTree) c.abort(c.enclosingPosition, s"couldn't synthesize $trecur")
     }
diff --git a/test/files/run/macro-enclosingowner-detectvar.check b/test/files/run/macro-enclosingowner-detectvar.check
new file mode 100644
index 0000000000..c8f86ec735
--- /dev/null
+++ b/test/files/run/macro-enclosingowner-detectvar.check
@@ -0,0 +1,16 @@
+(true,false,false,false)
+(true,false,false,false)
+(true,false,false,false)
+(true,false,false,false)
+(false,true,false,false)
+(false,true,false,false)
+(false,true,false,false)
+(false,true,false,false)
+(false,false,true,false)
+(false,false,true,false)
+(false,false,true,false)
+(false,false,true,false)
+(false,false,false,true)
+(false,false,false,true)
+(false,false,false,true)
+(false,false,false,true)
diff --git a/test/files/run/macro-enclosingowner-detectvar/Macros_1.scala b/test/files/run/macro-enclosingowner-detectvar/Macros_1.scala
new file mode 100644
index 0000000000..26ed64d8c3
--- /dev/null
+++ b/test/files/run/macro-enclosingowner-detectvar/Macros_1.scala
@@ -0,0 +1,14 @@
+import scala.reflect.macros.whitebox._
+import scala.language.experimental.macros
+
+object Macros {
+  def impl(c: Context) = {
+    import c.universe._
+    def detectFlags(sym: TermSymbol): String = {
+      (sym.isVal, sym.isVar, !sym.isVal && !sym.isVar && !sym.isLazy, sym.isLazy).toString
+    }
+    q"println(${detectFlags(c.internal.enclosingOwner.asTerm)}); 42"
+  }
+
+  def foo: Int = macro impl
+}
+\ No newline at end of file
diff --git a/test/files/run/macro-enclosingowner-detectvar/Test_2.scala b/test/files/run/macro-enclosingowner-detectvar/Test_2.scala
new file mode 100644
index 0000000000..58521d9429
--- /dev/null
+++ b/test/files/run/macro-enclosingowner-detectvar/Test_2.scala
@@ -0,0 +1,23 @@
+object Test extends App {
+  val a1 = Macros.foo
+  val a2 = Predef.identity(Predef.identity(Macros.foo))
+  val a3: Int = Macros.foo
+  val a4: Int = Predef.identity(Predef.identity(Macros.foo))
+
+  var b1 = Macros.foo
+  var b2 = Predef.identity(Predef.identity(Macros.foo))
+  var b3: Int = Macros.foo
+  var b4: Int = Predef.identity(Predef.identity(Macros.foo))
+
+  def c1 = Macros.foo
+  def c2 = Predef.identity(Predef.identity(Macros.foo))
+  def c3: Int = Macros.foo
+  def c4: Int = Predef.identity(Predef.identity(Macros.foo))
+  c1; c2; c3; c4;
+
+  lazy val d1 = Macros.foo
+  lazy val d2 = Predef.identity(Predef.identity(Macros.foo))
+  lazy val d3: Int = Macros.foo
+  lazy val d4: Int = Predef.identity(Predef.identity(Macros.foo))
+  d1; d2; d3; d4
+}
+\ No newline at end of file
diff --git a/test/files/run/macro-enclosingowner-sbt.check b/test/files/run/macro-enclosingowner-sbt.check
new file mode 100644
index 0000000000..3c95698e9a
--- /dev/null
+++ b/test/files/run/macro-enclosingowner-sbt.check
@@ -0,0 +1,16 @@
+a1
+a2
+a3
+a4
+b1
+b2
+b3
+b4
+c1
+c2
+c3
+c4
+d1
+d2
+d3
+d4
diff --git a/test/files/run/macro-enclosingowner-sbt/Macros_1.scala b/test/files/run/macro-enclosingowner-sbt/Macros_1.scala
new file mode 100644
index 0000000000..a98a984861
--- /dev/null
+++ b/test/files/run/macro-enclosingowner-sbt/Macros_1.scala
@@ -0,0 +1,14 @@
+import scala.reflect.macros.whitebox._
+import scala.language.experimental.macros
+
+object Macros {
+  def impl(c: Context) = {
+    import c.universe._
+    def enclosingName(sym: Symbol): String = {
+      sym.name.toString.stripSuffix(termNames.LOCAL_SUFFIX_STRING)
+    }
+    q"println(${enclosingName(c.internal.enclosingOwner).toString}); 42"
+  }
+
+  def foo: Int = macro impl
+}
+\ No newline at end of file
diff --git a/test/files/run/macro-enclosingowner-sbt/Test_2.scala b/test/files/run/macro-enclosingowner-sbt/Test_2.scala
new file mode 100644
index 0000000000..58521d9429
--- /dev/null
+++ b/test/files/run/macro-enclosingowner-sbt/Test_2.scala
@@ -0,0 +1,23 @@
+object Test extends App {
+  val a1 = Macros.foo
+  val a2 = Predef.identity(Predef.identity(Macros.foo))
+  val a3: Int = Macros.foo
+  val a4: Int = Predef.identity(Predef.identity(Macros.foo))
+
+  var b1 = Macros.foo
+  var b2 = Predef.identity(Predef.identity(Macros.foo))
+  var b3: Int = Macros.foo
+  var b4: Int = Predef.identity(Predef.identity(Macros.foo))
+
+  def c1 = Macros.foo
+  def c2 = Predef.identity(Predef.identity(Macros.foo))
+  def c3: Int = Macros.foo
+  def c4: Int = Predef.identity(Predef.identity(Macros.foo))
+  c1; c2; c3; c4;
+
+  lazy val d1 = Macros.foo
+  lazy val d2 = Predef.identity(Predef.identity(Macros.foo))
+  lazy val d3: Int = Macros.foo
+  lazy val d4: Int = Predef.identity(Predef.identity(Macros.foo))
+  d1; d2; d3; d4
+}
+\ No newline at end of file
diff --git a/test/files/run/macro-enclosures.check b/test/files/run/macro-enclosures.check
index 36bb67e194..b6fe7a4a91 100644
--- a/test/files/run/macro-enclosures.check
+++ b/test/files/run/macro-enclosures.check
@@ -30,3 +30,5 @@ enclosingTemplate = scala.AnyRef {
 }
 enclosingMethod = def test = Macros.foo
 enclosingDef = def test = Macros.foo
+enclosingOwner = method test
+enclosingOwnerChain = List(method test, object Test, package test, package <root>)
diff --git a/test/files/run/macro-enclosures/Impls_Macros_1.scala b/test/files/run/macro-enclosures/Impls_Macros_1.scala
index 5b04cf29e9..564cdfa68f 100644
--- a/test/files/run/macro-enclosures/Impls_Macros_1.scala
+++ b/test/files/run/macro-enclosures/Impls_Macros_1.scala
@@ -3,15 +3,21 @@ import scala.reflect.macros.blackbox.Context
 object Macros {
   def impl(c: Context) = {
     import c.universe._
-    reify {
-      println("enclosingPackage = " + c.Expr[String](Literal(Constant(c.enclosingPackage.toString))).splice)
-      println("enclosingClass = " + c.Expr[String](Literal(Constant(c.enclosingClass.toString))).splice)
-      println("enclosingImpl = " + c.Expr[String](Literal(Constant(c.enclosingImpl.toString))).splice)
-      println("enclosingTemplate = " + c.Expr[String](Literal(Constant(c.enclosingTemplate.toString))).splice)
-      println("enclosingMethod = " + c.Expr[String](Literal(Constant(c.enclosingMethod.toString))).splice)
-      println("enclosingDef = " + c.Expr[String](Literal(Constant(c.enclosingDef.toString))).splice)
+    def chain(sym: Symbol): List[Symbol] = sym.owner match {
+      case NoSymbol => sym :: Nil
+      case owner => sym :: chain(owner)
     }
+    q"""
+      println("enclosingPackage = " + ${c.enclosingPackage.toString})
+      println("enclosingClass = " + ${c.enclosingClass.toString})
+      println("enclosingImpl = " + ${c.enclosingImpl.toString})
+      println("enclosingTemplate = " + ${c.enclosingTemplate.toString})
+      println("enclosingMethod = " + ${c.enclosingMethod.toString})
+      println("enclosingDef = " + ${c.enclosingDef.toString})
+      println("enclosingOwner = " + ${c.internal.enclosingOwner.toString})
+      println("enclosingOwnerChain = " + ${chain(c.internal.enclosingOwner).toString})
+    """
   }
 
-  def foo = macro impl
+  def foo: Any = macro impl
 }
 \ 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 6d79b13419..64aaa07bf2 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(TermName("Macros")), TermName("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(typeNames.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 4bdc5bec00..eb067c25a5 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
@@ -4,7 +4,7 @@ object Impls {
   def foo(c: Context)(xs: c.Expr[Int]*) = {
     import c.universe._
     val stripped_xs = xs map (_.tree) toList match {
-      case List(Typed(stripped, Ident(wildstar))) if wildstar == tpnme.WILDCARD_STAR => List(stripped)
+      case List(Typed(stripped, Ident(wildstar))) if wildstar == typeNames.WILDCARD_STAR => List(stripped)
       case _ => ???
     }
     val body = Apply(Select(Ident(definitions.PredefModule), TermName("println")), stripped_xs)
diff --git a/test/files/run/macro-range/Common_1.scala b/test/files/run/macro-range/Common_1.scala
index 0e66815f15..35d2efd76d 100644
--- a/test/files/run/macro-range/Common_1.scala
+++ b/test/files/run/macro-range/Common_1.scala
@@ -12,6 +12,7 @@ abstract class RangeDefault {
 abstract class Utils {
   val context: Context
   import context.universe._
+  import internal._
 
   class TreeSubstituter(from: List[Symbol], to: List[Tree]) extends Transformer {
     override def transform(tree: Tree): Tree = tree match {
@@ -23,7 +24,7 @@ abstract class Utils {
         subst(from, to)
       case _ =>
         val tree1 = super.transform(tree)
-        if (tree1 ne tree) tree1.tpe = null
+        if (tree1 ne tree) setType(tree1, null)
         tree1
     }
   }
diff --git a/test/files/run/macro-range/Expansion_Impossible_2.scala b/test/files/run/macro-range/Expansion_Impossible_2.scala
index 514de6864a..242e83a61a 100644
--- a/test/files/run/macro-range/Expansion_Impossible_2.scala
+++ b/test/files/run/macro-range/Expansion_Impossible_2.scala
@@ -9,7 +9,7 @@ object Impls {
     import c.universe._
     import Flag._
 
-    val initName = nme.CONSTRUCTOR
+    val initName = termNames.CONSTRUCTOR
     // Either:
     //   scala"{ var i = $low; val h = $hi; while (i < h) { $f(i); i = i + 1 } }
     // or:
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 ba12fb05e6..410ec1b527 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
@@ -11,7 +11,7 @@ object Test extends App {
   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)), Ident(TypeName("Int")), 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 modulector = DefDef(NoMods, termNames.CONSTRUCTOR, Nil, List(List()), TypeTree(), Block(List(Apply(Select(Super(This(typeNames.EMPTY), typeNames.EMPTY), termNames.CONSTRUCTOR), List())), Literal(Constant(()))))
   val module = ModuleDef(NoMods, TermName("Macros"), Template(Nil, noSelfType, List(modulector, macrodef)))
   val macroapp = Apply(Select(Ident(TermName("Macros")), TermName("foo")), List(Literal(Constant(42))))
   val tree = Block(List(macrodef, module), macroapp)
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 8d2aa1e70a..3bea04cead 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
@@ -23,10 +23,10 @@ case class Utils[C <: Context]( c:C ) {
 object QueryableMacros{
   def _helper[C <: Context,S:c.WeakTypeTag]( c:C )( name:String, projection:c.Expr[_] ) = {
     import c.universe._
-    import treeBuild._
+    import internal._
     val element_type = implicitly[c.WeakTypeTag[S]].tpe
     val foo = c.Expr[ru.Expr[Queryable[S]]](
-    c.reifyTree( mkRuntimeUniverseRef, EmptyTree, c.typecheck(
+    c.reifyTree( gen.mkRuntimeUniverseRef, EmptyTree, c.typecheck(
       Utils[c.type](c).removeDoubleReify(
         Apply(Select(c.prefix.tree, TermName( name )), List( projection.tree ))
        ).asInstanceOf[Tree]
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 8d2aa1e70a..3bea04cead 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
@@ -23,10 +23,10 @@ case class Utils[C <: Context]( c:C ) {
 object QueryableMacros{
   def _helper[C <: Context,S:c.WeakTypeTag]( c:C )( name:String, projection:c.Expr[_] ) = {
     import c.universe._
-    import treeBuild._
+    import internal._
     val element_type = implicitly[c.WeakTypeTag[S]].tpe
     val foo = c.Expr[ru.Expr[Queryable[S]]](
-    c.reifyTree( mkRuntimeUniverseRef, EmptyTree, c.typecheck(
+    c.reifyTree( gen.mkRuntimeUniverseRef, EmptyTree, c.typecheck(
       Utils[c.type](c).removeDoubleReify(
         Apply(Select(c.prefix.tree, TermName( name )), List( projection.tree ))
        ).asInstanceOf[Tree]
diff --git a/test/files/run/macro-reify-type/Macros_1.scala b/test/files/run/macro-reify-type/Macros_1.scala
index bac1744c50..c38cf8aa52 100644
--- a/test/files/run/macro-reify-type/Macros_1.scala
+++ b/test/files/run/macro-reify-type/Macros_1.scala
@@ -6,6 +6,7 @@ object StaticReflect {
 
   def methodImpl[A: c.WeakTypeTag](c: Context)(name: c.Expr[String]): c.Expr[ru.Type] = {
     import c.universe._
+    import internal._
 
     val nameName: TermName = name.tree match {
       case Literal(Constant(str: String)) => TermName(str)
@@ -16,8 +17,8 @@ object StaticReflect {
     clazz member nameName match {
       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, TermName("rootMirror")), mtpe)
+        val mtpe  = member infoIn clazz
+        val mtag  = c.reifyType(gen.mkRuntimeUniverseRef, Select(gen.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 1f35973531..8ec60e9f61 100644
--- a/test/files/run/macro-reify-type/Test_2.scala
+++ b/test/files/run/macro-reify-type/Test_2.scala
@@ -5,16 +5,16 @@ object Test extends App {
   println(method[List[Int]]("map"))
   //val $u: scala.reflect.runtime.universe.type = scala.reflect.runtime.universe;
   //val $m: $u.Mirror = scala.reflect.runtime.universe.rootMirror;
-  //import $u._, $m._, Flag._
+  //import $u._, $m._, Flag._, internal._
   //val tpe = {
-  //  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()))));
-  //  build.setTypeSignature(symdef$bf2, TypeRef(ThisType(staticPackage("scala.collection.generic").asModule.moduleClass), staticClass("scala.collection.generic.CanBuildFrom"), List(TypeRef(ThisType(staticPackage("scala.collection.immutable").asModule.moduleClass), staticClass("scala.collection.immutable.List"), List(staticClass("scala.Int").asType.toTypeConstructor)), TypeRef(NoPrefix, symdef$B2, List()), TypeRef(NoPrefix, symdef$That2, List()))));
+  //  val symdef$B2 = reificationSupport.newNestedSymbol(reificationSupport.selectTerm(staticClass("scala.collection.TraversableLike"), "map"), TypeName("B"), NoPosition, DEFERRED | PARAM, false);
+  //  val symdef$That2 = reificationSupport.newNestedSymbol(reificationSupport.selectTerm(staticClass("scala.collection.TraversableLike"), "map"), TypeName("That"), NoPosition, DEFERRED | PARAM, false);
+  //  val symdef$f2 = reificationSupport.newNestedSymbol(reificationSupport.selectTerm(staticClass("scala.collection.TraversableLike"), "map"), TermName("f"), NoPosition, PARAM, false);
+  //  val symdef$bf2 = reificationSupport.newNestedSymbol(reificationSupport.selectTerm(staticClass("scala.collection.TraversableLike"), "map"), TermName("bf"), NoPosition, IMPLICIT | PARAM, false);
+  //  reificationSupport.setInfo(symdef$B2, TypeBounds(staticClass("scala.Nothing").asType.toTypeConstructor, staticClass("scala.Any").asType.toTypeConstructor));
+  //  reificationSupport.setInfo(symdef$That2, TypeBounds(staticClass("scala.Nothing").asType.toTypeConstructor, staticClass("scala.Any").asType.toTypeConstructor));
+  //  reificationSupport.setInfo(symdef$f2, TypeRef(ThisType(staticPackage("scala").asModule.moduleClass), staticClass("scala.Function1"), List(staticClass("scala.Int").asType.toTypeConstructor, TypeRef(NoPrefix, symdef$B2, List()))));
+  //  reificationSupport.setInfo(symdef$bf2, TypeRef(ThisType(staticPackage("scala.collection.generic").asModule.moduleClass), staticClass("scala.collection.generic.CanBuildFrom"), List(TypeRef(ThisType(staticPackage("scala.collection.immutable").asModule.moduleClass), staticClass("scala.collection.immutable.List"), List(staticClass("scala.Int").asType.toTypeConstructor)), TypeRef(NoPrefix, symdef$B2, List()), TypeRef(NoPrefix, symdef$That2, List()))));
   //  PolyType(List(symdef$B2, symdef$That2), MethodType(List(symdef$f2), MethodType(List(symdef$bf2), TypeRef(NoPrefix, symdef$That2, List()))))
   //}
   //println(tpe)
diff --git a/test/files/run/macro-reify-unreify/Macros_1.scala b/test/files/run/macro-reify-unreify/Macros_1.scala
index 6e358eb72d..d92dfa3e24 100644
--- a/test/files/run/macro-reify-unreify/Macros_1.scala
+++ b/test/files/run/macro-reify-unreify/Macros_1.scala
@@ -6,10 +6,10 @@ object Macros {
   object Impls {
     def foo(c: Context)(s: c.Expr[String]) = {
       import c.universe._
-      import treeBuild._
+      import internal._
 
-      val world = c.reifyTree(mkRuntimeUniverseRef, EmptyTree, s.tree)
-      val greeting = c.reifyTree(mkRuntimeUniverseRef, EmptyTree, c.typecheck(Apply(Select(Literal(Constant("hello ")), TermName("$plus")), List(c.unreifyTree(world)))))
+      val world = c.reifyTree(gen.mkRuntimeUniverseRef, EmptyTree, s.tree)
+      val greeting = c.reifyTree(gen.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-subpatterns.check b/test/files/run/macro-subpatterns.check
index b34d4bf4a1..4997146cf2 100644
--- a/test/files/run/macro-subpatterns.check
+++ b/test/files/run/macro-subpatterns.check
@@ -1,3 +1,3 @@
-List((a @ Extractor((b @ Extractor((c @ _))))))
-List((b @ Extractor((c @ _))))
-List((c @ _))
+Some(List((a @ Extractor((b @ Extractor((c @ _)))))))
+Some(List((b @ Extractor((c @ _)))))
+Some(List((c @ _)))
diff --git a/test/files/run/macro-subpatterns/Macro_1.scala b/test/files/run/macro-subpatterns/Macro_1.scala
index 2de6b4da9d..e009e411a2 100644
--- a/test/files/run/macro-subpatterns/Macro_1.scala
+++ b/test/files/run/macro-subpatterns/Macro_1.scala
@@ -4,15 +4,14 @@ import language.experimental.macros
 object Extractor {
   def unapply(x: Any): Any = macro unapplyImpl
   def unapplyImpl(c: Context)(x: c.Tree) = {
-    val st = c.universe.asInstanceOf[reflect.internal.SymbolTable]
-    import st._
-    val subpatterns = x.attachments.get[SubpatternsAttachment].get.patterns
+    import c.universe._
+    import internal._
     q"""
       new {
         def isEmpty = false
-        def get = ${subpatterns.toString}
+        def get = ${subpatterns(x).toString}
         def unapply(x: Any) = this
-      }.unapply(${x.asInstanceOf[st.Tree]})
-    """.asInstanceOf[c.Tree]
+      }.unapply($x)
+    """
   }
 }
diff --git a/test/files/run/macro-typecheck-macrosdisabled.check b/test/files/run/macro-typecheck-macrosdisabled.check
index 0579a4f4c8..c618d22d8d 100644
--- a/test/files/run/macro-typecheck-macrosdisabled.check
+++ b/test/files/run/macro-typecheck-macrosdisabled.check
@@ -23,7 +23,7 @@
       def apply[U <: scala.reflect.api.Universe with Singleton]($m$untyped: scala.reflect.api.Mirror[U]): U#Type = {
         val $u: U = $m$untyped.universe;
         val $m: $u.Mirror = $m$untyped.asInstanceOf[$u.Mirror];
-        $u.ConstantType.apply($u.Constant.apply(2))
+        $u.internal.reificationSupport.ConstantType($u.Constant.apply(2))
       }
     };
     new $typecreator2()
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 eb558f49b5..0e549f4ab8 100644
--- a/test/files/run/macro-typecheck-macrosdisabled/Impls_Macros_1.scala
+++ b/test/files/run/macro-typecheck-macrosdisabled/Impls_Macros_1.scala
@@ -14,12 +14,13 @@ object Macros {
 
   def impl_with_macros_disabled(c: Context) = {
     import c.universe._
+    import internal._
 
     val rupkg = c.mirror.staticModule("scala.reflect.runtime.package")
-    val rusym = build.selectTerm(rupkg, "universe")
-    val NullaryMethodType(rutpe) = rusym.typeSignature
-    val ru = build.newFreeTerm("ru", scala.reflect.runtime.universe)
-    build.setTypeSignature(ru, rutpe)
+    val rusym = reificationSupport.selectTerm(rupkg, "universe")
+    val NullaryMethodType(rutpe) = rusym.info
+    val ru = reificationSupport.newFreeTerm("ru", scala.reflect.runtime.universe)
+    reificationSupport.setInfo(ru, rutpe)
 
     val tree2 = Apply(Select(Ident(ru), TermName("reify")), List(Literal(Constant(2))))
     val ttree2 = c.typecheck(tree2, withMacrosDisabled = true)
diff --git a/test/files/run/macro-typecheck-macrosdisabled2.check b/test/files/run/macro-typecheck-macrosdisabled2.check
index c6e1c08d5d..2e862a6089 100644
--- a/test/files/run/macro-typecheck-macrosdisabled2.check
+++ b/test/files/run/macro-typecheck-macrosdisabled2.check
@@ -10,7 +10,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.build.Ident($m.staticModule("scala.Array")), $u.TermName.apply("apply")), scala.collection.immutable.List.apply[$u.Literal]($u.Literal.apply($u.Constant.apply(2))))
+        $u.Apply.apply($u.Select.apply($u.internal.reificationSupport.mkIdent($m.staticModule("scala.Array")), $u.TermName.apply("apply")), scala.collection.immutable.List.apply[$u.Literal]($u.Literal.apply($u.Constant.apply(2))))
       }
     };
     new $treecreator1()
@@ -23,7 +23,7 @@
       def apply[U <: scala.reflect.api.Universe with Singleton]($m$untyped: scala.reflect.api.Mirror[U]): U#Type = {
         val $u: U = $m$untyped.universe;
         val $m: $u.Mirror = $m$untyped.asInstanceOf[$u.Mirror];
-        $u.TypeRef.apply($u.ThisType.apply($m.staticPackage("scala").asModule.moduleClass), $m.staticClass("scala.Array"), scala.collection.immutable.List.apply[$u.Type]($m.staticClass("scala.Int").asType.toTypeConstructor))
+        $u.internal.reificationSupport.TypeRef($u.internal.reificationSupport.ThisType($m.staticPackage("scala").asModule.moduleClass), $m.staticClass("scala.Array"), scala.collection.immutable.List.apply[$u.Type]($m.staticClass("scala.Int").asType.toTypeConstructor))
       }
     };
     new $typecreator2()
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 3412f5c88f..f99f5d2f80 100644
--- a/test/files/run/macro-typecheck-macrosdisabled2/Impls_Macros_1.scala
+++ b/test/files/run/macro-typecheck-macrosdisabled2/Impls_Macros_1.scala
@@ -14,12 +14,13 @@ object Macros {
 
   def impl_with_macros_disabled(c: Context) = {
     import c.universe._
+    import internal._
 
     val rupkg = c.mirror.staticModule("scala.reflect.runtime.package")
-    val rusym = build.selectTerm(rupkg, "universe")
-    val NullaryMethodType(rutpe) = rusym.typeSignature
-    val ru = build.newFreeTerm("ru", scala.reflect.runtime.universe)
-    build.setTypeSignature(ru, rutpe)
+    val rusym = reificationSupport.selectTerm(rupkg, "universe")
+    val NullaryMethodType(rutpe) = rusym.info
+    val ru = reificationSupport.newFreeTerm("ru", scala.reflect.runtime.universe)
+    reificationSupport.setInfo(ru, rutpe)
 
     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)
diff --git a/test/files/run/macro-vampire-false-warning/Macros_1.scala b/test/files/run/macro-vampire-false-warning/Macros_1.scala
index 0912bfba0c..63c34b3ab6 100644
--- a/test/files/run/macro-vampire-false-warning/Macros_1.scala
+++ b/test/files/run/macro-vampire-false-warning/Macros_1.scala
@@ -10,8 +10,8 @@ object Macros {
   def selFieldImpl(c: Context) = {
     import c.universe._
     val field = c.macroApplication.symbol
-    val bodyAnn = field.annotations.filter(_.tpe <:< typeOf[body]).head
-    c.Expr[Any](bodyAnn.scalaArgs.head)
+    val bodyAnn = field.annotations.filter(_.tree.tpe <:< typeOf[body]).head
+    c.Expr[Any](bodyAnn.tree.children(1))
   }
 
   def mkObjectImpl(c: Context)(xs: c.Expr[Any]*) = {
@@ -21,7 +21,7 @@ object Macros {
     val kvps = xs.map(_.tree).toList map { case Apply(TypeApply(Select(Apply(_, List(Literal(Constant(name: String)))), _), _), List(value)) => name -> value }
     // val fields = kvps map { case (k, v) => q"@body($v) def ${TermName(k)} = macro Macros.selFieldImpl" }
     val fields = kvps map { case (k, v) => DefDef(
-      Modifiers(MACRO, tpnme.EMPTY, List(Apply(Select(New(Ident(TypeName("body"))), nme.CONSTRUCTOR), List(v)))),
+      Modifiers(MACRO, typeNames.EMPTY, List(Apply(Select(New(Ident(TypeName("body"))), termNames.CONSTRUCTOR), List(v)))),
       TermName(k), Nil, Nil, Ident(TypeName("Any")), Select(Ident(TermName("Macros")), TermName("selFieldImpl"))) }
     // q"import scala.language.experimental.macros; class Workaround { ..$fields }; new Workaround{}"
     c.Expr[Any](Block(
@@ -32,8 +32,8 @@ object Macros {
           Template(
             List(Select(Ident(TermName("scala")), TypeName("AnyRef"))), noSelfType,
             DefDef(
-              NoMods, nme.CONSTRUCTOR, Nil, List(Nil), TypeTree(),
-              Block(List(Apply(Select(Super(This(tpnme.EMPTY), tpnme.EMPTY), nme.CONSTRUCTOR), List())), Literal(Constant(()))))
+              NoMods, termNames.CONSTRUCTOR, Nil, List(Nil), TypeTree(),
+              Block(List(Apply(Select(Super(This(typeNames.EMPTY), typeNames.EMPTY), termNames.CONSTRUCTOR), List())), Literal(Constant(()))))
             +: fields)),
         ClassDef(
           Modifiers(FINAL), TypeName("$anon"), Nil,
@@ -41,9 +41,9 @@ object Macros {
             List(Ident(TypeName("Workaround"))), noSelfType,
             List(
               DefDef(
-                NoMods, nme.CONSTRUCTOR, Nil, List(Nil), TypeTree(),
-                Block(List(Apply(Select(Super(This(tpnme.EMPTY), tpnme.EMPTY), nme.CONSTRUCTOR), List())), Literal(Constant(())))))))),
-      Apply(Select(New(Ident(TypeName("$anon"))), nme.CONSTRUCTOR), List())))
+                NoMods, termNames.CONSTRUCTOR, Nil, List(Nil), TypeTree(),
+                Block(List(Apply(Select(Super(This(typeNames.EMPTY), typeNames.EMPTY), termNames.CONSTRUCTOR), List())), Literal(Constant(())))))))),
+      Apply(Select(New(Ident(TypeName("$anon"))), termNames.CONSTRUCTOR), List())))
   }
 }
 
diff --git a/test/files/run/macro-whitebox-dynamic-materialization/Macros_1.scala b/test/files/run/macro-whitebox-dynamic-materialization/Macros_1.scala
index 60a8d011f1..a2e925bb3a 100644
--- a/test/files/run/macro-whitebox-dynamic-materialization/Macros_1.scala
+++ b/test/files/run/macro-whitebox-dynamic-materialization/Macros_1.scala
@@ -18,7 +18,7 @@ object Macros {
   def impl[T: c.WeakTypeTag](c: Context) = {
     import c.universe._
     val tpe = weakTypeOf[T]
-    if (tpe.members.exists(_.typeSignature =:= typeOf[Int]))
+    if (tpe.members.exists(_.info =:= typeOf[Int]))
       c.abort(c.enclosingPosition, "I don't like classes that contain integers")
     q"new Foo[$tpe]{ override def toString = ${tpe.toString} }"
   }
diff --git a/test/files/run/macro-whitebox-fundep-materialization/Macros_1.scala b/test/files/run/macro-whitebox-fundep-materialization/Macros_1.scala
index a8309e35b0..5e89e6b2f8 100644
--- a/test/files/run/macro-whitebox-fundep-materialization/Macros_1.scala
+++ b/test/files/run/macro-whitebox-fundep-materialization/Macros_1.scala
@@ -15,12 +15,12 @@ object Iso {
 
     val sym = c.weakTypeOf[T].typeSymbol
     if (!sym.isClass || !sym.asClass.isCaseClass) c.abort(c.enclosingPosition, s"$sym is not a case class")
-    val fields = sym.typeSignature.declarations.toList.collect{ case x: TermSymbol if x.isVal && x.isCaseAccessor => x }
+    val fields = sym.info.decls.toList.collect{ case x: TermSymbol if x.isVal && x.isCaseAccessor => x }
 
     def mkTpt() = {
       val core = Ident(TupleClass(fields.length) orElse UnitClass)
       if (fields.length == 0) core
-      else AppliedTypeTree(core, fields map (f => TypeTree(f.typeSignature)))
+      else AppliedTypeTree(core, fields map (f => TypeTree(f.info)))
     }
 
     def mkFrom() = {
@@ -32,8 +32,8 @@ object Iso {
       List(AppliedTypeTree(Ident(newTypeName("Iso")), List(Ident(sym), mkTpt()))),
       emptyValDef,
       List(
-        DefDef(Modifiers(), nme.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(Apply(Select(Super(This(tpnme.EMPTY), tpnme.EMPTY), nme.CONSTRUCTOR), List())), Literal(Constant(())))),
+        DefDef(Modifiers(), termNames.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(Apply(Select(Super(This(typeNames.EMPTY), typeNames.EMPTY), termNames.CONSTRUCTOR), List())), Literal(Constant(())))),
         DefDef(Modifiers(), newTermName("to"), List(), List(List(ValDef(Modifiers(PARAM), newTermName("f"), Ident(sym), EmptyTree))), TypeTree(), mkFrom()))))
-    c.Expr[Iso[T, U]](Block(List(evidenceClass), Apply(Select(New(Ident(newTypeName("$anon"))), nme.CONSTRUCTOR), List())))
+    c.Expr[Iso[T, U]](Block(List(evidenceClass), Apply(Select(New(Ident(newTypeName("$anon"))), termNames.CONSTRUCTOR), List())))
   }
 }
diff --git a/test/files/run/no-pickle-skolems/Test_2.scala b/test/files/run/no-pickle-skolems/Test_2.scala
index 8fd6016aea..da55ad9df0 100644
--- a/test/files/run/no-pickle-skolems/Test_2.scala
+++ b/test/files/run/no-pickle-skolems/Test_2.scala
@@ -7,7 +7,7 @@ object Test {
    *  named CC.
    */
   def collectSymbols[T: TypeTag](inMethod: TermName, name: String): List[String] = {
-    val m = typeOf[T] member inMethod typeSignatureIn typeOf[T]
+    val m = typeOf[T] member inMethod infoIn typeOf[T]
     var buf: List[Symbol] = Nil
     var seen: Set[Symbol] = Set()
     def id(s: Symbol): Int = s.asInstanceOf[{ def id: Int }].id
@@ -21,8 +21,8 @@ object Test {
     def loop(t: Type) {
       t match {
         case TypeRef(pre, sym, args)    => loop(pre) ; check(sym) ; args foreach loop
-        case PolyType(tparams, restpe)  => tparams foreach { tp => check(tp) ; check(tp.owner) ; loop(tp.typeSignature) } ; loop(restpe)
-        case MethodType(params, restpe) => params foreach { p => check(p) ; loop(p.typeSignature) } ; loop(restpe)
+        case PolyType(tparams, restpe)  => tparams foreach { tp => check(tp) ; check(tp.owner) ; loop(tp.info) } ; loop(restpe)
+        case MethodType(params, restpe) => params foreach { p => check(p) ; loop(p.info) } ; loop(restpe)
         case _                          =>
       }
     }
@@ -32,7 +32,7 @@ object Test {
   }
 
   def main(args: Array[String]): Unit = {
-    val syms = collectSymbols[s.Bar]("to", "CC")
+    val syms = collectSymbols[s.Bar](TermName("to"), "CC")
     assert(syms.size == 1, syms)
     println("OK!")
   }
diff --git a/test/files/run/reflection-allmirrors-tostring.check b/test/files/run/reflection-allmirrors-tostring.check
index 2a3be29402..3003cce6c0 100644
--- a/test/files/run/reflection-allmirrors-tostring.check
+++ b/test/files/run/reflection-allmirrors-tostring.check
@@ -1,14 +1,14 @@
 class mirror for C (bound to null)
 module mirror for M (bound to null)
 instance mirror for an instance of C
-field mirror for C.f1 (bound to an instance of C)
-field mirror for C.f2 (bound to an instance of C)
-method mirror for C.m1: Int (bound to an instance of C)
-method mirror for C.m2(): Int (bound to an instance of C)
-method mirror for C.m3[T >: String <: Int]: T (bound to an instance of C)
-method mirror for C.m4[A, B <: A[Int]](x: A[B])(implicit y: Int): Nothing (bound to an instance of C)
-method mirror for C.m5(x: => Int, y: Int*): String (bound to an instance of C)
+field mirror for private[this] val f1: Int (bound to an instance of C)
+field mirror for private[this] var f2: Int (bound to an instance of C)
+method mirror for def m1: Int (bound to an instance of C)
+method mirror for def m2(): Int (bound to an instance of C)
+method mirror for def m3[T >: String <: Int]: T (bound to an instance of C)
+method mirror for def m4[A[_], B <: A[Int]](x: A[B])(implicit y: Int): Nothing (bound to an instance of C)
+method mirror for def m5(x: => Int,y: Int*): String (bound to an instance of C)
 class mirror for C.C (bound to an instance of C)
 module mirror for C.M (bound to an instance of C)
-constructor mirror for C.<init>(): C (bound to null)
-constructor mirror for C.C.<init>(): C.this.C (bound to an instance of C)
+constructor mirror for def <init>(): C (bound to null)
+constructor mirror for def <init>(): C.this.C (bound to an instance of C)
diff --git a/test/files/run/reflection-allmirrors-tostring.scala b/test/files/run/reflection-allmirrors-tostring.scala
index 41bab5ac0e..f0614e9a98 100644
--- a/test/files/run/reflection-allmirrors-tostring.scala
+++ b/test/files/run/reflection-allmirrors-tostring.scala
@@ -1,4 +1,3 @@
-
 import scala.language.higherKinds
 import scala.reflect.runtime.universe._
 
@@ -40,6 +39,6 @@ object Test extends App {
 
   val c = cm.staticClass("C")
   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))
+  println(cm.reflectClass(c).reflectConstructor(c.info.member(termNames.CONSTRUCTOR).asMethod))
+  println(im.reflectClass(cc).reflectConstructor(cc.info.member(termNames.CONSTRUCTOR).asMethod))
 }
diff --git a/test/files/run/reflection-companion.check b/test/files/run/reflection-companion.check
new file mode 100644
index 0000000000..5dbff9960e
--- /dev/null
+++ b/test/files/run/reflection-companion.check
@@ -0,0 +1,6 @@
+C#MOD
+C#CLS
+C#CLS
+NoSymbol#???
+NoSymbol#???
+NoSymbol#???
diff --git a/test/files/run/reflection-companion.scala b/test/files/run/reflection-companion.scala
new file mode 100644
index 0000000000..0f62dead12
--- /dev/null
+++ b/test/files/run/reflection-companion.scala
@@ -0,0 +1,16 @@
+import scala.reflect.runtime.universe._
+import scala.reflect.runtime.{currentMirror => cm}
+
+class C
+object C
+
+object Test extends App {
+  type T = C
+
+  println(showRaw(symbolOf[C].companion, printKinds = true))
+  println(showRaw(symbolOf[C].companion.companion, printKinds = true))
+  println(showRaw(symbolOf[C.type].companion, printKinds = true))
+  println(showRaw(symbolOf[T].companion, printKinds = true))
+  println(showRaw(cm.staticPackage("scala").moduleClass.companion, printKinds = true))
+  println(showRaw(cm.staticPackage("scala").companion, printKinds = true))
+}
+\ No newline at end of file
diff --git a/test/files/run/reflection-companiontype.check b/test/files/run/reflection-companiontype.check
new file mode 100644
index 0000000000..f87bc04480
--- /dev/null
+++ b/test/files/run/reflection-companiontype.check
@@ -0,0 +1,12 @@
+TypeRefs
+TypeRef(ThisType(<empty>#PKC), C#MODC, List())
+TypeRef(ThisType(<empty>#PKC), C#CLS, List())
+TypeRef(ThisType(<empty>#PKC), C#CLS, List())
+ClassInfoTypes
+TypeRef(ThisType(<empty>#PKC), C#MODC, List())
+TypeRef(ThisType(<empty>#PKC), C#CLS, List())
+TypeRef(ThisType(<empty>#PKC), C#CLS, List())
+Unrelated
+NoType
+NoType
+NoType
diff --git a/test/files/run/reflection-companiontype.scala b/test/files/run/reflection-companiontype.scala
new file mode 100644
index 0000000000..0f63457670
--- /dev/null
+++ b/test/files/run/reflection-companiontype.scala
@@ -0,0 +1,22 @@
+import scala.reflect.runtime.universe._
+import scala.reflect.runtime.{currentMirror => cm}
+
+class C
+object C
+
+object Test extends App {
+  type T = C
+
+  println("TypeRefs")
+  println(showRaw(typeOf[C].companion, printKinds = true))
+  println(showRaw(typeOf[C].companion.companion, printKinds = true))
+  println(showRaw(typeOf[C.type].companion, printKinds = true))
+  println("ClassInfoTypes")
+  println(showRaw(typeOf[C].typeSymbol.info.companion, printKinds = true))
+  println(showRaw(typeOf[C].typeSymbol.info.companion.typeSymbol.info.companion, printKinds = true))
+  println(showRaw(typeOf[C.type].typeSymbol.info.companion, printKinds = true))
+  println("Unrelated")
+  println(showRaw(typeOf[T].companion, printKinds = true))
+  println(showRaw(cm.staticPackage("scala").moduleClass.asType.toType.companion, printKinds = true))
+  println(showRaw(cm.staticPackage("scala").info.companion, printKinds = true))
+}
+\ No newline at end of file
diff --git a/test/files/run/reflection-constructormirror-inner-badpath.scala b/test/files/run/reflection-constructormirror-inner-badpath.scala
index 4bccff21fe..e7c06b32ae 100644
--- a/test/files/run/reflection-constructormirror-inner-badpath.scala
+++ b/test/files/run/reflection-constructormirror-inner-badpath.scala
@@ -12,8 +12,8 @@ class Foo{
   val classTag = implicitly[ClassTag[R]]
   val cl = classTag.runtimeClass.getClassLoader
   val cm = runtimeMirror(cl)
-  val constructor = expectedType.tpe.member( nme.CONSTRUCTOR ).asMethod
-  val sig = constructor.typeSignature
+  val constructor = expectedType.tpe.member( termNames.CONSTRUCTOR ).asMethod
+  val sig = constructor.info
   val sym = cm.classSymbol( classTag.runtimeClass )
   try {
     val cls = cm.reflectClass( sym )
diff --git a/test/files/run/reflection-constructormirror-inner-good.scala b/test/files/run/reflection-constructormirror-inner-good.scala
index 861332161f..c09da5b300 100644
--- a/test/files/run/reflection-constructormirror-inner-good.scala
+++ b/test/files/run/reflection-constructormirror-inner-good.scala
@@ -12,8 +12,8 @@ class Foo{
   val classTag = implicitly[ClassTag[R]]
   val cl = classTag.runtimeClass.getClassLoader
   val cm = runtimeMirror(cl)
-  val constructor = expectedType.tpe.member( nme.CONSTRUCTOR ).asMethod
-  val sig = constructor.typeSignature
+  val constructor = expectedType.tpe.member( termNames.CONSTRUCTOR ).asMethod
+  val sig = constructor.info
   val sym = cm.classSymbol( classTag.runtimeClass )
   val cls = cm.reflect( this ).reflectClass( sym )
   cls.reflectConstructor( constructor )( 5,"test" ).asInstanceOf[R]
diff --git a/test/files/run/reflection-constructormirror-nested-badpath.scala b/test/files/run/reflection-constructormirror-nested-badpath.scala
index 2983f185de..cf0de77e10 100644
--- a/test/files/run/reflection-constructormirror-nested-badpath.scala
+++ b/test/files/run/reflection-constructormirror-nested-badpath.scala
@@ -8,8 +8,8 @@ class Foo{
   val classTag = implicitly[ClassTag[R]]
   val cl = classTag.runtimeClass.getClassLoader
   val cm = runtimeMirror(cl)
-  val constructor = expectedType.tpe.member( nme.CONSTRUCTOR ).asMethod
-  val sig = constructor.typeSignature
+  val constructor = expectedType.tpe.member( termNames.CONSTRUCTOR ).asMethod
+  val sig = constructor.info
   val sym = cm.classSymbol( classTag.runtimeClass )
   try {
     val cls = cm.reflect( this ).reflectClass( sym )
diff --git a/test/files/run/reflection-constructormirror-nested-good.scala b/test/files/run/reflection-constructormirror-nested-good.scala
index 0b7c413975..363b720461 100644
--- a/test/files/run/reflection-constructormirror-nested-good.scala
+++ b/test/files/run/reflection-constructormirror-nested-good.scala
@@ -8,8 +8,8 @@ class Foo{
   val classTag = implicitly[ClassTag[R]]
   val cl = classTag.runtimeClass.getClassLoader
   val cm = runtimeMirror(cl)
-  val constructor = expectedType.tpe.member( nme.CONSTRUCTOR ).asMethod
-  val sig = constructor.typeSignature
+  val constructor = expectedType.tpe.member( termNames.CONSTRUCTOR ).asMethod
+  val sig = constructor.info
   val sym = cm.classSymbol( classTag.runtimeClass )
   val cls = cm.reflectClass( sym )
   cls.reflectConstructor( constructor )( 5,"test" ).asInstanceOf[R]
diff --git a/test/files/run/reflection-constructormirror-toplevel-badpath.scala b/test/files/run/reflection-constructormirror-toplevel-badpath.scala
index cf92929119..eda4aa0531 100644
--- a/test/files/run/reflection-constructormirror-toplevel-badpath.scala
+++ b/test/files/run/reflection-constructormirror-toplevel-badpath.scala
@@ -13,8 +13,8 @@ class Foo{
   val classTag = implicitly[ClassTag[R]]
   val cl = classTag.runtimeClass.getClassLoader
   val cm = runtimeMirror(cl)
-  val constructor = expectedType.tpe.member( nme.CONSTRUCTOR ).asMethod
-  val sig = constructor.typeSignature
+  val constructor = expectedType.tpe.member( termNames.CONSTRUCTOR ).asMethod
+  val sig = constructor.info
   val sym = cm.classSymbol( classTag.runtimeClass )
   try {
     val cls = cm.reflect( this ).reflectClass( sym )
diff --git a/test/files/run/reflection-constructormirror-toplevel-good.scala b/test/files/run/reflection-constructormirror-toplevel-good.scala
index b68134b2cb..9842d01695 100644
--- a/test/files/run/reflection-constructormirror-toplevel-good.scala
+++ b/test/files/run/reflection-constructormirror-toplevel-good.scala
@@ -13,8 +13,8 @@ class Foo{
   val classTag = implicitly[ClassTag[R]]
   val cl = classTag.runtimeClass.getClassLoader
   val cm = runtimeMirror(cl)
-  val constructor = expectedType.tpe.member( nme.CONSTRUCTOR ).asMethod
-  val sig = constructor.typeSignature
+  val constructor = expectedType.tpe.member( termNames.CONSTRUCTOR ).asMethod
+  val sig = constructor.info
   val sym = cm.classSymbol( classTag.runtimeClass )
   val cls = cm.reflectClass( sym )
   cls.reflectConstructor( constructor )( 5,"test" ).asInstanceOf[R]
diff --git a/test/files/run/reflection-enclosed-basic.scala b/test/files/run/reflection-enclosed-basic.scala
index 7b9e0c20dc..e001207e82 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(TermName("foo")).asMethod
+    val method = instanceMirror.symbol.info.decl(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(nme.CONSTRUCTOR).asMethod
+    val ctor = sym.info.decl(termNames.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 c1cf9bc336..fd81a8d115 100644
--- a/test/files/run/reflection-enclosed-inner-basic.scala
+++ b/test/files/run/reflection-enclosed-inner-basic.scala
@@ -14,19 +14,19 @@ class B {
 object Test extends App {
   val b = cm.classSymbol(classTag[B].runtimeClass)
   println(b)
-  println(b.typeSignature.declarations.toList)
+  println(b.info.decls.toList)
 
   def testMethodInvocation(instance: Any) = {
     val instanceMirror = cm.reflect(instance)
-    val method = instanceMirror.symbol.typeSignature.declaration(TermName("foo")).asMethod
+    val method = instanceMirror.symbol.info.decl(TermName("foo")).asMethod
     val methodMirror = instanceMirror.reflectMethod(method)
     println(methodMirror())
   }
 
   def testInnerClass(name: String) = {
-    val sym = b.typeSignature.declaration(TypeName(name)).asClass
+    val sym = b.info.decl(TypeName(name)).asClass
     println(sym)
-    val ctor = sym.typeSignature.declaration(nme.CONSTRUCTOR).asMethod
+    val ctor = sym.info.decl(termNames.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(TermName(name)).asModule
+    val sym = b.info.decl(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 8a73fac522..45dfb8a61f 100644
--- a/test/files/run/reflection-enclosed-inner-inner-basic.scala
+++ b/test/files/run/reflection-enclosed-inner-inner-basic.scala
@@ -16,19 +16,19 @@ class B {
 object Test extends App {
   val b = cm.classSymbol(classTag[B#BB].runtimeClass)
   println(b)
-  println(b.typeSignature.declarations.toList)
+  println(b.info.decls.toList)
 
   def testMethodInvocation(instance: Any) = {
     val instanceMirror = cm.reflect(instance)
-    val method = instanceMirror.symbol.typeSignature.declaration(TermName("foo")).asMethod
+    val method = instanceMirror.symbol.info.decl(TermName("foo")).asMethod
     val methodMirror = instanceMirror.reflectMethod(method)
     println(methodMirror())
   }
 
   def testInnerClass(name: String) = {
-    val sym = b.typeSignature.declaration(TypeName(name)).asClass
+    val sym = b.info.decl(TypeName(name)).asClass
     println(sym)
-    val ctor = sym.typeSignature.declaration(nme.CONSTRUCTOR).asMethod
+    val ctor = sym.info.decl(termNames.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(TermName(name)).asModule
+    val sym = b.info.decl(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 6c2fc6df7a..1973f47397 100644
--- a/test/files/run/reflection-enclosed-inner-nested-basic.scala
+++ b/test/files/run/reflection-enclosed-inner-nested-basic.scala
@@ -17,19 +17,19 @@ object Test extends App {
   val outer1 = new B()
   val b = cm.moduleSymbol(classTag[outer1.BB.type].runtimeClass)
   println(b)
-  println(b.typeSignature.declarations.toList)
+  println(b.info.decls.toList)
 
   def testMethodInvocation(instance: Any) = {
     val instanceMirror = cm.reflect(instance)
-    val method = instanceMirror.symbol.typeSignature.declaration(TermName("foo")).asMethod
+    val method = instanceMirror.symbol.info.decl(TermName("foo")).asMethod
     val methodMirror = instanceMirror.reflectMethod(method)
     println(methodMirror())
   }
 
   def testNestedClass(name: String) = {
-    val sym = b.typeSignature.declaration(TypeName(name)).asClass
+    val sym = b.info.decl(TypeName(name)).asClass
     println(sym)
-    val ctor = sym.typeSignature.declaration(nme.CONSTRUCTOR).asMethod
+    val ctor = sym.info.decl(termNames.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(TermName(name)).asModule
+    val sym = b.info.decl(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 180ac4ebee..4ff333d10f 100644
--- a/test/files/run/reflection-enclosed-nested-basic.scala
+++ b/test/files/run/reflection-enclosed-nested-basic.scala
@@ -14,19 +14,19 @@ object B {
 object Test extends App {
   val b = cm.moduleSymbol(classTag[B.type].runtimeClass)
   println(b)
-  println(b.typeSignature.declarations.toList)
+  println(b.info.decls.toList)
 
   def testMethodInvocation(instance: Any) = {
     val instanceMirror = cm.reflect(instance)
-    val method = instanceMirror.symbol.typeSignature.declaration(TermName("foo")).asMethod
+    val method = instanceMirror.symbol.info.decl(TermName("foo")).asMethod
     val methodMirror = instanceMirror.reflectMethod(method)
     println(methodMirror())
   }
 
   def testNestedClass(name: String) = {
-    val sym = b.typeSignature.declaration(TypeName(name)).asClass
+    val sym = b.info.decl(TypeName(name)).asClass
     println(sym)
-    val ctor = sym.typeSignature.declaration(nme.CONSTRUCTOR).asMethod
+    val ctor = sym.info.decl(termNames.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(TermName(name)).asModule
+    val sym = b.info.decl(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 2558b8035a..d45894c8c2 100644
--- a/test/files/run/reflection-enclosed-nested-inner-basic.scala
+++ b/test/files/run/reflection-enclosed-nested-inner-basic.scala
@@ -16,19 +16,19 @@ object B {
 object Test extends App {
   val b = cm.classSymbol(classTag[B.BB].runtimeClass)
   println(b)
-  println(b.typeSignature.declarations.toList)
+  println(b.info.decls.toList)
 
   def testMethodInvocation(instance: Any) = {
     val instanceMirror = cm.reflect(instance)
-    val method = instanceMirror.symbol.typeSignature.declaration(TermName("foo")).asMethod
+    val method = instanceMirror.symbol.info.decl(TermName("foo")).asMethod
     val methodMirror = instanceMirror.reflectMethod(method)
     println(methodMirror())
   }
 
   def testInnerClass(name: String) = {
-    val sym = b.typeSignature.declaration(TypeName(name)).asClass
+    val sym = b.info.decl(TypeName(name)).asClass
     println(sym)
-    val ctor = sym.typeSignature.declaration(nme.CONSTRUCTOR).asMethod
+    val ctor = sym.info.decl(termNames.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(TermName(name)).asModule
+    val sym = b.info.decl(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 b4711c9a8c..8a630ea1fb 100644
--- a/test/files/run/reflection-enclosed-nested-nested-basic.scala
+++ b/test/files/run/reflection-enclosed-nested-nested-basic.scala
@@ -16,19 +16,19 @@ object B {
 object Test extends App {
   val b = cm.moduleSymbol(classTag[B.BB.type].runtimeClass)
   println(b)
-  println(b.typeSignature.declarations.toList)
+  println(b.info.decls.toList)
 
   def testMethodInvocation(instance: Any) = {
     val instanceMirror = cm.reflect(instance)
-    val method = instanceMirror.symbol.typeSignature.declaration(TermName("foo")).asMethod
+    val method = instanceMirror.symbol.info.decl(TermName("foo")).asMethod
     val methodMirror = instanceMirror.reflectMethod(method)
     println(methodMirror())
   }
 
   def testNestedClass(name: String) = {
-    val sym = b.typeSignature.declaration(TypeName(name)).asClass
+    val sym = b.info.decl(TypeName(name)).asClass
     println(sym)
-    val ctor = sym.typeSignature.declaration(nme.CONSTRUCTOR).asMethod
+    val ctor = sym.info.decl(termNames.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(TermName(name)).asModule
+    val sym = b.info.decl(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 3af3ad774d..682326bc18 100644
--- a/test/files/run/reflection-equality.check
+++ b/test/files/run/reflection-equality.check
@@ -20,17 +20,17 @@ im: reflect.runtime.universe.InstanceMirror
 scala> val cs: ClassSymbol = im.symbol
 cs: reflect.runtime.universe.ClassSymbol = class X
 
-scala> val ts: Type = cs.typeSignature
+scala> val ts: Type = cs.info
 ts: reflect.runtime.universe.Type =
 scala.AnyRef {
   def <init>(): X
   def methodIntIntInt(x: scala.Int,y: scala.Int): scala.Int
 }
 
-scala> val ms: MethodSymbol = ts.declaration(TermName("methodIntIntInt")).asMethod
+scala> val ms: MethodSymbol = ts.decl(TermName("methodIntIntInt")).asMethod
 ms: reflect.runtime.universe.MethodSymbol = method methodIntIntInt
 
-scala> val MethodType( _, t1 ) = ms.typeSignature
+scala> val MethodType( _, t1 ) = ms.info
 t1: reflect.runtime.universe.Type = scala.Int
 
 scala> val t2 = typeOf[scala.Int]
diff --git a/test/files/run/reflection-equality.scala b/test/files/run/reflection-equality.scala
index 40f116bb53..0416bc7726 100644
--- a/test/files/run/reflection-equality.scala
+++ b/test/files/run/reflection-equality.scala
@@ -10,9 +10,9 @@ object Test extends ReplTest {
     |import scala.reflect.runtime.{ currentMirror => cm }
     |def im: InstanceMirror = cm.reflect(new X)
     |val cs: ClassSymbol = im.symbol
-    |val ts: Type = cs.typeSignature
-    |val ms: MethodSymbol = ts.declaration(TermName("methodIntIntInt")).asMethod
-    |val MethodType( _, t1 ) = ms.typeSignature
+    |val ts: Type = cs.info
+    |val ms: MethodSymbol = ts.decl(TermName("methodIntIntInt")).asMethod
+    |val MethodType( _, t1 ) = ms.info
     |val t2 = typeOf[scala.Int]
     |t1 == t2
     |t1 =:= t2
diff --git a/test/files/run/reflection-fieldmirror-accessorsareokay.scala b/test/files/run/reflection-fieldmirror-accessorsareokay.scala
index 3926ab7835..0e75dcf7e6 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(TermName("x")).asTerm)
-  test(cs.typeSignature.declaration(TermName("x_$eq")).asTerm)
+  test(cs.info.decl(TermName("x")).asTerm)
+  test(cs.info.decl(TermName("x_$eq")).asTerm)
 }
diff --git a/test/files/run/reflection-fieldmirror-ctorparam.scala b/test/files/run/reflection-fieldmirror-ctorparam.scala
index 608adad27b..b5b6b21027 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(TermName("x")).asTerm
+  val f = cs.info.decl(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 6a88dc3118..4fe0d2e4f3 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(TermName("x" + nme.LOCAL_SUFFIX_STRING)).asTerm
+  val f = cs.info.decl(TermName("x" + termNames.LOCAL_SUFFIX_STRING)).asTerm
   val fm: FieldMirror = im.reflectField(f)
   println(fm.get)
   fm.set(2)
diff --git a/test/files/run/reflection-fieldmirror-getsetvar.scala b/test/files/run/reflection-fieldmirror-getsetvar.scala
index 52c13a73bb..c64b0c46c0 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(TermName("x" + nme.LOCAL_SUFFIX_STRING)).asTerm
+  val f = cs.info.decl(TermName("x" + termNames.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 e070cdcfa3..ddc6c42e78 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(TermName("x" + nme.LOCAL_SUFFIX_STRING)).asTerm
+  val f = cs.info.decl(TermName("x" + termNames.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 89948772b1..1ece46576d 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(TermName("x")).asTerm
+  val f = cs.info.decl(TermName("x")).asTerm
   val fm: FieldMirror = im.reflectField(f)
   println(fm.symbol.isVar)
   println(fm.get)
diff --git a/test/files/run/reflection-idtc.check b/test/files/run/reflection-idtc.check
new file mode 100644
index 0000000000..9cdeb02f8c
--- /dev/null
+++ b/test/files/run/reflection-idtc.check
@@ -0,0 +1,6 @@
+[X]X
+Int
+===
+[X]Id[X]
+Id[Int]
+Int
diff --git a/test/files/run/reflection-idtc.scala b/test/files/run/reflection-idtc.scala
new file mode 100644
index 0000000000..f9eae612f0
--- /dev/null
+++ b/test/files/run/reflection-idtc.scala
@@ -0,0 +1,16 @@
+import scala.reflect.runtime.universe._
+import scala.reflect.runtime.{currentMirror => cm}
+import scala.tools.reflect.ToolBox
+
+object Test extends App {
+  val tb = cm.mkToolBox()
+  val idsym = tb.typecheck(q"type Id[X] = X").symbol.asType
+  val idTC1 = idsym.info
+  println(idTC1)
+  println(appliedType(idTC1, List(typeOf[Int])))
+  println("===")
+  val idTC2 = idsym.toType.etaExpand
+  println(idTC2)
+  println(appliedType(idTC2, List(typeOf[Int])))
+  println(appliedType(idTC2, List(typeOf[Int])).dealias)
+}
+\ No newline at end of file
diff --git a/test/files/run/reflection-implClass.scala b/test/files/run/reflection-implClass.scala
index db211fd9a8..4242530dd1 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(TermName("bar")).typeSignature ==
-    cm.classSymbol(classTag[Bar].runtimeClass).typeSignature.declaration(TermName("foo")).typeSignature)
+  assert(cm.classSymbol(classTag[Foo].runtimeClass).info.decl(TermName("bar")).info ==
+    cm.classSymbol(classTag[Bar].runtimeClass).info.decl(TermName("foo")).info)
 
   val s1 = implClass(classTag[Foo].runtimeClass)
   assert(s1 != NoSymbol)
-  assert(s1.typeSignature != NoType)
-  assert(s1.companionSymbol.typeSignature != NoType)
-  assert(s1.companionSymbol.typeSignature.declaration(TermName("bar")) != NoSymbol)
+  assert(s1.info != NoType)
+  assert(s1.companion.info != NoType)
+  assert(s1.companion.info.decl(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(TermName("foo")) != NoSymbol)
+  assert(s2.info != NoType)
+  assert(s2.companion.info != NoType)
+  assert(s2.companion.info.decl(TermName("foo")) != NoSymbol)
   def implClass(clazz: Class[_]) = {
     val implClass = Class.forName(clazz.getName + "$class")
     cm.classSymbol(implClass)
diff --git a/test/files/run/reflection-implicit.scala b/test/files/run/reflection-implicit.scala
index f2b3ba960c..a6e939322a 100644
--- a/test/files/run/reflection-implicit.scala
+++ b/test/files/run/reflection-implicit.scala
@@ -9,9 +9,9 @@ class C {
 }
 
 object Test extends App {
-  val decls = typeOf[C].typeSymbol.typeSignature.declarations.sorted.toList.filter(sym => !sym.isTerm || (sym.isMethod && !sym.asMethod.isConstructor))
+  val decls = typeOf[C].typeSymbol.info.decls.sorted.toList.filter(sym => !sym.isTerm || (sym.isMethod && !sym.asMethod.isConstructor))
   println(decls map (_.isImplicit))
-  val param = decls.find(_.name.toString == "d").get.asMethod.paramss.last.head
-  param.typeSignature
+  val param = decls.find(_.name.toString == "d").get.asMethod.paramLists.last.head
+  param.info
   println(param.isImplicit)
 }
diff --git a/test/files/run/reflection-java-annotations.check b/test/files/run/reflection-java-annotations.check
index 2d37fff1f4..72d40989fe 100644
--- a/test/files/run/reflection-java-annotations.check
+++ b/test/files/run/reflection-java-annotations.check
@@ -1 +1,4 @@
+warning: there were 1 deprecation warning(s); re-run with -deprecation for details
 List(JavaComplexAnnotation_1(v1 = 1, v10 = "hello", v101 = [101, 101], v102 = [102, 102], v103 = ['g', 'g'], v104 = [104, 104], v105 = [105L, 105L], v106 = [106.0, 106.0], v107 = [107.0, 107.0], v108 = [false, true], v11 = classOf[JavaAnnottee_1], v110 = ["hello", "world"], v111 = [classOf[JavaSimpleAnnotation_1], classOf[JavaComplexAnnotation_1]], v112 = [FOO, BAR], v113 = [JavaSimpleAnnotation_1(v1 = 21, v10 = "world2", v11 = classOf[JavaComplexAnnotation_1], v12 = BAR, v2 = 22, v3 = '\027', v4 = 24, v5 = 25L, v6 = 26.0, v7 = 27.0, v8 = false)], v12 = FOO, v13 = JavaSimpleAnnotation_1(v1 = 11, v10 = "world1", v11 = classOf[JavaSimpleAnnotation_1], v12 = FOO, v2 = 12, v3 = '\r', v4 = 14, v5 = 15L, v6 = 16.0, v7 = 17.0, v8 = false), v2 = 2, v3 = '\03', v4 = 4, v5 = 5L, v6 = 6.0, v7 = 7.0, v8 = false))
+=======
+new JavaComplexAnnotation_1(v1 = 1, v10 = "hello", v101 = Array(101, 101), v102 = Array(102, 102), v103 = Array('g', 'g'), v104 = Array(104, 104), v105 = Array(105L, 105L), v106 = Array(106.0, 106.0), v107 = Array(107.0, 107.0), v108 = Array(false, true), v11 = classOf[JavaAnnottee_1], v110 = Array("hello", "world"), v111 = Array(classOf[JavaSimpleAnnotation_1], classOf[JavaComplexAnnotation_1]), v112 = Array(FOO, BAR), v113 = Array(new JavaSimpleAnnotation_1(v1 = 21, v10 = "world2", v11 = classOf[JavaComplexAnnotation_1], v12 = BAR, v2 = 22, v3 = '\027', v4 = 24, v5 = 25L, v6 = 26.0, v7 = 27.0, v8 = false)), v12 = FOO, v13 = new JavaSimpleAnnotation_1(v1 = 11, v10 = "world1", v11 = classOf[JavaSimpleAnnotation_1], v12 = FOO, v2 = 12, v3 = '\r', v4 = 14, v5 = 15L, v6 = 16.0, v7 = 17.0, v8 = false), v2 = 2, v3 = '\03', v4 = 4, v5 = 5L, v6 = 6.0, v7 = 7.0, v8 = false)
diff --git a/test/files/run/reflection-java-annotations/Test_2.scala b/test/files/run/reflection-java-annotations/Test_2.scala
index d2c3157071..dec5b45ca7 100644
--- a/test/files/run/reflection-java-annotations/Test_2.scala
+++ b/test/files/run/reflection-java-annotations/Test_2.scala
@@ -1,7 +1,9 @@
 object Test extends App {
   import scala.reflect.runtime.universe._
   val sym = typeOf[JavaAnnottee_1].typeSymbol
-  sym.typeSignature
+  sym.info
   sym.annotations foreach (_.javaArgs)
   println(sym.annotations)
+  println("=======")
+  sym.annotations.map(_.tree).map(println)
 }
 \ No newline at end of file
diff --git a/test/files/run/reflection-java-crtp/Main_2.scala b/test/files/run/reflection-java-crtp/Main_2.scala
index fb5668f323..b9347869e4 100644
--- a/test/files/run/reflection-java-crtp/Main_2.scala
+++ b/test/files/run/reflection-java-crtp/Main_2.scala
@@ -3,6 +3,6 @@ object Test extends App {
   val enum = typeOf[JavaSimpleEnumeration_1].baseClasses(1).asClass
   // make sure that the E's in Enum<E extends Enum<E>> are represented by the same symbol
   val e1 = enum.typeParams(0).asType
-  val TypeBounds(_, TypeRef(_, _, List(TypeRef(_, e2: TypeSymbol, _)))) = e1.typeSignature
+  val TypeBounds(_, TypeRef(_, _, List(TypeRef(_, e2: TypeSymbol, _)))) = e1.info
   println(e1, e2, e1 eq e2)
 }
 \ No newline at end of file
diff --git a/test/files/run/reflection-magicsymbols-invoke.check b/test/files/run/reflection-magicsymbols-invoke.check
index b153ae0470..f580296ae7 100644
--- a/test/files/run/reflection-magicsymbols-invoke.check
+++ b/test/files/run/reflection-magicsymbols-invoke.check
@@ -15,12 +15,12 @@ testing Any.!=: false
 testing Any.##: 50
 testing Any.==: true
 testing Any.asInstanceOf: class scala.ScalaReflectionException: Any.asInstanceOf requires a type argument, it cannot be invoked with mirrors
-testing Any.asInstanceOf: class scala.ScalaReflectionException: scala.Any.asInstanceOf[T0]: T0 takes 0 arguments
+testing Any.asInstanceOf: class scala.ScalaReflectionException: final def asInstanceOf[T0]: T0 takes 0 arguments
 testing Any.equals: true
 testing Any.getClass: class java.lang.String
 testing Any.hashCode: 50
 testing Any.isInstanceOf: class scala.ScalaReflectionException: Any.isInstanceOf requires a type argument, it cannot be invoked with mirrors
-testing Any.isInstanceOf: class scala.ScalaReflectionException: scala.Any.isInstanceOf[T0]: Boolean takes 0 arguments
+testing Any.isInstanceOf: class scala.ScalaReflectionException: final def isInstanceOf[T0]: Boolean takes 0 arguments
 testing Any.toString: 2
 ============
 AnyVal
@@ -28,7 +28,7 @@ it's important to print the list of AnyVal's members
 if some of them change (possibly, adding and/or removing magic symbols), we must update this test
 constructor AnyVal: ()AnyVal
 method getClass: ()Class[_ <: AnyVal]
-testing AnyVal.<init>: class scala.ScalaReflectionException: unsupported symbol constructor AnyVal when invoking bytecodeless method mirror for scala.AnyVal.<init>(): AnyVal (bound to null)
+testing AnyVal.<init>: class scala.ScalaReflectionException: unsupported symbol constructor AnyVal when invoking bytecodeless method mirror for def <init>(): AnyVal (bound to null)
 testing AnyVal.getClass: class scala.ScalaReflectionException: expected a member of class Integer, you provided method scala.AnyVal.getClass
 ============
 AnyRef
@@ -59,9 +59,9 @@ method wait: (x$1: Long, x$2: Int)Unit
 testing Object.!=: false
 testing Object.##: 50
 testing Object.$asInstanceOf: class scala.ScalaReflectionException: AnyRef.$asInstanceOf is an internal method, it cannot be invoked with mirrors
-testing Object.$asInstanceOf: class scala.ScalaReflectionException: java.lang.Object.$asInstanceOf[T0](): T0 takes 0 arguments
+testing Object.$asInstanceOf: class scala.ScalaReflectionException: final def $asInstanceOf[T0](): T0 takes 0 arguments
 testing Object.$isInstanceOf: class scala.ScalaReflectionException: AnyRef.$isInstanceOf is an internal method, it cannot be invoked with mirrors
-testing Object.$isInstanceOf: class scala.ScalaReflectionException: java.lang.Object.$isInstanceOf[T0](): Boolean takes 0 arguments
+testing Object.$isInstanceOf: class scala.ScalaReflectionException: final def $isInstanceOf[T0](): Boolean takes 0 arguments
 testing Object.==: true
 testing Object.clone: class java.lang.CloneNotSupportedException: java.lang.String
 testing Object.eq: true
@@ -115,5 +115,5 @@ testing String.+: 23
 ============
 CTM
 testing Predef.classOf: class scala.ScalaReflectionException: Predef.classOf is a compile-time function, it cannot be invoked with mirrors
-testing Predef.classOf: class scala.ScalaReflectionException: scala.Predef.classOf[T]: Class[T] takes 0 arguments
+testing Predef.classOf: class scala.ScalaReflectionException: def classOf[T]: Class[T] takes 0 arguments
 testing Universe.reify: class scala.ScalaReflectionException: scala.reflect.api.Universe.reify is a macro, i.e. a compile-time function, it cannot be invoked with mirrors
diff --git a/test/files/run/reflection-magicsymbols-invoke.scala b/test/files/run/reflection-magicsymbols-invoke.scala
index ff3992709f..793f78bff4 100644
--- a/test/files/run/reflection-magicsymbols-invoke.scala
+++ b/test/files/run/reflection-magicsymbols-invoke.scala
@@ -9,7 +9,7 @@ package scala {
 }
 
 object Test extends App {
-  def key(sym: Symbol) = sym + ": " + sym.typeSignature
+  def key(sym: Symbol) = sym + ": " + sym.info
   def test(tpe: Type, receiver: Any, method: String, args: Any*) {
     def wrap[T](op: => T) =
       try {
@@ -24,11 +24,11 @@ object Test extends App {
       }
     print(s"testing ${tpe.typeSymbol.name}.$method: ")
     wrap({
-      if (method == nme.CONSTRUCTOR.toString) {
-        val ctor = tpe.declaration(nme.CONSTRUCTOR).asMethod
+      if (method == termNames.CONSTRUCTOR.toString) {
+        val ctor = tpe.decl(termNames.CONSTRUCTOR).asMethod
         cm.reflectClass(ctor.owner.asClass).reflectConstructor(ctor)(args: _*)
       } else {
-        val meth = tpe.declaration(TermName(method).encodedName.toTermName).asMethod
+        val meth = tpe.decl(TermName(method).encodedName.toTermName).asMethod
         cm.reflect(receiver).reflectMethod(meth)(args: _*)
       }
     })
@@ -53,8 +53,8 @@ object Test extends App {
   println("============\nAnyVal")
   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, nme.CONSTRUCTOR.toString)
+  typeOf[AnyVal].decls.toList.sortBy(key).foreach(sym => println(key(sym)))
+  test(typeOf[AnyVal], null, termNames.CONSTRUCTOR.toString)
   test(typeOf[AnyVal], 2, "getClass")
 
   println("============\nAnyRef")
@@ -84,17 +84,17 @@ object Test extends App {
   println("============\nArray")
   println("it's important to print the list of Array's members")
   println("if some of them change (possibly, adding and/or removing magic symbols), we must update this test")
-  ArrayClass.typeSignature.members.toList.sortBy(key).foreach(sym => println(key(sym)))
-  test(ArrayClass.typeSignature, Array(1, 2), "length")
-  test(ArrayClass.typeSignature, Array(1, 2), "apply", 0)
-  test(ArrayClass.typeSignature, Array(1, 2), "update", 0, 0)
-  test(ArrayClass.typeSignature, Array(1, 2), "clone")
+  ArrayClass.info.members.toList.sortBy(key).foreach(sym => println(key(sym)))
+  test(ArrayClass.info, Array(1, 2), "length")
+  test(ArrayClass.info, Array(1, 2), "apply", 0)
+  test(ArrayClass.info, Array(1, 2), "update", 0, 0)
+  test(ArrayClass.info, Array(1, 2), "clone")
 
   println("============\nOther")
   test(typeOf[String], "2", "+", 3)
 
   println("============\nCTM")
-  test(PredefModule.moduleClass.typeSignature, Predef, "classOf")
-  test(PredefModule.moduleClass.typeSignature, Predef, "classOf", typeOf[String])
+  test(PredefModule.moduleClass.info, Predef, "classOf")
+  test(PredefModule.moduleClass.info, Predef, "classOf", typeOf[String])
   test(typeOf[scala.reflect.api.Universe], scala.reflect.runtime.universe, "reify", "2")
 }
 \ No newline at end of file
diff --git a/test/files/run/reflection-magicsymbols-repl.check b/test/files/run/reflection-magicsymbols-repl.check
index 46c21dfa00..a1bee76652 100644
--- a/test/files/run/reflection-magicsymbols-repl.check
+++ b/test/files/run/reflection-magicsymbols-repl.check
@@ -17,9 +17,9 @@ scala> class A {
 defined class A
 
 scala> def test(n: Int): Unit = {
-  val sig = typeOf[A] member TermName("foo" + n) typeSignature
+  val sig = typeOf[A] member TermName("foo" + n) info
   val x = sig.asInstanceOf[MethodType].params.head
-  println(x.typeSignature)
+  println(x.info)
 }
 warning: there were 1 feature warning(s); re-run with -feature for details
 test: (n: Int)Unit
diff --git a/test/files/run/reflection-magicsymbols-repl.scala b/test/files/run/reflection-magicsymbols-repl.scala
index 6a432c2664..c006e85b3a 100644
--- a/test/files/run/reflection-magicsymbols-repl.scala
+++ b/test/files/run/reflection-magicsymbols-repl.scala
@@ -14,9 +14,9 @@ object Test extends ReplTest {
     |  def foo8(x: Singleton) = ???
     |}
     |def test(n: Int): Unit = {
-    |  val sig = typeOf[A] member TermName("foo" + n) typeSignature
+    |  val sig = typeOf[A] member TermName("foo" + n) info
     |  val x = sig.asInstanceOf[MethodType].params.head
-    |  println(x.typeSignature)
+    |  println(x.info)
     |}
     |for (i <- 1 to 8) test(i)
     |""".stripMargin
diff --git a/test/files/run/reflection-magicsymbols-vanilla.scala b/test/files/run/reflection-magicsymbols-vanilla.scala
index 2bde3d8874..328caf945d 100644
--- a/test/files/run/reflection-magicsymbols-vanilla.scala
+++ b/test/files/run/reflection-magicsymbols-vanilla.scala
@@ -14,9 +14,9 @@ class A {
 object Test extends App {
   import scala.reflect.runtime.universe._
   def test(n: Int): Unit = {
-    val sig = typeOf[A] member TermName("foo" + n) typeSignature
+    val sig = typeOf[A] member TermName("foo" + n) info
     val x = sig.asInstanceOf[MethodType].params.head
-    println(x.typeSignature)
+    println(x.info)
   }
   for (i <- 1 to 8) test(i)
 }
diff --git a/test/files/run/reflection-methodsymbol-params.scala b/test/files/run/reflection-methodsymbol-params.scala
index baad8d6b9b..bc1289a625 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(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)
+  println(typeOf[C].member(TermName("x1")).asMethod.paramLists)
+  println(typeOf[C].member(TermName("x2")).asMethod.paramLists)
+  println(typeOf[C].member(TermName("x3")).asMethod.paramLists)
+  println(typeOf[C].member(TermName("x4")).asMethod.paramLists)
+  println(typeOf[C].member(TermName("y1")).asMethod.paramLists)
+  println(typeOf[C].member(TermName("y2")).asMethod.paramLists)
+  println(typeOf[C].member(TermName("y3")).asMethod.paramLists)
+  println(typeOf[C].member(TermName("y4")).asMethod.paramLists)
 }
 \ No newline at end of file
diff --git a/test/files/run/reflection-names.scala b/test/files/run/reflection-names.scala
index 2433c84813..a297b85825 100644
--- a/test/files/run/reflection-names.scala
+++ b/test/files/run/reflection-names.scala
@@ -4,10 +4,10 @@ object Test {
   val global = new Global(new Settings())
   import global._
 
-  val x1 = "abc" drop 1                      // "bc": String
-  val x2 = ("abc": TermName) drop 1          // "bc": TermName
-  val x3 = ("abc": TypeName) drop 1          // "bc": TypeName
-  val x4 = (("abc": TypeName): Name) drop 1  // "bc": Name
+  val x1 = "abc" drop 1                    // "bc": String
+  val x2 = TermName("abc") drop 1          // "bc": TermName
+  val x3 = TypeName("abc") drop 1          // "bc": TypeName
+  val x4 = (TypeName("abc"): Name) drop 1  // "bc": Name
 
   def main(args: Array[String]): Unit = {
     List(x1, x2, x3, x4) foreach (x => println(x.getClass.getName, x))
diff --git a/test/files/run/reflection-repl-classes.check b/test/files/run/reflection-repl-classes.check
index 874fed2d7c..03a6aef2b5 100644
--- a/test/files/run/reflection-repl-classes.check
+++ b/test/files/run/reflection-repl-classes.check
@@ -17,7 +17,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.TermName("foo")).asMethod
+  val method = im.symbol.info.member(u.TermName("foo")).asMethod
   val mm = im.reflectMethod(method)
 }
 defined object defs
diff --git a/test/files/run/reflection-repl-classes.scala b/test/files/run/reflection-repl-classes.scala
index 4bfb980498..048e6b8ce0 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.TermName("foo")).asMethod
+    |  val method = im.symbol.info.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 6d3daff1f7..3f4873bbee 100644
--- a/test/files/run/reflection-sanitychecks.scala
+++ b/test/files/run/reflection-sanitychecks.scala
@@ -38,7 +38,7 @@ object Test extends App {
     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("class: " + failsafe(im.reflectClass(tpe.member(TypeName("C")).asClass).reflectConstructor(typeOf[C].member(TypeName("C")).asClass.info.member(termNames.CONSTRUCTOR).asMethod)()))
     println("object: " + failsafe(im.reflectModule(tpe.member(TermName("O")).asModule).instance))
     println()
   }
diff --git a/test/files/run/reflection-scala-annotations.check b/test/files/run/reflection-scala-annotations.check
new file mode 100644
index 0000000000..5bc2786161
--- /dev/null
+++ b/test/files/run/reflection-scala-annotations.check
@@ -0,0 +1,7 @@
+reflection-scala-annotations.scala:5: warning: Implementation restriction: subclassing Classfile does not
+make your annotation visible at runtime.  If that is what
+you want, you must write the annotation class in Java.
+class jann(x: Int, y: Array[Int]) extends ClassfileAnnotation
+      ^
+new sann(1, immutable.this.List.apply[Int](1, 2))
+new jann(y = Array(1, 2), x = 2)
diff --git a/test/files/run/reflection-scala-annotations.scala b/test/files/run/reflection-scala-annotations.scala
new file mode 100644
index 0000000000..f6a6895ee0
--- /dev/null
+++ b/test/files/run/reflection-scala-annotations.scala
@@ -0,0 +1,16 @@
+import scala.reflect.runtime.universe._
+import scala.annotation._
+
+class sann(x: Int, y: List[Int]) extends StaticAnnotation
+class jann(x: Int, y: Array[Int]) extends ClassfileAnnotation
+
+@sann(1, List(1, 2))
+class S
+
+@jann(y = Array(1, 2), x = 2)
+class J
+
+object Test extends App {
+  println(symbolOf[S].annotations.head.tree)
+  println(symbolOf[J].annotations.head.tree)
+}
diff --git a/test/files/run/reflection-sorted-decls.scala b/test/files/run/reflection-sorted-decls.scala
index 5616e10b3b..8dcb0f3ec6 100644
--- a/test/files/run/reflection-sorted-decls.scala
+++ b/test/files/run/reflection-sorted-decls.scala
@@ -2,7 +2,7 @@ object Test  {
   def main(args: Array[String]) {
     class Foo(val a: Int, val b: Int, val c: Int)
     import scala.reflect.runtime.{currentMirror => cm}
-    val decls = cm.classSymbol(classOf[Foo]).typeSignature.declarations
+    val decls = cm.classSymbol(classOf[Foo]).info.decls
     decls.sorted.toList.filter(!_.isMethod) foreach System.out.println
   }
 }
diff --git a/test/files/run/reflection-sorted-members.scala b/test/files/run/reflection-sorted-members.scala
index a8379234c0..fa028c99c6 100644
--- a/test/files/run/reflection-sorted-members.scala
+++ b/test/files/run/reflection-sorted-members.scala
@@ -5,7 +5,7 @@ object Test  {
     class Bar(val x: Int)
     class Foo(val a: Int, val b: Int, val c: Int) extends Bar(a + b + c) with T1 with T2
     import scala.reflect.runtime.{currentMirror => cm}
-    val members = cm.classSymbol(classOf[Foo]).typeSignature.members
+    val members = cm.classSymbol(classOf[Foo]).info.members
     members.sorted.toList.filter(!_.isMethod) foreach System.out.println
   }
 }
diff --git a/test/files/run/reflection-sync-potpourri.scala b/test/files/run/reflection-sync-potpourri.scala
index 0c96974df7..f65131f18a 100644
--- a/test/files/run/reflection-sync-potpourri.scala
+++ b/test/files/run/reflection-sync-potpourri.scala
@@ -16,7 +16,7 @@ object Test extends App {
     () => typeOf[scala.io.Codec])
   val perms = types.permutations.toList
   def force(lazytpe: () => Type): String = {
-    lazytpe().typeSymbol.typeSignature
+    lazytpe().typeSymbol.info
     lazytpe().toString
   }
   val diceRolls = List.fill(n)(rng.nextInt(perms.length))
diff --git a/test/files/run/reflection-tags.check b/test/files/run/reflection-tags.check
new file mode 100644
index 0000000000..375518e921
--- /dev/null
+++ b/test/files/run/reflection-tags.check
@@ -0,0 +1 @@
+List()
diff --git a/test/files/run/reflection-tags.scala b/test/files/run/reflection-tags.scala
new file mode 100644
index 0000000000..3d7c7b2a0a
--- /dev/null
+++ b/test/files/run/reflection-tags.scala
@@ -0,0 +1,21 @@
+import scala.reflect.runtime.universe._
+import scala.reflect.ClassTag
+
+object Test extends App {
+  var typeMembers = typeOf[scala.reflect.api.Universe].members.filter(sym => sym.isType && !sym.isClass).toList
+  typeMembers = typeMembers.filter(_.name != TypeName("ModifiersCreator")) // type ModifiersCreator = ModifiersExtractor
+  typeMembers = typeMembers.filter(_.name != TypeName("Importer")) // deprecated
+  typeMembers = typeMembers.filter(_.name != TypeName("Internal")) // internal
+  typeMembers = typeMembers.filter(_.name != TypeName("Compat")) // internal
+  typeMembers = typeMembers.filter(_.name != TypeName("BuildApi")) // deprecated
+  val tags = typeOf[scala.reflect.api.Universe].members.filter(sym => sym.isImplicit).toList
+
+  typeMembers.foreach(_.info)
+  tags.foreach(_.info)
+
+  val outliers = typeMembers.filter(tm => !tags.exists(tag => tag.info match {
+    case NullaryMethodType(TypeRef(_, sym, targ :: Nil)) => sym == typeOf[ClassTag[_]].typeSymbol && targ.typeSymbol == tm
+    case _ => false
+  }))
+  println(outliers)
+}
+\ 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 33d4634397..366b5fe270 100644
--- a/test/files/run/reflection-valueclasses-magic.scala
+++ b/test/files/run/reflection-valueclasses-magic.scala
@@ -13,9 +13,9 @@ object Test extends App {
   def key(sym: Symbol) = {
     sym match {
       // initialize parameter symbols
-      case meth: MethodSymbol => meth.paramss.flatten.map(_.typeSignature)
+      case meth: MethodSymbol => meth.paramLists.flatten.map(_.info)
     }
-    sym + ": " + sym.typeSignature
+    sym + ": " + sym.info
   }
 
   def convert(value: Any, tpe: Type) = {
@@ -44,11 +44,11 @@ object Test extends App {
           val realex = scala.ExceptionUtils.unwrapThrowable(ex)
           println(realex.getClass + ": " + realex.getMessage)
       }
-    val meth = tpe.declaration(TermName(method).encodedName.toTermName)
+    val meth = tpe.decl(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) }
-      print(s"testing ${tpe.typeSymbol.name}.$method(${testee.paramss.flatten.map(_.typeSignature).mkString(','.toString)}) with receiver = $receiver and args = ${convertedArgs.map(arg => arg + ' '.toString + arg.getClass).toList}: ")
+      val convertedArgs = args.zipWithIndex.map { case (arg, i) => convert(arg, testee.paramLists.flatten.apply(i).info) }
+      print(s"testing ${tpe.typeSymbol.name}.$method(${testee.paramLists.flatten.map(_.info).mkString(','.toString)}) with receiver = $receiver and args = ${convertedArgs.map(arg => arg + ' '.toString + arg.getClass).toList}: ")
       wrap(cm.reflect(receiver).reflectMethod(testee)(convertedArgs: _*))
     })
   }
diff --git a/test/files/run/reify_newimpl_45.scala b/test/files/run/reify_newimpl_45.scala
index 2a6c68d441..fd8011f468 100644
--- a/test/files/run/reify_newimpl_45.scala
+++ b/test/files/run/reify_newimpl_45.scala
@@ -2,13 +2,13 @@ import scala.reflect.runtime.universe._
 import scala.reflect.runtime.{universe => ru}
 import scala.reflect.runtime.{currentMirror => cm}
 import scala.tools.reflect.ToolBox
+import internal._
 
 object Test extends App {
   class C[T >: Null] {
     val code = reify{val x: T = "2".asInstanceOf[T]; println("ima worx: %s".format(x)); x}
-    println(code.tree.freeTypes)
-    val T = code.tree.freeTypes(0)
-    val tree = code.tree.substituteSymbols(List(T), List(definitions.StringClass))
+    println(freeTypes(code.tree))
+    val tree = substituteSymbols(code.tree, freeTypes(code.tree), List(definitions.StringClass))
     cm.mkToolBox().eval(tree)
   }
 
diff --git a/test/files/run/showdecl.check b/test/files/run/showdecl.check
new file mode 100644
index 0000000000..b8d7f94c57
--- /dev/null
+++ b/test/files/run/showdecl.check
@@ -0,0 +1,34 @@
+compile-time
+uninitialized D: class D extends 
+initialized D: class D extends C
+uninitialized x: val x: <?>
+initialized x: val x: Int
+uninitialized y: lazy val y: <?>
+initialized y: lazy val y: Int
+uninitialized z: def z: <?>
+initialized z: def z: Int
+uninitialized t: def t: <?>
+initialized t: def t[T <: Int](x: D)(y: x.W): Int
+uninitialized W: type W = String
+initialized W: type W = String
+uninitialized C: class C extends 
+initialized C: class C extends D
+uninitialized O: object O
+initialized O: object O
+runtime
+autoinitialized D: class D extends C
+autoinitialized D: class D extends C
+autoinitialized x: val x: Int
+autoinitialized x: val x: Int
+autoinitialized y: lazy val y: Int
+autoinitialized y: lazy val y: Int
+autoinitialized z: def z: Int
+autoinitialized z: def z: Int
+autoinitialized t: def t[T <: Int](x: D)(y: x.W): Int
+autoinitialized t: def t[T <: Int](x: D)(y: x.W): Int
+autoinitialized W: type W = String
+autoinitialized W: type W = String
+autoinitialized C: class C extends D
+autoinitialized C: class C extends D
+autoinitialized O: object O
+autoinitialized O: object O
diff --git a/test/files/run/showdecl/Macros_1.scala b/test/files/run/showdecl/Macros_1.scala
new file mode 100644
index 0000000000..c68dd275de
--- /dev/null
+++ b/test/files/run/showdecl/Macros_1.scala
@@ -0,0 +1,30 @@
+import scala.reflect.macros.whitebox._
+import scala.language.experimental.macros
+
+object Macros {
+  def impl(c: Context) = {
+    var messages = List[String]()
+    def println(msg: String) = messages :+= msg
+
+    import c.universe._
+    def test(sym: Symbol): Unit = {
+      println(s"uninitialized ${sym.name}: ${showDecl(sym)}")
+      sym.info
+      println(s"initialized ${sym.name}: ${showDecl(sym)}")
+    }
+
+    println("compile-time")
+    test(c.mirror.staticClass("D"))
+    test(c.mirror.staticClass("D").info.member(TermName("x")))
+    test(c.mirror.staticClass("D").info.member(TermName("y")))
+    test(c.mirror.staticClass("D").info.member(TermName("z")))
+    test(c.mirror.staticClass("D").info.member(TermName("t")))
+    test(c.mirror.staticClass("D").info.member(TypeName("W")))
+    test(c.mirror.staticClass("D").info.member(TypeName("C")))
+    test(c.mirror.staticClass("D").info.member(TermName("O")))
+
+    q"..${messages.map(msg => q"println($msg)")}"
+  }
+
+  def foo: Any = macro impl
+}
+\ No newline at end of file
diff --git a/test/files/run/showdecl/Test_2.scala b/test/files/run/showdecl/Test_2.scala
new file mode 100644
index 0000000000..6eb64baf34
--- /dev/null
+++ b/test/files/run/showdecl/Test_2.scala
@@ -0,0 +1,32 @@
+import scala.reflect.runtime.universe._
+import scala.reflect.runtime.{currentMirror => cm}
+
+object Test extends App {
+  def test(sym: Symbol): Unit = {
+    println(s"autoinitialized ${sym.name}: ${showDecl(sym)}")
+    sym.info
+    println(s"autoinitialized ${sym.name}: ${showDecl(sym)}")
+  }
+
+  Macros.foo
+  println("runtime")
+  test(symbolOf[D])
+  test(typeOf[D].member(TermName("x")))
+  test(typeOf[D].member(TermName("y")))
+  test(typeOf[D].member(TermName("z")))
+  test(typeOf[D].member(TermName("t")))
+  test(typeOf[D].member(TypeName("W")))
+  test(typeOf[D].member(TypeName("C")))
+  test(typeOf[D].member(TermName("O")))
+}
+
+class C
+class D extends C {
+  val x = 2
+  lazy val y = 3
+  var z = 4
+  def t[T <: Int](x: D)(y: x.W) = 5
+  type W = String
+  class C extends D
+  object O extends C
+}
diff --git a/test/files/run/showraw_tree.check b/test/files/run/showraw_tree.check
index eb74bd8b2b..d8cb1fde02 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(Select(Ident(scala.Predef), TypeName("String")), Select(Ident(scala.Predef), TypeName("String"))))), nme.CONSTRUCTOR), List())
-Apply(Select(New(AppliedTypeTree(Ident(scala.collection.mutable.HashMap), List(Select(Ident(scala.Predef), TypeName("String")), Select(Ident(scala.Predef), TypeName("String"))))), nme.CONSTRUCTOR), List())
+Apply(Select(New(AppliedTypeTree(Ident(scala.collection.immutable.HashMap), List(Select(Ident(scala.Predef), TypeName("String")), Select(Ident(scala.Predef), TypeName("String"))))), termNames.CONSTRUCTOR), List())
+Apply(Select(New(AppliedTypeTree(Ident(scala.collection.mutable.HashMap), List(Select(Ident(scala.Predef), TypeName("String")), Select(Ident(scala.Predef), TypeName("String"))))), termNames.CONSTRUCTOR), List())
diff --git a/test/files/run/showraw_tree_ids.check b/test/files/run/showraw_tree_ids.check
index 7e0149a3c1..d7a7aa5959 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(Select(Ident(scala.Predef#<id>), TypeName("String")), Select(Ident(scala.Predef#<id>), TypeName("String"))))), nme.CONSTRUCTOR), List())
-Apply(Select(New(AppliedTypeTree(Ident(scala.collection.mutable.HashMap#<id>), List(Select(Ident(scala.Predef#<id>), TypeName("String")), Select(Ident(scala.Predef#<id>), TypeName("String"))))), nme.CONSTRUCTOR), List())
+Apply(Select(New(AppliedTypeTree(Ident(scala.collection.immutable.HashMap#<id>), List(Select(Ident(scala.Predef#<id>), TypeName("String")), Select(Ident(scala.Predef#<id>), TypeName("String"))))), termNames.CONSTRUCTOR), List())
+Apply(Select(New(AppliedTypeTree(Ident(scala.collection.mutable.HashMap#<id>), List(Select(Ident(scala.Predef#<id>), TypeName("String")), Select(Ident(scala.Predef#<id>), TypeName("String"))))), termNames.CONSTRUCTOR), List())
diff --git a/test/files/run/showraw_tree_kinds.check b/test/files/run/showraw_tree_kinds.check
index 577f447ae4..85939b02f0 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(Select(Ident(scala.Predef#MOD), TypeName("String")), Select(Ident(scala.Predef#MOD), TypeName("String"))))), nme.CONSTRUCTOR), List())
-Apply(Select(New(AppliedTypeTree(Ident(scala.collection.mutable.HashMap#CLS), List(Select(Ident(scala.Predef#MOD), TypeName("String")), Select(Ident(scala.Predef#MOD), TypeName("String"))))), nme.CONSTRUCTOR), List())
+Apply(Select(New(AppliedTypeTree(Ident(scala.collection.immutable.HashMap#CLS), List(Select(Ident(scala.Predef#MOD), TypeName("String")), Select(Ident(scala.Predef#MOD), TypeName("String"))))), termNames.CONSTRUCTOR), List())
+Apply(Select(New(AppliedTypeTree(Ident(scala.collection.mutable.HashMap#CLS), List(Select(Ident(scala.Predef#MOD), TypeName("String")), Select(Ident(scala.Predef#MOD), TypeName("String"))))), termNames.CONSTRUCTOR), List())
diff --git a/test/files/run/showraw_tree_types_ids.check b/test/files/run/showraw_tree_types_ids.check
index 6a73d77436..75347463cb 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(Select[4](Ident[5](scala.Predef#<id>), TypeName("String")#<id>)), TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>), TypeName("String")#<id>)))))), nme.CONSTRUCTOR#<id>), List())
+Apply[1](Select[2](New[1](TypeTree[1]().setOriginal(AppliedTypeTree(Ident[3](scala.collection.immutable.HashMap#<id>), List(TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>), TypeName("String")#<id>)), TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>), TypeName("String")#<id>)))))), termNames.CONSTRUCTOR#<id>), List())
 [1] TypeRef(ThisType(scala.collection.immutable#<id>), scala.collection.immutable.HashMap#<id>, List(TypeRef(SingleType(ThisType(scala#<id>), scala.Predef#<id>), TypeName("String")#<id>, List()), TypeRef(SingleType(ThisType(scala#<id>), scala.Predef#<id>), TypeName("String")#<id>, List())))
 [2] MethodType(List(), TypeRef(ThisType(scala.collection.immutable#<id>), scala.collection.immutable.HashMap#<id>, List(TypeRef(SingleType(ThisType(scala#<id>), scala.Predef#<id>), TypeName("String")#<id>, List()), TypeRef(SingleType(ThisType(scala#<id>), scala.Predef#<id>), TypeName("String")#<id>, List()))))
 [3] TypeRef(ThisType(scala.collection.immutable#<id>), scala.collection.immutable.HashMap#<id>, List())
 [4] TypeRef(SingleType(ThisType(scala#<id>), scala.Predef#<id>), TypeName("String")#<id>, List())
 [5] SingleType(ThisType(scala#<id>), scala.Predef#<id>)
-Apply[6](Select[7](New[6](TypeTree[6]().setOriginal(AppliedTypeTree(Ident[8](scala.collection.mutable.HashMap#<id>), List(TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>), TypeName("String")#<id>)), TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>), TypeName("String")#<id>)))))), nme.CONSTRUCTOR#<id>), List())
+Apply[6](Select[7](New[6](TypeTree[6]().setOriginal(AppliedTypeTree(Ident[8](scala.collection.mutable.HashMap#<id>), List(TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>), TypeName("String")#<id>)), TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>), TypeName("String")#<id>)))))), termNames.CONSTRUCTOR#<id>), List())
 [4] TypeRef(SingleType(ThisType(scala#<id>), scala.Predef#<id>), TypeName("String")#<id>, List())
 [5] SingleType(ThisType(scala#<id>), scala.Predef#<id>)
 [6] TypeRef(ThisType(scala.collection.mutable#<id>), scala.collection.mutable.HashMap#<id>, List(TypeRef(SingleType(ThisType(scala#<id>), scala.Predef#<id>), TypeName("String")#<id>, List()), TypeRef(SingleType(ThisType(scala#<id>), scala.Predef#<id>), TypeName("String")#<id>, List())))
diff --git a/test/files/run/showraw_tree_types_typed.check b/test/files/run/showraw_tree_types_typed.check
index cf63ecb586..de691e369e 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(Select[4](Ident[5](scala.Predef), TypeName("String"))), TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef), TypeName("String"))))))), nme.CONSTRUCTOR), List())
+Apply[1](Select[2](New[1](TypeTree[1]().setOriginal(AppliedTypeTree(Ident[3](scala.collection.immutable.HashMap), List(TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef), TypeName("String"))), TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef), TypeName("String"))))))), termNames.CONSTRUCTOR), List())
 [1] TypeRef(ThisType(scala.collection.immutable), scala.collection.immutable.HashMap, List(TypeRef(SingleType(ThisType(scala), scala.Predef), TypeName("String"), List()), TypeRef(SingleType(ThisType(scala), scala.Predef), TypeName("String"), List())))
 [2] MethodType(List(), TypeRef(ThisType(scala.collection.immutable), scala.collection.immutable.HashMap, List(TypeRef(SingleType(ThisType(scala), scala.Predef), TypeName("String"), List()), TypeRef(SingleType(ThisType(scala), scala.Predef), TypeName("String"), List()))))
 [3] TypeRef(ThisType(scala.collection.immutable), scala.collection.immutable.HashMap, List())
 [4] TypeRef(SingleType(ThisType(scala), scala.Predef), TypeName("String"), List())
 [5] SingleType(ThisType(scala), scala.Predef)
-Apply[6](Select[7](New[6](TypeTree[6]().setOriginal(AppliedTypeTree(Ident[8](scala.collection.mutable.HashMap), List(TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef), TypeName("String"))), TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef), TypeName("String"))))))), nme.CONSTRUCTOR), List())
+Apply[6](Select[7](New[6](TypeTree[6]().setOriginal(AppliedTypeTree(Ident[8](scala.collection.mutable.HashMap), List(TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef), TypeName("String"))), TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef), TypeName("String"))))))), termNames.CONSTRUCTOR), List())
 [4] TypeRef(SingleType(ThisType(scala), scala.Predef), TypeName("String"), List())
 [5] SingleType(ThisType(scala), scala.Predef)
 [6] TypeRef(ThisType(scala.collection.mutable), scala.collection.mutable.HashMap, List(TypeRef(SingleType(ThisType(scala), scala.Predef), TypeName("String"), List()), TypeRef(SingleType(ThisType(scala), scala.Predef), TypeName("String"), List())))
diff --git a/test/files/run/showraw_tree_types_untyped.check b/test/files/run/showraw_tree_types_untyped.check
index eb74bd8b2b..d8cb1fde02 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(Select(Ident(scala.Predef), TypeName("String")), Select(Ident(scala.Predef), TypeName("String"))))), nme.CONSTRUCTOR), List())
-Apply(Select(New(AppliedTypeTree(Ident(scala.collection.mutable.HashMap), List(Select(Ident(scala.Predef), TypeName("String")), Select(Ident(scala.Predef), TypeName("String"))))), nme.CONSTRUCTOR), List())
+Apply(Select(New(AppliedTypeTree(Ident(scala.collection.immutable.HashMap), List(Select(Ident(scala.Predef), TypeName("String")), Select(Ident(scala.Predef), TypeName("String"))))), termNames.CONSTRUCTOR), List())
+Apply(Select(New(AppliedTypeTree(Ident(scala.collection.mutable.HashMap), List(Select(Ident(scala.Predef), TypeName("String")), Select(Ident(scala.Predef), TypeName("String"))))), termNames.CONSTRUCTOR), List())
diff --git a/test/files/run/showraw_tree_ultimate.check b/test/files/run/showraw_tree_ultimate.check
index 63f72de50b..81efcc05ab 100644
--- a/test/files/run/showraw_tree_ultimate.check
+++ b/test/files/run/showraw_tree_ultimate.check
@@ -1,12 +1,12 @@
-Apply[1](Select[2](New[1](TypeTree[1]().setOriginal(AppliedTypeTree(Ident[3](scala.collection.immutable.HashMap#<id>#CLS), List(TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE)), TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>#MOD), 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(SingleType(ThisType(scala#<id>#PK), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List()), TypeRef(SingleType(ThisType(scala#<id>#PK), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List())))
-[2] MethodType(List(), TypeRef(ThisType(scala.collection.immutable#<id>#PK), scala.collection.immutable.HashMap#<id>#CLS, List(TypeRef(SingleType(ThisType(scala#<id>#PK), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List()), TypeRef(SingleType(ThisType(scala#<id>#PK), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List()))))
-[3] TypeRef(ThisType(scala.collection.immutable#<id>#PK), scala.collection.immutable.HashMap#<id>#CLS, List())
-[4] TypeRef(SingleType(ThisType(scala#<id>#PK), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List())
-[5] SingleType(ThisType(scala#<id>#PK), scala.Predef#<id>#MOD)
-Apply[6](Select[7](New[6](TypeTree[6]().setOriginal(AppliedTypeTree(Ident[8](scala.collection.mutable.HashMap#<id>#CLS), List(TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE)), TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE)))))), nme.CONSTRUCTOR#<id>#CTOR), List())
-[4] TypeRef(SingleType(ThisType(scala#<id>#PK), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List())
-[5] SingleType(ThisType(scala#<id>#PK), scala.Predef#<id>#MOD)
-[6] TypeRef(ThisType(scala.collection.mutable#<id>#PK), scala.collection.mutable.HashMap#<id>#CLS, List(TypeRef(SingleType(ThisType(scala#<id>#PK), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List()), TypeRef(SingleType(ThisType(scala#<id>#PK), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List())))
-[7] MethodType(List(), TypeRef(ThisType(scala.collection.mutable#<id>#PK), scala.collection.mutable.HashMap#<id>#CLS, List(TypeRef(SingleType(ThisType(scala#<id>#PK), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List()), TypeRef(SingleType(ThisType(scala#<id>#PK), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List()))))
-[8] TypeRef(ThisType(scala.collection.mutable#<id>#PK), scala.collection.mutable.HashMap#<id>#CLS, List())
+Apply[1](Select[2](New[1](TypeTree[1]().setOriginal(AppliedTypeTree(Ident[3](scala.collection.immutable.HashMap#<id>#CLS), List(TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE)), TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE)))))), termNames.CONSTRUCTOR#<id>#PCTOR), List())
+[1] TypeRef(ThisType(scala.collection.immutable#<id>#PKC), scala.collection.immutable.HashMap#<id>#CLS, List(TypeRef(SingleType(ThisType(scala#<id>#PKC), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List()), TypeRef(SingleType(ThisType(scala#<id>#PKC), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List())))
+[2] MethodType(List(), TypeRef(ThisType(scala.collection.immutable#<id>#PKC), scala.collection.immutable.HashMap#<id>#CLS, List(TypeRef(SingleType(ThisType(scala#<id>#PKC), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List()), TypeRef(SingleType(ThisType(scala#<id>#PKC), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List()))))
+[3] TypeRef(ThisType(scala.collection.immutable#<id>#PKC), scala.collection.immutable.HashMap#<id>#CLS, List())
+[4] TypeRef(SingleType(ThisType(scala#<id>#PKC), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List())
+[5] SingleType(ThisType(scala#<id>#PKC), scala.Predef#<id>#MOD)
+Apply[6](Select[7](New[6](TypeTree[6]().setOriginal(AppliedTypeTree(Ident[8](scala.collection.mutable.HashMap#<id>#CLS), List(TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE)), TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE)))))), termNames.CONSTRUCTOR#<id>#CTOR), List())
+[4] TypeRef(SingleType(ThisType(scala#<id>#PKC), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List())
+[5] SingleType(ThisType(scala#<id>#PKC), scala.Predef#<id>#MOD)
+[6] TypeRef(ThisType(scala.collection.mutable#<id>#PKC), scala.collection.mutable.HashMap#<id>#CLS, List(TypeRef(SingleType(ThisType(scala#<id>#PKC), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List()), TypeRef(SingleType(ThisType(scala#<id>#PKC), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List())))
+[7] MethodType(List(), TypeRef(ThisType(scala.collection.mutable#<id>#PKC), scala.collection.mutable.HashMap#<id>#CLS, List(TypeRef(SingleType(ThisType(scala#<id>#PKC), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List()), TypeRef(SingleType(ThisType(scala#<id>#PKC), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List()))))
+[8] TypeRef(ThisType(scala.collection.mutable#<id>#PKC), scala.collection.mutable.HashMap#<id>#CLS, List())
diff --git a/test/files/run/t1195-new.scala b/test/files/run/t1195-new.scala
index 4f068c7d42..fcb80082a2 100644
--- a/test/files/run/t1195-new.scala
+++ b/test/files/run/t1195-new.scala
@@ -11,7 +11,7 @@ object Test {
   val g1 = g()
   val h1 = h()
 
-  def m[T: WeakTypeTag](x: T) = println(weakTypeOf[T] + ", underlying = " + weakTypeOf[T].typeSymbol.typeSignature)
+  def m[T: WeakTypeTag](x: T) = println(weakTypeOf[T] + ", underlying = " + weakTypeOf[T].typeSymbol.info)
 
   def main(args: Array[String]): Unit = {
     m(f)
diff --git a/test/files/run/t3425b/Base_1.scala b/test/files/run/t3425b/Base_1.scala
index 5a660a89b2..bdbc124d29 100644
--- a/test/files/run/t3425b/Base_1.scala
+++ b/test/files/run/t3425b/Base_1.scala
@@ -80,7 +80,7 @@ object Gen {
       |    sshow("Reflective Calls", fcalls collect { case (true, n) => n })
       |    // For a good time try printing this - have to fix bugs in
       |    // reflection before that's going to be a good idea
-      |    // println(typeOf[Test.type].typeSymbol.asClass.typeSignature)
+      |    // println(typeOf[Test.type].typeSymbol.asClass.info)
       |  }
       |}
       """.stripMargin.trim
diff --git a/test/files/run/t3425b/Generated_2.scala b/test/files/run/t3425b/Generated_2.scala
index f1699636f6..d08f17e8b2 100644
--- a/test/files/run/t3425b/Generated_2.scala
+++ b/test/files/run/t3425b/Generated_2.scala
@@ -881,6 +881,6 @@ object Test {
     sshow("Reflective Calls", fcalls collect { case (true, n) => n })
     // For a good time try printing this - have to fix bugs in
     // reflection before that's going to be a good idea
-    // println(typeOf[Test.type].typeSymbol.asClass.typeSignature)
+    // println(typeOf[Test.type].typeSymbol.asClass.info)
   }
 }
diff --git a/test/files/run/t5256a.scala b/test/files/run/t5256a.scala
index 84ef97b0d2..c8cea53028 100644
--- a/test/files/run/t5256a.scala
+++ b/test/files/run/t5256a.scala
@@ -7,5 +7,5 @@ object Test extends App {
   val c = cm.classSymbol(classOf[A])
   println(c)
   println(c.fullName)
-  println(c.typeSignature)
+  println(c.info)
 }
 \ No newline at end of file
diff --git a/test/files/run/t5256b.scala b/test/files/run/t5256b.scala
index 0ffab8a668..5cd172e032 100644
--- a/test/files/run/t5256b.scala
+++ b/test/files/run/t5256b.scala
@@ -6,5 +6,5 @@ object Test extends App {
   val c = cm.classSymbol(classOf[A])
   println(c)
   println(c.fullName)
-  println(c.typeSignature)
+  println(c.info)
 }
 \ No newline at end of file
diff --git a/test/files/run/t5256c.scala b/test/files/run/t5256c.scala
index d56215f6eb..66ddd3df5c 100644
--- a/test/files/run/t5256c.scala
+++ b/test/files/run/t5256c.scala
@@ -7,6 +7,6 @@ object Test extends App {
     val c = cm.classSymbol(classOf[A])
     println(c)
     println(c.fullName)
-    println(c.typeSignature)
+    println(c.info)
   }
 }
 \ No newline at end of file
diff --git a/test/files/run/t5256d.check b/test/files/run/t5256d.check
index 5705acf20a..d42d234386 100644
--- a/test/files/run/t5256d.check
+++ b/test/files/run/t5256d.check
@@ -19,7 +19,7 @@ class A
 scala> println(c.fullName)
 $line8.$read.$iw.$iw.$iw.$iw.A
 
-scala> println(c.typeSignature)
+scala> println(c.info)
 scala.AnyRef {
   def <init>(): A
   def foo: scala.Nothing
diff --git a/test/files/run/t5256d.scala b/test/files/run/t5256d.scala
index 24ac1eb316..5aa26071c0 100644
--- a/test/files/run/t5256d.scala
+++ b/test/files/run/t5256d.scala
@@ -8,6 +8,6 @@ class A { def foo = ??? }
 val c = cm.classSymbol(classOf[A])
 println(c)
 println(c.fullName)
-println(c.typeSignature)
+println(c.info)
   """
 }
 \ No newline at end of file
diff --git a/test/files/run/t5256e.scala b/test/files/run/t5256e.scala
index f83546f2c0..2f57ea68b9 100644
--- a/test/files/run/t5256e.scala
+++ b/test/files/run/t5256e.scala
@@ -6,5 +6,5 @@ object Test extends App {
   val c = cm.classSymbol(classOf[C#A])
   println(c)
   println(c.fullName)
-  println(c.typeSignature)
+  println(c.info)
 }
 \ No newline at end of file
diff --git a/test/files/run/t5256f.scala b/test/files/run/t5256f.scala
index 80c7ad8018..1de2592416 100644
--- a/test/files/run/t5256f.scala
+++ b/test/files/run/t5256f.scala
@@ -7,7 +7,7 @@ object Test extends App {
   val c1 = cm.classSymbol(classOf[A1])
   println(c1)
   println(c1.fullName)
-  println(c1.typeSignature)
+  println(c1.info)
 
   new Test
 }
@@ -18,5 +18,5 @@ class Test {
   val c2 = cm.classSymbol(classOf[A2])
   println(c2)
   println(c2.fullName)
-  println(c2.typeSignature)
+  println(c2.info)
 }
diff --git a/test/files/run/t5256g.scala b/test/files/run/t5256g.scala
index 358c18601a..2d4c1b5068 100644
--- a/test/files/run/t5256g.scala
+++ b/test/files/run/t5256g.scala
@@ -9,5 +9,5 @@ object Test extends App {
   val c = cm.classSymbol(mutant.getClass)
   println(c)
   println(c.fullName)
-  println(c.typeSignature)
+  println(c.info)
 }
diff --git a/test/files/run/t5256h.scala b/test/files/run/t5256h.scala
index fd4ffd9b12..f58aa6dbe7 100644
--- a/test/files/run/t5256h.scala
+++ b/test/files/run/t5256h.scala
@@ -6,5 +6,5 @@ object Test extends App {
   val c = cm.classSymbol(mutant.getClass)
   println(c)
   println(c.fullName)
-  println(c.typeSignature)
+  println(c.info)
 }
diff --git a/test/files/run/t5923a/Macros_1.scala b/test/files/run/t5923a/Macros_1.scala
index 9aa7a02708..9050fd4b11 100644
--- a/test/files/run/t5923a/Macros_1.scala
+++ b/test/files/run/t5923a/Macros_1.scala
@@ -9,6 +9,7 @@ object C {
 object Macros {
   def impl[T](c: Context)(ttag: c.WeakTypeTag[T]) = {
     import c.universe._
+    import internal._
     val ttag0 = ttag;
     {
       // When we're expanding implicitly[C[Nothing]], the type inferencer will see
@@ -43,7 +44,7 @@ object Macros {
       implicit def ttag: WeakTypeTag[T] = {
         val tpe = ttag0.tpe
         val sym = tpe.typeSymbol.asType
-        if (sym.isParameter && !sym.isSkolem) TypeTag.Nothing.asInstanceOf[TypeTag[T]]
+        if (sym.isParameter && !isSkolem(sym)) TypeTag.Nothing.asInstanceOf[TypeTag[T]]
         else ttag0
       }
       reify(C[T](c.Expr[String](Literal(Constant(weakTypeOf[T].toString))).splice))
diff --git a/test/files/run/t6221/Macros_1.scala b/test/files/run/t6221/Macros_1.scala
index b5c28360fa..0aeaa00c86 100644
--- a/test/files/run/t6221/Macros_1.scala
+++ b/test/files/run/t6221/Macros_1.scala
@@ -14,7 +14,8 @@ object ReflectiveClosure {
 object Macros {
   def reflectiveClosureImpl[A, B](c: Context)(f: c.Expr[A => B]): c.Expr[ReflectiveClosure[A, B]] = {
     import c.universe._
-    val u = treeBuild.mkRuntimeUniverseRef
+    import internal._
+    val u = gen.mkRuntimeUniverseRef
     val m = EmptyTree
     val tree = c.Expr[scala.reflect.runtime.universe.Tree](Select(c.reifyTree(u, m, f.tree), newTermName("tree")))
     c.universe.reify(new ReflectiveClosure(tree.splice, f.splice))
diff --git a/test/files/run/t6240-universe-code-gen.scala b/test/files/run/t6240-universe-code-gen.scala
index 84691639bd..9f7061ee1b 100644
--- a/test/files/run/t6240-universe-code-gen.scala
+++ b/test/files/run/t6240-universe-code-gen.scala
@@ -53,7 +53,7 @@ object Test extends App {
         |    TypeTag.Null.tpe
         |
         |${forceCode("this", JavaUniverseTpe)}
-        |${forceCode("definitions", DefinitionsModule.typeSignature)}
+        |${forceCode("definitions", DefinitionsModule.info)}
         |${forceCode("refChecks", typeOf[scala.reflect.internal.transform.RefChecks])}
         |${forceCode("uncurry", typeOf[scala.reflect.internal.transform.UnCurry])}
         |${forceCode("erasure", typeOf[scala.reflect.internal.transform.Erasure])}
diff --git a/test/files/run/t6323b.scala b/test/files/run/t6323b.scala
index f530ac3ecc..50d0900c7f 100644
--- a/test/files/run/t6323b.scala
+++ b/test/files/run/t6323b.scala
@@ -10,7 +10,7 @@ object Test extends App {
       val lookAtMe = m.reflect(Test("a",List(5)))
       val value = u.weakTypeOf[Test]
       val members = value.members
-      val member = value.members.filter(_.name.encoded == "a")
+      val member = value.members.filter(_.name.encodedName == TermName("a"))
       val aAccessor = lookAtMe.reflectMethod(member.head.asMethod)
       val thisShouldBeA = aAccessor.apply()
       println(thisShouldBeA)
diff --git a/test/files/run/t6379.check b/test/files/run/t6379.check
new file mode 100644
index 0000000000..3e5dfec623
--- /dev/null
+++ b/test/files/run/t6379.check
@@ -0,0 +1,14 @@
+compile-time
+uninitialized close: List(class IOException)
+initialized close: List(class IOException)
+uninitialized productElement: List(class IndexOutOfBoundsException)
+initialized productElement: List(class IndexOutOfBoundsException)
+uninitialized read: List(class IOException)
+initialized read: List(class IOException)
+runtime
+uninitialized close: List(class IOException)
+initialized close: List(class IOException)
+uninitialized productElement: List(class IndexOutOfBoundsException)
+initialized productElement: List(class IndexOutOfBoundsException)
+uninitialized read: List(class IOException)
+initialized read: List(class IOException)
diff --git a/test/files/run/t6379/Macros_1.scala b/test/files/run/t6379/Macros_1.scala
new file mode 100644
index 0000000000..4f3daf4978
--- /dev/null
+++ b/test/files/run/t6379/Macros_1.scala
@@ -0,0 +1,26 @@
+import scala.reflect.macros.whitebox._
+import scala.language.experimental.macros
+import java.io._
+
+object Macros {
+  def impl(c: Context) = {
+    var messages = List[String]()
+    def println(msg: String) = messages :+= msg
+
+    import c.universe._
+    def test(sym: MethodSymbol): Unit = {
+      println(s"uninitialized ${sym.name}: ${sym.exceptions}")
+      sym.info
+      println(s"initialized ${sym.name}: ${sym.exceptions}")
+    }
+
+    println("compile-time")
+    test(typeOf[Closeable].declaration(TermName("close")).asMethod)
+    test(typeOf[Product1[_]].declaration(TermName("productElement")).asMethod)
+    test(c.mirror.staticClass("Reader").info.decl(TermName("read")).asMethod)
+
+    q"..${messages.map(msg => q"println($msg)")}"
+  }
+
+  def foo: Any = macro impl
+}
+\ No newline at end of file
diff --git a/test/files/run/t6379/Test_2.scala b/test/files/run/t6379/Test_2.scala
new file mode 100644
index 0000000000..8e9c994654
--- /dev/null
+++ b/test/files/run/t6379/Test_2.scala
@@ -0,0 +1,22 @@
+import java.io._
+import scala.reflect.runtime.universe._
+
+class Reader(fname: String) {
+  private val in = new BufferedReader(new FileReader(fname))
+  @throws[IOException]("if the file doesn't exist")
+  def read() = in.read()
+}
+
+object Test extends App {
+  def test(sym: MethodSymbol): Unit = {
+    println(s"uninitialized ${sym.name}: ${sym.exceptions}")
+    sym.info
+    println(s"initialized ${sym.name}: ${sym.exceptions}")
+  }
+
+  Macros.foo
+  println("runtime")
+  test(typeOf[Closeable].decl(TermName("close")).asMethod)
+  test(typeOf[Product1[_]].decl(TermName("productElement")).asMethod)
+  test(typeOf[Reader].decl(TermName("read")).asMethod)
+}
diff --git a/test/files/run/t6392b.check b/test/files/run/t6392b.check
index c2cc103373..83d8fe20c1 100644
--- a/test/files/run/t6392b.check
+++ b/test/files/run/t6392b.check
@@ -1 +1 @@
-ModuleDef(Modifiers(), TermName("C")#MOD, Template(List(Select(Ident(scala#PK), TypeName("AnyRef")#TPE)), noSelfType, List(DefDef(Modifiers(), nme.CONSTRUCTOR#PCTOR, List(), List(List()), TypeTree(), Block(List(Apply(Select(Super(This(TypeName("C")), tpnme.EMPTY), nme.CONSTRUCTOR#PCTOR), List())), Literal(Constant(())))))))
+ModuleDef(Modifiers(), TermName("C")#MOD, Template(List(Select(Ident(scala#PK), TypeName("AnyRef")#TPE)), noSelfType, List(DefDef(Modifiers(), termNames.CONSTRUCTOR#PCTOR, List(), List(List()), TypeTree(), Block(List(Apply(Select(Super(This(TypeName("C")), typeNames.EMPTY), termNames.CONSTRUCTOR#CTOR), List())), Literal(Constant(())))))))
diff --git a/test/files/run/t6394b/Macros_1.scala b/test/files/run/t6394b/Macros_1.scala
index 53215e63aa..1a747816e3 100644
--- a/test/files/run/t6394b/Macros_1.scala
+++ b/test/files/run/t6394b/Macros_1.scala
@@ -4,7 +4,7 @@ object Macros {
   def impl(c:Context): c.Expr[Any] = {
     import c.universe._
 
-    val selfTree = This(tpnme.EMPTY)
+    val selfTree = This(typeNames.EMPTY)
     c.Expr[AnyRef](selfTree)
   }
 
diff --git a/test/files/run/t6411a.scala b/test/files/run/t6411a.scala
index 3bfeac2890..46c88d9294 100644
--- a/test/files/run/t6411a.scala
+++ b/test/files/run/t6411a.scala
@@ -32,7 +32,7 @@ object a {
 object Test extends App {
   def test(methName: String, arg: Any) = {
     val moduleA = cm.reflect(a)
-    val msym = moduleA.symbol.typeSignature.declaration(TermName(methName)).asMethod
+    val msym = moduleA.symbol.info.decl(TermName(methName)).asMethod
     println(s"meth = $msym")
     val mmirror = moduleA.reflectMethod(msym)
     val mresult =
diff --git a/test/files/run/t6411b.scala b/test/files/run/t6411b.scala
index af30108826..b5c3bf8732 100644
--- a/test/files/run/t6411b.scala
+++ b/test/files/run/t6411b.scala
@@ -6,7 +6,7 @@ case class Bar(foo: Foo)
 object Test extends App {
   val mirror = runtimeMirror(getClass.getClassLoader)
   val cm = mirror.reflectClass(typeOf[Bar].typeSymbol.asClass)
-  val ctor = typeOf[Bar].declaration(nme.CONSTRUCTOR).asMethod
+  val ctor = typeOf[Bar].decl(termNames.CONSTRUCTOR).asMethod
   val ctorm = cm.reflectConstructor(ctor)
   println(ctorm(Foo(3)))
 }
 \ No newline at end of file
diff --git a/test/files/run/t6439.check b/test/files/run/t6439.check
index f804fa75f4..f8d5b3a8cd 100644
--- a/test/files/run/t6439.check
+++ b/test/files/run/t6439.check
@@ -59,8 +59,8 @@ scala> :power
 scala> object lookup {
   import intp._
   def apply(name: String): Symbol       = types(name) orElse terms(name)
-  def types(name: String): Symbol       = replScope lookup (name: TypeName) orElse getClassIfDefined(name)
-  def terms(name: String): Symbol       = replScope lookup (name: TermName) orElse getModuleIfDefined(name)
+  def types(name: String): Symbol       = replScope lookup (TypeName(name)) orElse getClassIfDefined(name)
+  def terms(name: String): Symbol       = replScope lookup (TermName(name)) orElse getModuleIfDefined(name)
   def types[T: global.TypeTag] : Symbol = typeOf[T].typeSymbol
   def terms[T: global.TypeTag] : Symbol = typeOf[T].termSymbol
   def apply[T: global.TypeTag] : Symbol = typeOf[T].typeSymbol
diff --git a/test/files/run/t6439.scala b/test/files/run/t6439.scala
index 175a1d134f..53155a71a1 100644
--- a/test/files/run/t6439.scala
+++ b/test/files/run/t6439.scala
@@ -21,8 +21,8 @@ type F = Int // no warn
 object lookup {
   import intp._
   def apply(name: String): Symbol       = types(name) orElse terms(name)
-  def types(name: String): Symbol       = replScope lookup (name: TypeName) orElse getClassIfDefined(name)
-  def terms(name: String): Symbol       = replScope lookup (name: TermName) orElse getModuleIfDefined(name)
+  def types(name: String): Symbol       = replScope lookup (TypeName(name)) orElse getClassIfDefined(name)
+  def terms(name: String): Symbol       = replScope lookup (TermName(name)) orElse getModuleIfDefined(name)
   def types[T: global.TypeTag] : Symbol = typeOf[T].typeSymbol
   def terms[T: global.TypeTag] : Symbol = typeOf[T].termSymbol
   def apply[T: global.TypeTag] : Symbol = typeOf[T].typeSymbol
diff --git a/test/files/run/t6548/Test_2.scala b/test/files/run/t6548/Test_2.scala
index 7200259d36..cb5abd9c39 100644
--- a/test/files/run/t6548/Test_2.scala
+++ b/test/files/run/t6548/Test_2.scala
@@ -8,5 +8,5 @@ class Bean {
 
 object Test extends App {
   println(cm.staticClass("Bean").isCaseClass)
-  println(typeOf[Bean].declaration(TermName("value")).annotations)
+  println(typeOf[Bean].decl(TermName("value")).annotations)
 }
diff --git a/test/files/run/t6591_2.check b/test/files/run/t6591_2.check
index 8c972ef920..a2930b1749 100644
--- a/test/files/run/t6591_2.check
+++ b/test/files/run/t6591_2.check
@@ -1 +1 @@
-Block(List(ValDef(Modifiers(), TermName("v"), SelectFromTypeTree(Ident(A), TypeName("I")), Select(Apply(Select(New(Ident(A)), nme.CONSTRUCTOR), List()), TermName("impl")))), Ident(TermName("v")))
+Block(List(ValDef(Modifiers(), TermName("v"), SelectFromTypeTree(Ident(A), TypeName("I")), Select(Apply(Select(New(Ident(A)), termNames.CONSTRUCTOR), List()), TermName("impl")))), Ident(TermName("v")))
diff --git a/test/files/run/t6591_3.check b/test/files/run/t6591_3.check
index f4592adce9..362aafd11c 100644
--- a/test/files/run/t6591_3.check
+++ b/test/files/run/t6591_3.check
@@ -1 +1 @@
-Block(List(ValDef(Modifiers(), TermName("v"), Select(This(TypeName("A")), TypeName("I")), Apply(Select(New(Select(This(TypeName("A")), TypeName("I"))), nme.CONSTRUCTOR), List()))), Ident(TermName("v")))
+Block(List(ValDef(Modifiers(), TermName("v"), Select(This(TypeName("A")), TypeName("I")), Apply(Select(New(Select(This(TypeName("A")), TypeName("I"))), termNames.CONSTRUCTOR), List()))), Ident(TermName("v")))
diff --git a/test/files/run/t6591_7.scala b/test/files/run/t6591_7.scala
index b6c8d399a0..914842e613 100644
--- a/test/files/run/t6591_7.scala
+++ b/test/files/run/t6591_7.scala
@@ -1,5 +1,6 @@
 import scala.reflect.runtime.universe._
 import scala.tools.reflect.Eval
+import internal._
 
 object Test extends App {
   locally {
@@ -13,10 +14,10 @@ object Test extends App {
         // blocked by SI-7103, though it's not the focus of this test
         // therefore I'm just commenting out the evaluation
         // println(expr.eval)
-        expr.tree.freeTerms foreach (ft => {
+        freeTerms(expr.tree) foreach (ft => {
           // blocked by SI-7104, though it's not the focus of this test
-          // therefore I'm just commenting out the call to typeSignature
-          // println(s"name = ${ft.name}, sig = ${ft.typeSignature}, stable = ${ft.isStable}")
+          // therefore I'm just commenting out the call to info
+          // println(s"name = ${ft.name}, sig = ${ft.info}, stable = ${ft.isStable}")
           println(s"name = ${ft.name}, stable = ${ft.isStable}")
         })
       }
diff --git a/test/files/run/t6608.scala b/test/files/run/t6608.scala
index 2f956bfb35..2ba979649b 100644
--- a/test/files/run/t6608.scala
+++ b/test/files/run/t6608.scala
@@ -7,7 +7,7 @@ class C {
 
 object Test extends App {
   import universe._
-  val access = typeOf[C].declarations
+  val access = typeOf[C].decls
     .toList
     .filter(_.name.toString.endsWith("yyy"))
     .map(x => (x.name, x.isPrivate))
diff --git a/test/files/run/t6732.check b/test/files/run/t6732.check
new file mode 100644
index 0000000000..016c6e50c0
--- /dev/null
+++ b/test/files/run/t6732.check
@@ -0,0 +1,4 @@
+scala#PK: true, false, true, false
+scala#PKC: false, true, true, true
+scala.collection.immutable.List#MOD: true, false, false, false
+scala.collection.immutable.List#MODC: false, true, false, false
diff --git a/test/files/run/t6732.scala b/test/files/run/t6732.scala
new file mode 100644
index 0000000000..fdc1ab04e6
--- /dev/null
+++ b/test/files/run/t6732.scala
@@ -0,0 +1,12 @@
+import scala.reflect.runtime.universe._
+import definitions._
+
+object Test extends App {
+  def test(sym: Symbol): Unit = {
+    println(s"${showRaw(sym, printKinds = true)}: ${sym.isModule}, ${sym.isModuleClass}, ${sym.isPackage}, ${sym.isPackageClass}")
+  }
+  test(ScalaPackage)
+  test(ScalaPackageClass)
+  test(ListModule)
+  test(ListModule.moduleClass)
+}
+\ No newline at end of file
diff --git a/test/files/run/t6733.check b/test/files/run/t6733.check
new file mode 100644
index 0000000000..aeb595fbfd
--- /dev/null
+++ b/test/files/run/t6733.check
@@ -0,0 +1,27 @@
+method $init$: isPrivateThis = false, isProtectedThis = false
+value pri1a: isPrivateThis = true, isProtectedThis = false
+method pri2a: isPrivateThis = true, isProtectedThis = false
+variable pri3a: isPrivateThis = true, isProtectedThis = false
+value pri4a: isPrivateThis = true, isProtectedThis = false
+lazy value pri4a: isPrivateThis = true, isProtectedThis = false
+type Pri5a: isPrivateThis = true, isProtectedThis = false
+class Pri6: isPrivateThis = true, isProtectedThis = false
+trait Pri7: isPrivateThis = true, isProtectedThis = false
+object Pri8: isPrivateThis = true, isProtectedThis = false
+value pro1a: isPrivateThis = false, isProtectedThis = true
+value pro1a: isPrivateThis = true, isProtectedThis = false
+value pro1b: isPrivateThis = false, isProtectedThis = true
+method pro2a: isPrivateThis = false, isProtectedThis = true
+method pro2b: isPrivateThis = false, isProtectedThis = true
+method pro3a: isPrivateThis = false, isProtectedThis = true
+method pro3a_=: isPrivateThis = false, isProtectedThis = true
+variable pro3a: isPrivateThis = true, isProtectedThis = false
+method pro3b: isPrivateThis = false, isProtectedThis = true
+method pro3b_=: isPrivateThis = false, isProtectedThis = true
+value pro4a: isPrivateThis = false, isProtectedThis = true
+lazy value pro4a: isPrivateThis = true, isProtectedThis = false
+type Pro5a: isPrivateThis = false, isProtectedThis = true
+type Pro5b: isPrivateThis = false, isProtectedThis = true
+class Pro6: isPrivateThis = false, isProtectedThis = true
+trait Pro7: isPrivateThis = false, isProtectedThis = true
+object Pro8: isPrivateThis = false, isProtectedThis = true
diff --git a/test/files/run/t6733.scala b/test/files/run/t6733.scala
new file mode 100644
index 0000000000..df1946a9d5
--- /dev/null
+++ b/test/files/run/t6733.scala
@@ -0,0 +1,35 @@
+import scala.reflect.runtime.universe._
+
+trait Foo {
+  private[this] val pri1a = 0
+  // private[this] val pri1b: Int
+  private[this] def pri2a = 1
+  // private[this] def pri2b: Int
+  private[this] var pri3a = 0
+  // private[this] var pri3b: Int
+  private[this] lazy val pri4a = 0
+  // private[this] lazy val pri4b: Int
+  private[this] type Pri5a = Int
+  // private[this] type Pri5b <: Int
+  private[this] class Pri6
+  private[this] trait Pri7
+  private[this] object Pri8
+
+  protected[this] val pro1a = 0
+  protected[this] val pro1b: Int
+  protected[this] def pro2a = 1
+  protected[this] def pro2b: Int
+  protected[this] var pro3a = 0
+  protected[this] var pro3b: Int
+  protected[this] lazy val pro4a = 0
+  // protected[this] lazy val pro4b: Int
+  protected[this] type Pro5a = Int
+  protected[this] type Pro5b <: Int
+  protected[this] class Pro6
+  protected[this] trait Pro7
+  protected[this] object Pro8
+}
+
+object Test extends App {
+  typeOf[Foo].decls.sorted.foreach(m => println(s"$m: isPrivateThis = ${m.isPrivateThis}, isProtectedThis = ${m.isProtectedThis}"))
+}
+\ No newline at end of file
diff --git a/test/files/run/t6745-2.scala b/test/files/run/t6745-2.scala
index 31ecd42bd1..5afa65d28a 100644
--- a/test/files/run/t6745-2.scala
+++ b/test/files/run/t6745-2.scala
@@ -16,7 +16,7 @@ package context {
   def check(source: String, unit: global.CompilationUnit) = {
     val context: Context = global.analyzer.rootContext(unit)
     val importInfo: ImportInfo = context.imports.head // Predef._
-    val importedSym = importInfo.importedSymbol(nme.CONSTRUCTOR)
+    val importedSym = importInfo.importedSymbol(termNames.CONSTRUCTOR)
     assert(importedSym == NoSymbol, importedSym) // was "constructor Predef"
   }
 }
diff --git a/test/files/run/t6814.check b/test/files/run/t6814.check
new file mode 100644
index 0000000000..97ada77202
--- /dev/null
+++ b/test/files/run/t6814.check
@@ -0,0 +1,7 @@
+List[Int]
+scala.collection.immutable.List.type
+object java.lang.RuntimeException is not a value
+List[Int]
+List
+scala.collection.immutable.List.type
+scala.collection.immutable.List.type does not take parameters
diff --git a/test/files/run/t6814/Macros_1.scala b/test/files/run/t6814/Macros_1.scala
new file mode 100644
index 0000000000..0257f451d6
--- /dev/null
+++ b/test/files/run/t6814/Macros_1.scala
@@ -0,0 +1,24 @@
+import scala.language.experimental.macros
+import scala.reflect.macros.blackbox.Context
+
+object Macros {
+  def impl(c: Context) = {
+    import c.universe._
+
+    def test(tree: Tree, mode: c.TypecheckMode): String = {
+      try c.typecheck(tree, mode, silent = false).tpe.toString
+      catch { case c.TypecheckException(_, msg) => msg }
+    }
+
+    q"""
+      println(${test(q"List(1, 2)", c.TERMmode)})
+      println(${test(q"List", c.TERMmode)})
+      println(${test(q"RuntimeException", c.TERMmode)})
+      println(${test(tq"List[Int]", c.TYPEmode)})
+      println(${test(tq"List", c.TYPEmode)})
+      println(${test(q"List", c.TYPEmode)})
+      println(${test(q"List(1, 2)", c.TYPEmode)})
+    """
+  }
+  def foo: Unit = macro impl
+}
+\ No newline at end of file
diff --git a/test/files/run/t6814/Test_2.scala b/test/files/run/t6814/Test_2.scala
new file mode 100644
index 0000000000..acfddae942
--- /dev/null
+++ b/test/files/run/t6814/Test_2.scala
@@ -0,0 +1,3 @@
+object Test extends App {
+  Macros.foo
+}
+\ No newline at end of file
diff --git a/test/files/run/t6860.scala b/test/files/run/t6860.scala
index 2dcc2a67f7..c2f8db02c2 100644
--- a/test/files/run/t6860.scala
+++ b/test/files/run/t6860.scala
@@ -12,8 +12,8 @@ object Test {
   import scala.reflect.runtime.universe._
 
   def main(args: Array[String]): Unit = {
-    val members = typeOf[A].declarations.toList
-    val tpes = members flatMap (_.annotations) map (_.tpe)
+    val members = typeOf[A].decls.toList
+    val tpes = members flatMap (_.annotations) map (_.tree.tpe)
 
     tpes.map(_.toString).sorted foreach println
   }
diff --git a/test/files/run/t6989/Test_2.scala b/test/files/run/t6989/Test_2.scala
index e48e82422d..932a369f6c 100644
--- a/test/files/run/t6989/Test_2.scala
+++ b/test/files/run/t6989/Test_2.scala
@@ -11,20 +11,20 @@ import scala.reflect.runtime.universe._
 package object foo {
   def testAll(): Unit = {
     test(typeOf[foo.PackagePrivateJavaClass].typeSymbol)
-    test(typeOf[foo.PackagePrivateJavaClass].typeSymbol.companionSymbol)
+    test(typeOf[foo.PackagePrivateJavaClass].typeSymbol.companion)
     test(typeOf[foo.JavaClass_1].typeSymbol)
-    test(typeOf[foo.JavaClass_1].typeSymbol.companionSymbol)
+    test(typeOf[foo.JavaClass_1].typeSymbol.companion)
   }
 
   def test(sym: Symbol): Unit = {
     printSymbolDetails(sym)
     if (sym.isClass || sym.isModule) {
-      sym.typeSignature.declarations.toList.sortBy(_.name.toString) foreach test
+      sym.info.decls.toList.sortBy(_.name.toString) foreach test
     }
   }
 
   def printSymbolDetails(sym: Symbol): Unit = {
-    def stableSignature(sym: Symbol) = sym.typeSignature match {
+    def stableSignature(sym: Symbol) = sym.info match {
       case ClassInfoType(_, _, _) => "ClassInfoType(...)"
       case tpe => tpe.toString
     }
diff --git a/test/files/run/t6992/Macros_1.scala b/test/files/run/t6992/Macros_1.scala
index d101efdda3..f578f2b3c0 100644
--- a/test/files/run/t6992/Macros_1.scala
+++ b/test/files/run/t6992/Macros_1.scala
@@ -13,12 +13,12 @@ object Macros {
       ClassDef(
         Modifiers(Flag.FINAL), anon, Nil, Template(
           Nil, noSelfType, List(
-            DefDef(Modifiers(), nme.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(pendingSuperCall), Literal(Constant(())))),
+            DefDef(Modifiers(), termNames.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(pendingSuperCall), Literal(Constant(())))),
             TypeDef(Modifiers(), TypeName(lit), Nil, TypeTree(typeOf[Int]))
           )
         )
       ),
-      Apply(Select(New(Ident(anon)), nme.CONSTRUCTOR), Nil)
+      Apply(Select(New(Ident(anon)), termNames.CONSTRUCTOR), Nil)
     ))
   }
 
@@ -33,7 +33,7 @@ object Macros {
       ClassDef(
         Modifiers(Flag.FINAL), anon, Nil, Template(
           Nil, noSelfType, List(
-            DefDef(Modifiers(), nme.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(pendingSuperCall), Literal(Constant(())))),
+            DefDef(Modifiers(), termNames.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(pendingSuperCall), Literal(Constant(())))),
             DefDef(
               Modifiers(), TermName(lit), Nil, Nil, TypeTree(),
               c.literal(42).tree
@@ -41,7 +41,7 @@ object Macros {
           )
         )
       ),
-      Apply(Select(New(Ident(anon)), nme.CONSTRUCTOR), Nil)
+      Apply(Select(New(Ident(anon)), termNames.CONSTRUCTOR), Nil)
     ))
   }
 
@@ -57,7 +57,7 @@ object Macros {
       ClassDef(
         Modifiers(), anon, Nil, Template(
           Nil, emptyValDef, List(
-            DefDef(Modifiers(), nme.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(pendingSuperCall), Literal(Constant(())))),
+            DefDef(Modifiers(), termNames.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(pendingSuperCall), Literal(Constant(())))),
             DefDef(
               Modifiers(), TermName(lit), Nil, Nil, TypeTree(),
               c.literal(42).tree
@@ -67,9 +67,9 @@ object Macros {
       ),
       ClassDef(
         Modifiers(Flag.FINAL), wrapper, Nil,
-        Template(Ident(anon) :: Nil, noSelfType, DefDef(Modifiers(), nme.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(pendingSuperCall), Literal(Constant(())))) :: Nil)
+        Template(Ident(anon) :: Nil, noSelfType, DefDef(Modifiers(), termNames.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(pendingSuperCall), Literal(Constant(())))) :: Nil)
       ),
-      Apply(Select(New(Ident(wrapper)), nme.CONSTRUCTOR), Nil)
+      Apply(Select(New(Ident(wrapper)), termNames.CONSTRUCTOR), Nil)
     ))
   }
 }
 \ No newline at end of file
diff --git a/test/files/run/t6992/Test_2.scala b/test/files/run/t6992/Test_2.scala
index 1ed8958d38..2399bf81df 100644
--- a/test/files/run/t6992/Test_2.scala
+++ b/test/files/run/t6992/Test_2.scala
@@ -4,7 +4,7 @@ object Test extends App {
   val foo = Macros.foo("T")
   val ttpe = scala.reflect.runtime.universe.weakTypeOf[foo.T]
   println(ttpe)
-  println(ttpe.typeSymbol.typeSignature)
+  println(ttpe.typeSymbol.info)
 
   val bar = Macros.bar("test")
   println(bar.test)
diff --git a/test/files/run/t7008-scala-defined/Impls_Macros_2.scala b/test/files/run/t7008-scala-defined/Impls_Macros_2.scala
index 7049ed6490..330db8da75 100644
--- a/test/files/run/t7008-scala-defined/Impls_Macros_2.scala
+++ b/test/files/run/t7008-scala-defined/Impls_Macros_2.scala
@@ -4,7 +4,7 @@ import scala.reflect.macros.blackbox.Context
 object Macros {
   def impl(c: Context) = {
     import c.universe._
-    val decls = c.typeOf[ScalaClassWithCheckedExceptions_1[_]].declarations.toList
+    val decls = c.typeOf[ScalaClassWithCheckedExceptions_1[_]].decls.toList
     val s = decls.sortBy(_.name.toString).map(decl => (s"${decl.name}: ${decl.annotations}")).mkString(scala.compat.Platform.EOL)
     reify(println(c.Expr[String](Literal(Constant(s))).splice))
   }
diff --git a/test/files/run/t7008-scala-defined/Test_3.scala b/test/files/run/t7008-scala-defined/Test_3.scala
index 03bb79d311..ee7b9d9cde 100644
--- a/test/files/run/t7008-scala-defined/Test_3.scala
+++ b/test/files/run/t7008-scala-defined/Test_3.scala
@@ -4,6 +4,6 @@ object Test extends App {
   Macros.foo
   println("=============")
 
-  val decls = typeOf[ScalaClassWithCheckedExceptions_1[_]].declarations.toList
+  val decls = typeOf[ScalaClassWithCheckedExceptions_1[_]].decls.toList
   decls sortBy (_.name.toString) foreach (decl => println(s"${decl.name}: ${decl.annotations}"))
 }
 \ No newline at end of file
diff --git a/test/files/run/t7008/Impls_Macros_2.scala b/test/files/run/t7008/Impls_Macros_2.scala
index 9dfa66a20a..3c6fe116ce 100644
--- a/test/files/run/t7008/Impls_Macros_2.scala
+++ b/test/files/run/t7008/Impls_Macros_2.scala
@@ -4,7 +4,7 @@ import scala.reflect.macros.blackbox.Context
 object Macros {
   def impl(c: Context) = {
     import c.universe._
-    val decls = c.typeOf[JavaClassWithCheckedExceptions_1[_]].declarations.toList
+    val decls = c.typeOf[JavaClassWithCheckedExceptions_1[_]].decls.toList
     val s = decls.sortBy(_.name.toString).map(decl => (s"${decl.name}: ${decl.annotations}")).mkString(scala.compat.Platform.EOL)
     reify(println(c.Expr[String](Literal(Constant(s))).splice))
   }
diff --git a/test/files/run/t7008/Test_3.scala b/test/files/run/t7008/Test_3.scala
index b2961a829e..99db05e810 100644
--- a/test/files/run/t7008/Test_3.scala
+++ b/test/files/run/t7008/Test_3.scala
@@ -4,6 +4,6 @@ object Test extends App {
   Macros.foo
   println("=============")
 
-  val decls = typeOf[JavaClassWithCheckedExceptions_1[_]].declarations.toList
+  val decls = typeOf[JavaClassWithCheckedExceptions_1[_]].decls.toList
   decls sortBy (_.name.toString) foreach (decl => println(s"${decl.name}: ${decl.annotations}"))
 }
 \ No newline at end of file
diff --git a/test/files/run/t7044.check b/test/files/run/t7044.check
new file mode 100644
index 0000000000..ab523873bf
--- /dev/null
+++ b/test/files/run/t7044.check
@@ -0,0 +1,14 @@
+compile-time
+uninitialized File: <no file>
+initialized File: <no file>
+uninitialized BitSet: <no file>
+initialized BitSet: <no file>
+uninitialized C: Test_2.scala
+initialized C: Test_2.scala
+runtime
+autoinitialized File: <no file> true
+autoinitialized File: <no file> true
+autoinitialized BitSet: <no file> true
+autoinitialized BitSet: <no file> true
+autoinitialized C: <no file> true
+autoinitialized C: <no file> true
diff --git a/test/files/run/t7044/Macros_1.scala b/test/files/run/t7044/Macros_1.scala
new file mode 100644
index 0000000000..3b3f8c3385
--- /dev/null
+++ b/test/files/run/t7044/Macros_1.scala
@@ -0,0 +1,26 @@
+import scala.reflect.macros.whitebox._
+import scala.language.experimental.macros
+
+object Macros {
+  def impl(c: Context) = {
+    var messages = List[String]()
+    def println(msg: String) = messages :+= msg
+
+    import c.universe._
+    def test(tpe: Type): Unit = {
+      val sym = tpe.typeSymbol
+      println(s"uninitialized ${sym.name}: ${sym.pos.source.file.name}")
+      internal.initialize(sym)
+      println(s"initialized ${sym.name}: ${sym.pos.source.file.name}")
+    }
+
+    println("compile-time")
+    test(typeOf[java.io.File])
+    test(typeOf[scala.collection.BitSet])
+    test(c.mirror.staticClass("C").toType)
+
+    q"..${messages.map(msg => q"println($msg)")}"
+  }
+
+  def foo: Any = macro impl
+}
+\ No newline at end of file
diff --git a/test/files/run/t7044/Test_2.scala b/test/files/run/t7044/Test_2.scala
new file mode 100644
index 0000000000..8dfb349086
--- /dev/null
+++ b/test/files/run/t7044/Test_2.scala
@@ -0,0 +1,19 @@
+import scala.reflect.runtime.universe._
+import scala.reflect.runtime.{currentMirror => cm}
+
+class C
+
+object Test extends App {
+  def test(tpe: Type): Unit = {
+    val sym = tpe.typeSymbol
+    println(s"autoinitialized ${sym.name}: ${sym.pos.source.file.name} ${sym.pos.source.file.sizeOption.nonEmpty}")
+    internal.initialize(sym)
+    println(s"autoinitialized ${sym.name}: ${sym.pos.source.file.name} ${sym.pos.source.file.sizeOption.nonEmpty}")
+  }
+
+  Macros.foo
+  println("runtime")
+  test(typeOf[java.io.File])
+  test(typeOf[scala.collection.BitSet])
+  test(typeOf[C])
+}
diff --git a/test/files/run/t7045.scala b/test/files/run/t7045.scala
index f41baca05e..5b31a8b779 100644
--- a/test/files/run/t7045.scala
+++ b/test/files/run/t7045.scala
@@ -7,6 +7,6 @@ class D { self: C => }
 object Test extends App {
   val d = cm.staticClass("D")
   println(d.selfType)
-  d.typeSignature
+  d.info
   println(d.selfType)
 }
 \ No newline at end of file
diff --git a/test/files/run/t7046.scala b/test/files/run/t7046.scala
index 647a15cd18..f15545f59f 100644
--- a/test/files/run/t7046.scala
+++ b/test/files/run/t7046.scala
@@ -8,6 +8,6 @@ class E extends C
 object Test extends App {
   val c = cm.staticClass("C")
   println(c.knownDirectSubclasses)
-  c.typeSignature
+  c.info
   println(c.knownDirectSubclasses)
 }
 \ No newline at end of file
diff --git a/test/files/run/t7096.scala b/test/files/run/t7096.scala
index 2495102899..e7a894fc23 100644
--- a/test/files/run/t7096.scala
+++ b/test/files/run/t7096.scala
@@ -3,6 +3,53 @@
  */
 import scala.tools.partest._
 import scala.tools.nsc._
+import scala.reflect.runtime.{universe => ru}
+import scala.language.implicitConversions
+
+// necessary to avoid bincompat with scala-partest compiled against the old compiler
+abstract class CompilerTest extends DirectTest {
+  def check(source: String, unit: global.CompilationUnit): Unit
+
+  lazy val global: Global = newCompiler()
+  lazy val units: List[global.CompilationUnit] = compilationUnits(global)(sources: _ *)
+  import global._
+  import definitions.{ compilerTypeFromTag }
+
+  override def extraSettings = "-usejavacp -d " + testOutput.path
+
+  def show() = (sources, units).zipped foreach check
+
+  // Override at least one of these...
+  def code = ""
+  def sources: List[String] = List(code)
+
+  // Utility functions
+  class MkType(sym: Symbol) {
+    def apply[M](implicit t: ru.TypeTag[M]): Type =
+      if (sym eq NoSymbol) NoType
+      else appliedType(sym, compilerTypeFromTag(t))
+  }
+  implicit def mkMkType(sym: Symbol) = new MkType(sym)
+
+  def allMembers(root: Symbol): List[Symbol] = {
+    def loop(seen: Set[Symbol], roots: List[Symbol]): List[Symbol] = {
+      val latest = roots flatMap (_.info.members) filterNot (seen contains _)
+      if (latest.isEmpty) seen.toList.sortWith(_ isLess _)
+      else loop(seen ++ latest, latest)
+    }
+    loop(Set(), List(root))
+  }
+
+  class SymsInPackage(pkgName: String) {
+    def pkg     = rootMirror.getPackage(TermName(pkgName))
+    def classes = allMembers(pkg) filter (_.isClass)
+    def modules = allMembers(pkg) filter (_.isModule)
+    def symbols = classes ++ terms filterNot (_ eq NoSymbol)
+    def terms   = allMembers(pkg) filter (s => s.isTerm && !s.isConstructor)
+    def tparams = classes flatMap (_.info.typeParams)
+    def tpes    = symbols map (_.tpe) distinct
+  }
+}
 
 object Test extends CompilerTest {
   import global._
diff --git a/test/files/run/t7240/Macros_1.scala b/test/files/run/t7240/Macros_1.scala
index c6e976038d..b24b607d17 100644
--- a/test/files/run/t7240/Macros_1.scala
+++ b/test/files/run/t7240/Macros_1.scala
@@ -34,11 +34,11 @@ object Bakery {
         List(dslTrait("bakery.FailureCake")),
         emptyValDef,
         List(
-          DefDef(Modifiers(), nme.CONSTRUCTOR, List(), List(List()), TypeTree(),
-            Block(List(Apply(Select(Super(This(tpnme.EMPTY), tpnme.EMPTY), nme.CONSTRUCTOR), List())), Literal(Constant(())))),
+          DefDef(Modifiers(), termNames.CONSTRUCTOR, List(), List(List()), TypeTree(),
+            Block(List(Apply(Select(Super(This(typeNames.EMPTY), typeNames.EMPTY), termNames.CONSTRUCTOR), List())), Literal(Constant(())))),
           DefDef(Modifiers(), newTermName("main"), List(), List(List()), Ident(newTypeName("Any")), transformedBody))))
 
-    def constructor = Apply(Select(New(Ident(newTypeName("eval"))), nme.CONSTRUCTOR), List())
+    def constructor = Apply(Select(New(Ident(newTypeName("eval"))), termNames.CONSTRUCTOR), List())
 
     c.eval(c.Expr[Any](
       c.untypecheck(Block(composeDSL(Literal(Constant(1))), constructor))))
diff --git a/test/files/run/t7328.scala b/test/files/run/t7328.scala
index 8816fa2347..56956b489b 100644
--- a/test/files/run/t7328.scala
+++ b/test/files/run/t7328.scala
@@ -5,7 +5,7 @@ case class Foo(x: Int) extends AnyVal
 case class Bar(foo: Foo)
 
 object Test extends App {
-  val foo = typeOf[Bar].declaration(TermName("foo")).asMethod
+  val foo = typeOf[Bar].decl(TermName("foo")).asMethod
   println(foo.returnType) // Foo
 
   val bar = Bar(Foo(3))
diff --git a/test/files/run/t7331c.check b/test/files/run/t7331c.check
index b35d831f83..a9dc6a7d0f 100644
--- a/test/files/run/t7331c.check
+++ b/test/files/run/t7331c.check
@@ -1,3 +1,3 @@
-ClassDef(Modifiers(), TypeName("C"), List(), Template(List(Select(Ident(scala), TypeName("AnyRef"))), noSelfType, List(DefDef(Modifiers(), nme.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(pendingSuperCall), Literal(Constant(())))))))
+ClassDef(Modifiers(), TypeName("C"), List(), Template(List(Select(Ident(scala), TypeName("AnyRef"))), noSelfType, List(DefDef(Modifiers(), termNames.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(pendingSuperCall), Literal(Constant(())))))))
 source-<toolbox>,line-1,offset=6
 NoPosition
diff --git a/test/files/run/t7455/Test.scala b/test/files/run/t7455/Test.scala
index b23a724c78..2cda9225f4 100644
--- a/test/files/run/t7455/Test.scala
+++ b/test/files/run/t7455/Test.scala
@@ -21,7 +21,7 @@ object Test extends DirectTest {
     for {
       name <- Seq("Outer", "Outer$PrivateInner", "Outer$PrivateStaticInner", "Outer$PublicInner")
       clazz = compiler.rootMirror.staticClass(name)
-      constr <- clazz.info.member(nme.CONSTRUCTOR).alternatives
+      constr <- clazz.info.member(termNames.CONSTRUCTOR).alternatives
     } {
       println(constr.defString)
       fullyInitializeSymbol(constr)
diff --git a/test/files/run/t7533.check b/test/files/run/t7533.check
new file mode 100644
index 0000000000..fa5b3edc8f
--- /dev/null
+++ b/test/files/run/t7533.check
@@ -0,0 +1,30 @@
+Testing Symbol.isAbstract...
+=======class C=======
+class C => true
+constructor C => false
+value x1 => true
+value x2 => false
+value x2 => false
+method y1 => true
+method y2 => false
+type T1 => true
+type T2 => false
+=======trait T=======
+trait T => true
+method $init$ => false
+value z1 => true
+value z2 => false
+value z2 => false
+method w1 => true
+method w2 => false
+type U1 => true
+type U2 => false
+=======class D=======
+class D => false
+constructor D => false
+value x1 => false
+value x1 => false
+method y1 => false
+=======object M=======
+object M => false
+constructor M => false
diff --git a/test/files/run/t7533.scala b/test/files/run/t7533.scala
new file mode 100644
index 0000000000..c7bd8e8d43
--- /dev/null
+++ b/test/files/run/t7533.scala
@@ -0,0 +1,38 @@
+import scala.reflect.runtime.universe._
+
+abstract class C {
+  val x1: Int
+  val x2: Int = 2
+  def y1: Int
+  def y2: Int = 2
+  type T1 <: Int
+  type T2 = Int
+}
+trait T {
+  val z1: Int
+  val z2: Int = 2
+  def w1: Int
+  def w2: Int = 2
+  type U1 <: Int
+  type U2 = Int
+}
+class D extends C {
+  val x1 = 3
+  def y1 = 3
+}
+object M
+
+object Test extends App {
+  println("Testing Symbol.isAbstract...")
+  def test[T: TypeTag] = {
+    val sym = typeOf[T].typeSymbol
+    println(s"=======$sym=======")
+    def printAbstract(sym: Symbol) = println(s"$sym => ${sym.isAbstract}")
+    printAbstract(sym)
+    sym.info.decls.sorted.foreach(printAbstract)
+  }
+  test[C]
+  test[T]
+  test[D]
+  test[M.type]
+}
+\ No newline at end of file
diff --git a/test/files/run/t7556/Test_2.scala b/test/files/run/t7556/Test_2.scala
index 31848738ef..a78c917ed8 100644
--- a/test/files/run/t7556/Test_2.scala
+++ b/test/files/run/t7556/Test_2.scala
@@ -5,7 +5,7 @@ object Test {
     val mc = new MegaClass
     val anns = mc.getClass.getAnnotations.map(_.annotationType.getName).toList.sorted
     println(s"class annotations: $anns")
-    val N = typeTag[MegaClass].tpe.declarations.size // was:  error reading Scala signature of MegaClass: 65935
+    val N = typeTag[MegaClass].tpe.decls.size // was:  error reading Scala signature of MegaClass: 65935
     println(s"$N decls via runtime reflection")
   }
 }
diff --git a/test/files/run/t7570b.scala b/test/files/run/t7570b.scala
index f1db193186..7d4ade5237 100644
--- a/test/files/run/t7570b.scala
+++ b/test/files/run/t7570b.scala
@@ -3,11 +3,12 @@ import scala.reflect.runtime.{currentMirror => cm}
 import scala.tools.reflect.{ToolBox, ToolBoxError}
 import definitions._
 import Flag._
+import internal._
 
 object Test extends App {
   val tb = cm.mkToolBox()
-  val msg = build.newFreeTerm("msg", "C")
-  build.setTypeSignature(msg, typeOf[String])
+  val msg = internal.reificationSupport.newFreeTerm("msg", "C")
+  internal.reificationSupport.setInfo(msg, typeOf[String])
   try {
     val csym = tb.define(q"""class C { override def toString = $msg }""")
     println(tb.eval(q"new $csym"))
diff --git a/test/files/run/t7582-private-within.check b/test/files/run/t7582-private-within.check
index b2743ffa06..1b9a0910af 100644
--- a/test/files/run/t7582-private-within.check
+++ b/test/files/run/t7582-private-within.check
@@ -2,7 +2,7 @@ private[package pack] class JavaPackagePrivate
 private[package pack] module JavaPackagePrivate
 private[package pack] module class JavaPackagePrivate
 private[package pack] field field
-private[package pack] primary constructor <init>
+private[package pack] constructor <init>
 private[package pack] method meth
 private[package pack] field staticField
 private[package pack] method staticMeth
diff --git a/test/files/run/t8104/Macros_1.scala b/test/files/run/t8104/Macros_1.scala
index 2ad4bc5a99..e135bd807b 100644
--- a/test/files/run/t8104/Macros_1.scala
+++ b/test/files/run/t8104/Macros_1.scala
@@ -4,8 +4,8 @@ object Macros {
   def impl[T](c: Context)(implicit T: c.WeakTypeTag[T]) = {
     import c.universe._
     import definitions._
-    val fields = T.tpe.declarations.toList.collect{ case x: TermSymbol if x.isVal && x.isCaseAccessor => x }
-    val Repr = appliedType(TupleClass(fields.length).asType.toType, fields.map(_.typeSignature))
+    val fields = T.tpe.decls.toList.collect{ case x: TermSymbol if x.isVal && x.isCaseAccessor => x }
+    val Repr = appliedType(TupleClass(fields.length).asType.toType, fields.map(_.info))
     q"new Generic[$T]{ type Repr = $Repr }"
   }
 }
 \ No newline at end of file
diff --git a/test/files/run/t8104/Test_2.scala b/test/files/run/t8104/Test_2.scala
index 55c080a563..08451dfb2a 100644
--- a/test/files/run/t8104/Test_2.scala
+++ b/test/files/run/t8104/Test_2.scala
@@ -11,7 +11,7 @@ object Test extends App {
   import scala.reflect.runtime.universe._
   def reprify[T, Repr](x: T)(implicit generic: Generic.Aux[T, Repr], tag: WeakTypeTag[Repr]) = {
     println(tag)
-    println(tag.tpe.typeSymbol.typeSignature)
+    println(tag.tpe.typeSymbol.info)
   }
   reprify(C(40, 2))
 
diff --git a/test/files/run/t8190.check b/test/files/run/t8190.check
new file mode 100644
index 0000000000..d117bf3294
--- /dev/null
+++ b/test/files/run/t8190.check
@@ -0,0 +1,91 @@
+Annotation
+Constant
+Mirror
+Name
+TermName
+TypeName
+Position
+Scope
+MemberScope
+Symbol
+TermSymbol
+TypeSymbol
+MethodSymbol
+ModuleSymbol
+ClassSymbol
+FreeTermSymbol
+FreeTypeSymbol
+Type
+SingletonType
+ThisType
+SingleType
+SuperType
+ConstantType
+TypeRef
+CompoundType
+RefinedType
+ClassInfoType
+MethodType
+NullaryMethodType
+PolyType
+ExistentialType
+AnnotatedType
+TypeBounds
+BoundedWildcardType
+Tree
+TermTree
+TypTree
+SymTree
+NameTree
+RefTree
+DefTree
+MemberDef
+PackageDef
+ImplDef
+ClassDef
+ModuleDef
+ValOrDefDef
+ValDef
+DefDef
+TypeDef
+LabelDef
+ImportSelector
+Import
+Template
+Block
+CaseDef
+Alternative
+Star
+Bind
+UnApply
+Function
+Assign
+AssignOrNamedArg
+If
+Match
+Return
+Try
+Throw
+New
+Typed
+GenericApply
+TypeApply
+Apply
+Super
+This
+Select
+Ident
+ReferenceToBoxed
+Literal
+Annotated
+SingletonTypeTree
+SelectFromTypeTree
+CompoundTypeTree
+AppliedTypeTree
+TypeBoundsTree
+ExistentialTypeTree
+TypeTree
+Modifiers
+TreeCopier
+checking exhaustiveness in scala.reflect.api.Universe...
+uncovered type members: List()
diff --git a/test/files/run/t8190.scala b/test/files/run/t8190.scala
new file mode 100644
index 0000000000..17ff83c714
--- /dev/null
+++ b/test/files/run/t8190.scala
@@ -0,0 +1,210 @@
+import scala.reflect.runtime.universe._
+
+trait Overloads {
+  // makes sure noone erases to Any or AnyRef
+  def test(x: AnyRef) = "AnyRef"
+  def test(x: Annotation) = "Annotation"
+  def test(x: Constant) = "Constant"
+  def test(x: Mirror) = "Mirror"
+  def test(x: Name) = "Name"
+  def test(x: TermName) = "TermName"
+  def test(x: TypeName) = "TypeName"
+  def test(x: Position) = "Position"
+  def test(x: Scope) = "Scope"
+  def test(x: MemberScope) = "MemberScope"
+  def test(x: Symbol) = "Symbol"
+  def test(x: TermSymbol) = "TermSymbol"
+  def test(x: TypeSymbol) = "TypeSymbol"
+  def test(x: MethodSymbol) = "MethodSymbol"
+  def test(x: ModuleSymbol) = "ModuleSymbol"
+  def test(x: ClassSymbol) = "ClassSymbol"
+  def test(x: FreeTermSymbol) = "FreeTermSymbol"
+  def test(x: FreeTypeSymbol) = "FreeTypeSymbol"
+  def test(x: Type) = "Type"
+  def test(x: SingletonType) = "SingletonType"
+  def test(x: ThisType) = "ThisType"
+  def test(x: SingleType) = "SingleType"
+  def test(x: SuperType) = "SuperType"
+  def test(x: ConstantType) = "ConstantType"
+  def test(x: TypeRef) = "TypeRef"
+  def test(x: CompoundType) = "CompoundType"
+  def test(x: RefinedType) = "RefinedType"
+  def test(x: ClassInfoType) = "ClassInfoType"
+  def test(x: MethodType) = "MethodType"
+  def test(x: NullaryMethodType) = "NullaryMethodType"
+  def test(x: PolyType) = "PolyType"
+  def test(x: ExistentialType) = "ExistentialType"
+  def test(x: AnnotatedType) = "AnnotatedType"
+  def test(x: TypeBounds) = "TypeBounds"
+  def test(x: BoundedWildcardType) = "BoundedWildcardType"
+  def test(x: Tree) = "Tree"
+  def test(x: TermTree) = "TermTree"
+  def test(x: TypTree) = "TypTree"
+  def test(x: SymTree) = "SymTree"
+  def test(x: NameTree) = "NameTree"
+  def test(x: RefTree) = "RefTree"
+  def test(x: DefTree) = "DefTree"
+  def test(x: MemberDef) = "MemberDef"
+  def test(x: PackageDef) = "PackageDef"
+  def test(x: ImplDef) = "ImplDef"
+  def test(x: ClassDef) = "ClassDef"
+  def test(x: ModuleDef) = "ModuleDef"
+  def test(x: ValOrDefDef) = "ValOrDefDef"
+  def test(x: ValDef) = "ValDef"
+  def test(x: DefDef) = "DefDef"
+  def test(x: TypeDef) = "TypeDef"
+  def test(x: LabelDef) = "LabelDef"
+  def test(x: ImportSelector) = "ImportSelector"
+  def test(x: Import) = "Import"
+  def test(x: Template) = "Template"
+  def test(x: Block) = "Block"
+  def test(x: CaseDef) = "CaseDef"
+  def test(x: Alternative) = "Alternative"
+  def test(x: Star) = "Star"
+  def test(x: Bind) = "Bind"
+  def test(x: UnApply) = "UnApply"
+  def test(x: Function) = "Function"
+  def test(x: Assign) = "Assign"
+  def test(x: AssignOrNamedArg) = "AssignOrNamedArg"
+  def test(x: If) = "If"
+  def test(x: Match) = "Match"
+  def test(x: Return) = "Return"
+  def test(x: Try) = "Try"
+  def test(x: Throw) = "Throw"
+  def test(x: New) = "New"
+  def test(x: Typed) = "Typed"
+  def test(x: GenericApply) = "GenericApply"
+  def test(x: TypeApply) = "TypeApply"
+  def test(x: Apply) = "Apply"
+  def test(x: Super) = "Super"
+  def test(x: This) = "This"
+  def test(x: Select) = "Select"
+  def test(x: Ident) = "Ident"
+  def test(x: ReferenceToBoxed) = "ReferenceToBoxed"
+  def test(x: Literal) = "Literal"
+  def test(x: Annotated) = "Annotated"
+  def test(x: SingletonTypeTree) = "SingletonTypeTree"
+  def test(x: SelectFromTypeTree) = "SelectFromTypeTree"
+  def test(x: CompoundTypeTree) = "CompoundTypeTree"
+  def test(x: AppliedTypeTree) = "AppliedTypeTree"
+  def test(x: TypeBoundsTree) = "TypeBoundsTree"
+  def test(x: ExistentialTypeTree) = "ExistentialTypeTree"
+  def test(x: TypeTree) = "TypeTree"
+  def test(x: Modifiers) = "Modifiers"
+  def test(x: TreeCopier) = "TreeCopier"
+}
+
+object Test extends App with Overloads {
+  val buf = scala.collection.mutable.ListBuffer[String]()
+  def record(result: String): Unit = {
+    println(result)
+    buf += result
+  }
+  def check(): Unit = {
+    println("checking exhaustiveness in scala.reflect.api.Universe...")
+    var types = typeOf[scala.reflect.api.Universe].members.filter(sym => sym.isType && !sym.isClass).map(_.name.toString)
+    types = types.filter(_ != "ModifiersCreator") // type ModifiersCreator = ModifiersExtractor
+    types = types.filter(_ != "FlagSet") // type FlagSet
+    types = types.filter(_ != "RuntimeClass") // type RuntimeClass = java.lang.Class[_]
+    types = types.filter(_ != "JavaArgument") // deprecated
+    types = types.filter(_ != "LiteralArgument") // deprecated
+    types = types.filter(_ != "ArrayArgument") // deprecated
+    types = types.filter(_ != "NestedArgument") // deprecated
+    types = types.filter(_ != "Importer") // deprecated
+    types = types.filter(_ != "Internal") // internal
+    types = types.filter(_ != "Compat") // internal
+    types = types.filter(_ != "BuildApi") // deprecated
+    val diff = types.toList diff buf.toList
+    println("uncovered type members: " + diff)
+  }
+  record(test(null: Annotation))
+  record(test(null: Constant))
+  record(test(null: Mirror))
+  record(test(null: Name))
+  record(test(null: TermName))
+  record(test(null: TypeName))
+  record(test(null: Position))
+  record(test(null: Scope))
+  record(test(null: MemberScope))
+  record(test(null: Symbol))
+  record(test(null: TermSymbol))
+  record(test(null: TypeSymbol))
+  record(test(null: MethodSymbol))
+  record(test(null: ModuleSymbol))
+  record(test(null: ClassSymbol))
+  record(test(null: FreeTermSymbol))
+  record(test(null: FreeTypeSymbol))
+  record(test(null: Type))
+  record(test(null: SingletonType))
+  record(test(null: ThisType))
+  record(test(null: SingleType))
+  record(test(null: SuperType))
+  record(test(null: ConstantType))
+  record(test(null: TypeRef))
+  record(test(null: CompoundType))
+  record(test(null: RefinedType))
+  record(test(null: ClassInfoType))
+  record(test(null: MethodType))
+  record(test(null: NullaryMethodType))
+  record(test(null: PolyType))
+  record(test(null: ExistentialType))
+  record(test(null: AnnotatedType))
+  record(test(null: TypeBounds))
+  record(test(null: BoundedWildcardType))
+  record(test(null: Tree))
+  record(test(null: TermTree))
+  record(test(null: TypTree))
+  record(test(null: SymTree))
+  record(test(null: NameTree))
+  record(test(null: RefTree))
+  record(test(null: DefTree))
+  record(test(null: MemberDef))
+  record(test(null: PackageDef))
+  record(test(null: ImplDef))
+  record(test(null: ClassDef))
+  record(test(null: ModuleDef))
+  record(test(null: ValOrDefDef))
+  record(test(null: ValDef))
+  record(test(null: DefDef))
+  record(test(null: TypeDef))
+  record(test(null: LabelDef))
+  record(test(null: ImportSelector))
+  record(test(null: Import))
+  record(test(null: Template))
+  record(test(null: Block))
+  record(test(null: CaseDef))
+  record(test(null: Alternative))
+  record(test(null: Star))
+  record(test(null: Bind))
+  record(test(null: UnApply))
+  record(test(null: Function))
+  record(test(null: Assign))
+  record(test(null: AssignOrNamedArg))
+  record(test(null: If))
+  record(test(null: Match))
+  record(test(null: Return))
+  record(test(null: Try))
+  record(test(null: Throw))
+  record(test(null: New))
+  record(test(null: Typed))
+  record(test(null: GenericApply))
+  record(test(null: TypeApply))
+  record(test(null: Apply))
+  record(test(null: Super))
+  record(test(null: This))
+  record(test(null: Select))
+  record(test(null: Ident))
+  record(test(null: ReferenceToBoxed))
+  record(test(null: Literal))
+  record(test(null: Annotated))
+  record(test(null: SingletonTypeTree))
+  record(test(null: SelectFromTypeTree))
+  record(test(null: CompoundTypeTree))
+  record(test(null: AppliedTypeTree))
+  record(test(null: TypeBoundsTree))
+  record(test(null: ExistentialTypeTree))
+  record(test(null: TypeTree))
+  record(test(null: Modifiers))
+  record(test(null: TreeCopier))
+  check()
+}
+\ No newline at end of file
diff --git a/test/files/run/t8192.check b/test/files/run/t8192.check
new file mode 100644
index 0000000000..7195703e19
--- /dev/null
+++ b/test/files/run/t8192.check
@@ -0,0 +1,44 @@
+compile-time
+class File
+primary constructor: NoSymbol
+def <init>(x$1: String): java.io.File => false
+def <init>(x$1: String,x$2: String): java.io.File => false
+def <init>(x$1: java.io.File,x$2: String): java.io.File => false
+def <init>(x$1: java.net.URI): java.io.File => false
+package scala
+primary constructor: NoSymbol
+object List
+primary constructor: def <init>(): scala.collection.immutable.List.type => true
+def <init>(): scala.collection.immutable.List.type => true
+trait Product1
+primary constructor: def $init$(): Unit => true
+class UninitializedFieldError
+primary constructor: def <init>(msg: String): UninitializedFieldError => true
+def <init>(msg: String): UninitializedFieldError => true
+def <init>(obj: Any): UninitializedFieldError => false
+class C
+primary constructor: def <init>(x: Int): C => true
+def <init>(x: Int): C => true
+def <init>(x: String): C => false
+runtime
+class File
+primary constructor: NoSymbol
+def <init>(x$1: java.io.File,x$2: java.lang.String): java.io.File => false
+def <init>(x$1: java.lang.String): java.io.File => false
+def <init>(x$1: java.lang.String,x$2: java.lang.String): java.io.File => false
+def <init>(x$1: java.net.URI): java.io.File => false
+package scala
+primary constructor: NoSymbol
+object List
+primary constructor: def <init>(): scala.collection.immutable.List.type => true
+def <init>(): scala.collection.immutable.List.type => true
+trait Product1
+primary constructor: def $init$(): Unit => true
+class UninitializedFieldError
+primary constructor: def <init>(msg: String): UninitializedFieldError => true
+def <init>(msg: String): UninitializedFieldError => true
+def <init>(obj: Any): UninitializedFieldError => false
+class C
+primary constructor: def <init>(x: Int): C => true
+def <init>(x: Int): C => true
+def <init>(x: String): C => false
diff --git a/test/files/run/t8192/Macros_1.scala b/test/files/run/t8192/Macros_1.scala
new file mode 100644
index 0000000000..ddad9fb872
--- /dev/null
+++ b/test/files/run/t8192/Macros_1.scala
@@ -0,0 +1,44 @@
+import scala.reflect.macros.whitebox._
+import scala.language.experimental.macros
+import java.io._
+
+object Macros {
+  def impl(c: Context) = {
+    var messages = List[String]()
+    def println(msg: String) = messages :+= msg
+
+    import c.universe._
+    def test(sym: ClassSymbol): Unit = {
+      def fullyInitializeSymbol(sym: Symbol): Unit = {
+        val internal = c.universe.asInstanceOf[scala.reflect.internal.SymbolTable]
+        internal.definitions.fullyInitializeSymbol(sym.asInstanceOf[internal.Symbol])
+      }
+      def defString(sym: Symbol): String = {
+        val internal = c.universe.asInstanceOf[scala.reflect.internal.SymbolTable]
+        sym.asInstanceOf[internal.Symbol].defString
+      }
+      def showCtor(sym: Symbol): String = {
+        fullyInitializeSymbol(sym)
+        if (sym == NoSymbol) "NoSymbol"
+        else s"${defString(sym)} => ${sym.asMethod.isPrimaryConstructor}"
+      }
+      sym.info
+      println(sym.toString)
+      println(s"primary constructor: ${showCtor(sym.primaryConstructor)}")
+      val ctors = sym.info.members.filter(_.name == termNames.CONSTRUCTOR).map(sym => showCtor(sym))
+      ctors.toList.sorted.foreach(println)
+    }
+
+    println("compile-time")
+    test(typeOf[File].typeSymbol.asClass)
+    test(definitions.ScalaPackageClass)
+    test(definitions.ListModule.moduleClass.asClass)
+    test(typeOf[Product1[_]].typeSymbol.asClass)
+    test(typeOf[UninitializedFieldError].typeSymbol.asClass)
+    test(c.mirror.staticClass("C").asClass)
+
+    q"..${messages.map(msg => q"println($msg)")}"
+  }
+
+  def foo: Any = macro impl
+}
+\ No newline at end of file
diff --git a/test/files/run/t8192/Test_2.scala b/test/files/run/t8192/Test_2.scala
new file mode 100644
index 0000000000..29f187c171
--- /dev/null
+++ b/test/files/run/t8192/Test_2.scala
@@ -0,0 +1,39 @@
+import java.io._
+import scala.reflect.runtime.universe._
+import scala.reflect.runtime.{universe => ru}
+
+class C(x: Int) {
+  def this(x: String) = this(x.toInt)
+}
+
+object Test extends App {
+  def test(sym: ClassSymbol): Unit = {
+    def fullyInitializeSymbol(sym: Symbol): Unit = {
+      val internal = ru.asInstanceOf[scala.reflect.internal.SymbolTable]
+      internal.definitions.fullyInitializeSymbol(sym.asInstanceOf[internal.Symbol])
+    }
+    def defString(sym: Symbol): String = {
+      val internal = ru.asInstanceOf[scala.reflect.internal.SymbolTable]
+      sym.asInstanceOf[internal.Symbol].defString
+    }
+    def showCtor(sym: Symbol): String = {
+      fullyInitializeSymbol(sym)
+      if (sym == NoSymbol) "NoSymbol"
+      else s"${defString(sym)} => ${sym.asMethod.isPrimaryConstructor}"
+    }
+    sym.info
+    println(sym.toString)
+    println(s"primary constructor: ${showCtor(sym.primaryConstructor)}")
+    val ctors = sym.info.members.filter(_.name == termNames.CONSTRUCTOR).map(sym => showCtor(sym))
+    ctors.toList.sorted.foreach(println)
+  }
+
+  Macros.foo
+  println("runtime")
+  test(typeOf[File].typeSymbol.asClass)
+  test(definitions.ScalaPackageClass)
+  test(definitions.ListModule.moduleClass.asClass)
+  test(typeOf[Product1[_]].typeSymbol.asClass)
+  test(typeOf[UninitializedFieldError].typeSymbol.asClass)
+  test(typeOf[C].typeSymbol.asClass)
+}
diff --git a/test/files/run/toolbox_typecheck_implicitsdisabled.scala b/test/files/run/toolbox_typecheck_implicitsdisabled.scala
index 8c1a6e580c..3fabdb33b6 100644
--- a/test/files/run/toolbox_typecheck_implicitsdisabled.scala
+++ b/test/files/run/toolbox_typecheck_implicitsdisabled.scala
@@ -7,7 +7,7 @@ object Test extends App {
   val toolbox = cm.mkToolBox()
 
   val tree1 = Block(List(
-    Import(Select(Ident(TermName("scala")), TermName("Predef")), List(ImportSelector(nme.WILDCARD, -1, null, -1)))),
+    Import(Select(Ident(TermName("scala")), TermName("Predef")), List(ImportSelector(termNames.WILDCARD, -1, null, -1)))),
     Apply(Select(Literal(Constant(1)), TermName("$minus$greater")), List(Literal(Constant(2))))
   )
   val ttree1 = toolbox.typecheck(tree1, withImplicitViewsDisabled = false)
@@ -15,7 +15,7 @@ object Test extends App {
 
   try {
     val tree2 = Block(List(
-      Import(Select(Ident(TermName("scala")), TermName("Predef")), List(ImportSelector(nme.WILDCARD, -1, null, -1)))),
+      Import(Select(Ident(TermName("scala")), TermName("Predef")), List(ImportSelector(termNames.WILDCARD, -1, null, -1)))),
       Apply(Select(Literal(Constant(1)), TermName("$minus$greater")), List(Literal(Constant(2))))
     )
     val ttree2 = toolbox.typecheck(tree2, withImplicitViewsDisabled = true)
diff --git a/test/files/run/toolbox_typecheck_macrosdisabled.check b/test/files/run/toolbox_typecheck_macrosdisabled.check
index d9e79cdd19..62de375826 100644
--- a/test/files/run/toolbox_typecheck_macrosdisabled.check
+++ b/test/files/run/toolbox_typecheck_macrosdisabled.check
@@ -32,7 +32,7 @@
       def apply[U <: scala.reflect.api.Universe with Singleton]($m$untyped: scala.reflect.api.Mirror[U]): U#Type = {
         val $u: U = $m$untyped.universe;
         val $m: $u.Mirror = $m$untyped.asInstanceOf[$u.Mirror];
-        $u.ConstantType.apply($u.Constant.apply(2))
+        $u.internal.reificationSupport.ConstantType($u.Constant.apply(2))
       }
     };
     new $typecreator2()
diff --git a/test/files/run/toolbox_typecheck_macrosdisabled.scala b/test/files/run/toolbox_typecheck_macrosdisabled.scala
index 4cbeefd6e0..5466cb7765 100644
--- a/test/files/run/toolbox_typecheck_macrosdisabled.scala
+++ b/test/files/run/toolbox_typecheck_macrosdisabled.scala
@@ -2,6 +2,7 @@ import scala.reflect.runtime.universe._
 import scala.reflect.runtime.{universe => ru}
 import scala.reflect.runtime.{currentMirror => cm}
 import scala.tools.reflect.ToolBox
+import internal._
 
 // Note: If you're looking at this test and you don't know why, you may
 // have accidentally changed the way type tags reify.  If so, validate
@@ -10,10 +11,10 @@ import scala.tools.reflect.ToolBox
 object Test extends App {
   val toolbox = cm.mkToolBox()
   val rupkg = cm.staticModule("scala.reflect.runtime.package")
-  val rusym = build.selectTerm(rupkg, "universe")
-  val NullaryMethodType(rutpe) = rusym.typeSignature
-  val ru = build.newFreeTerm("ru", scala.reflect.runtime.universe)
-  build.setTypeSignature(ru, rutpe)
+  val rusym = reificationSupport.selectTerm(rupkg, "universe")
+  val NullaryMethodType(rutpe) = rusym.info
+  val ru = reificationSupport.newFreeTerm("ru", scala.reflect.runtime.universe)
+  reificationSupport.setInfo(ru, rutpe)
 
   val tree1 = Apply(Select(Ident(ru), TermName("reify")), List(Literal(Constant(2))))
   val ttree1 = toolbox.typecheck(tree1, withMacrosDisabled = false)
diff --git a/test/files/run/toolbox_typecheck_macrosdisabled2.check b/test/files/run/toolbox_typecheck_macrosdisabled2.check
index 8e554a6c8f..86f89504d1 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.build.Ident($m.staticModule("scala.Array")), $u.TermName.apply("apply")), scala.collection.immutable.List.apply[$u.Literal]($u.Literal.apply($u.Constant.apply(2))))
+        $u.Apply.apply($u.Select.apply($u.internal.reificationSupport.mkIdent($m.staticModule("scala.Array")), $u.TermName.apply("apply")), scala.collection.immutable.List.apply[$u.Literal]($u.Literal.apply($u.Constant.apply(2))))
       }
     };
     new $treecreator1()
@@ -32,7 +32,7 @@
       def apply[U <: scala.reflect.api.Universe with Singleton]($m$untyped: scala.reflect.api.Mirror[U]): U#Type = {
         val $u: U = $m$untyped.universe;
         val $m: $u.Mirror = $m$untyped.asInstanceOf[$u.Mirror];
-        $u.TypeRef.apply($u.ThisType.apply($m.staticPackage("scala").asModule.moduleClass), $m.staticClass("scala.Array"), scala.collection.immutable.List.apply[$u.Type]($m.staticClass("scala.Int").asType.toTypeConstructor))
+        $u.internal.reificationSupport.TypeRef($u.internal.reificationSupport.ThisType($m.staticPackage("scala").asModule.moduleClass), $m.staticClass("scala.Array"), scala.collection.immutable.List.apply[$u.Type]($m.staticClass("scala.Int").asType.toTypeConstructor))
       }
     };
     new $typecreator2()
diff --git a/test/files/run/toolbox_typecheck_macrosdisabled2.scala b/test/files/run/toolbox_typecheck_macrosdisabled2.scala
index 2fbd8f7c7a..606d3d40cb 100644
--- a/test/files/run/toolbox_typecheck_macrosdisabled2.scala
+++ b/test/files/run/toolbox_typecheck_macrosdisabled2.scala
@@ -2,6 +2,7 @@ import scala.reflect.runtime.universe._
 import scala.reflect.runtime.{universe => ru}
 import scala.reflect.runtime.{currentMirror => cm}
 import scala.tools.reflect.ToolBox
+import internal._
 
 // Note: If you're looking at this test and you don't know why, you may
 // have accidentally changed the way type tags reify.  If so, validate
@@ -10,10 +11,10 @@ import scala.tools.reflect.ToolBox
 object Test extends App {
   val toolbox = cm.mkToolBox()
   val rupkg = cm.staticModule("scala.reflect.runtime.package")
-  val rusym = build.selectTerm(rupkg, "universe")
-  val NullaryMethodType(rutpe) = rusym.typeSignature
-  val ru = build.newFreeTerm("ru", scala.reflect.runtime.universe)
-  build.setTypeSignature(ru, rutpe)
+  val rusym = reificationSupport.selectTerm(rupkg, "universe")
+  val NullaryMethodType(rutpe) = rusym.info
+  val ru = reificationSupport.newFreeTerm("ru", scala.reflect.runtime.universe)
+  reificationSupport.setInfo(ru, rutpe)
 
   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)
diff --git a/test/files/run/typed-annotated/Macros_1.scala b/test/files/run/typed-annotated/Macros_1.scala
index d805d82f39..4f0660dc45 100644
--- a/test/files/run/typed-annotated/Macros_1.scala
+++ b/test/files/run/typed-annotated/Macros_1.scala
@@ -6,8 +6,8 @@ class ann extends scala.annotation.StaticAnnotation
 object Macros {
   def impl(c: Context) = {
     import c.universe._
-    // val tpt = Annotated(Apply(Select(New(Ident(newTypeName("ann"))), nme.CONSTRUCTOR), List()), Ident(newTypeName("Int")))
-    val tpt = Annotated(Apply(Select(New(Ident(newTypeName("ann"))), nme.CONSTRUCTOR), List()), TypeTree(weakTypeOf[Int]))
+    // val tpt = Annotated(Apply(Select(New(Ident(newTypeName("ann"))), termNames.CONSTRUCTOR), List()), Ident(newTypeName("Int")))
+    val tpt = Annotated(Apply(Select(New(Ident(newTypeName("ann"))), termNames.CONSTRUCTOR), List()), TypeTree(weakTypeOf[Int]))
     c.Expr[Unit](Block(
       List(ValDef(Modifiers(), newTermName("x"), tpt, Literal(Constant(42)))),
       Apply(Ident(newTermName("println")), List(Ident(newTermName("x"))))))
diff --git a/test/files/run/typetags_symbolof_x.check b/test/files/run/typetags_symbolof_x.check
new file mode 100644
index 0000000000..fd0e069bca
--- /dev/null
+++ b/test/files/run/typetags_symbolof_x.check
@@ -0,0 +1,6 @@
+class Int
+object C
+type T
+type Id
+class Nothing
+class Null
diff --git a/test/files/run/typetags_symbolof_x.scala b/test/files/run/typetags_symbolof_x.scala
new file mode 100644
index 0000000000..333c4e7da4
--- /dev/null
+++ b/test/files/run/typetags_symbolof_x.scala
@@ -0,0 +1,15 @@
+import scala.reflect.runtime.universe._
+
+class C
+object C
+
+object Test extends App {
+  type T = Int
+  type Id[X] = X
+  println(symbolOf[Int])
+  println(symbolOf[C.type])
+  println(symbolOf[T])
+  println(symbolOf[Id[_]])
+  println(symbolOf[Nothing])
+  println(symbolOf[Null])
+}
diff --git a/test/files/scalacheck/quasiquotes/ArbitraryTreesAndNames.scala b/test/files/scalacheck/quasiquotes/ArbitraryTreesAndNames.scala
index fe90d7222f..7bd37140a7 100644
--- a/test/files/scalacheck/quasiquotes/ArbitraryTreesAndNames.scala
+++ b/test/files/scalacheck/quasiquotes/ArbitraryTreesAndNames.scala
@@ -1,5 +1,5 @@
 import org.scalacheck._, Prop._, Gen._, Arbitrary._
-import scala.reflect.runtime.universe._, Flag._
+import scala.reflect.runtime.universe._, internal._, Flag._
 
 trait ArbitraryTreesAndNames {
   def smallList[T](size: Int, g: Gen[T]) = {
diff --git a/test/files/scalacheck/quasiquotes/DefinitionConstructionProps.scala b/test/files/scalacheck/quasiquotes/DefinitionConstructionProps.scala
index 5f22925335..7e846bfb24 100644
--- a/test/files/scalacheck/quasiquotes/DefinitionConstructionProps.scala
+++ b/test/files/scalacheck/quasiquotes/DefinitionConstructionProps.scala
@@ -1,5 +1,5 @@
 import org.scalacheck._, Prop._, Gen._, Arbitrary._
-import scala.reflect.runtime.universe._, Flag._, build.ScalaDot
+import scala.reflect.runtime.universe._, Flag._, internal.reificationSupport.ScalaDot
 
 object DefinitionConstructionProps
     extends QuasiquoteProperties("definition construction")
@@ -28,7 +28,7 @@ object DefinitionConstructionProps
 trait ClassConstruction { self: QuasiquoteProperties =>
   val anyRef = ScalaDot(TypeName("AnyRef"))
   val emtpyConstructor =
-    DefDef(Modifiers(), nme.CONSTRUCTOR, List(),
+    DefDef(Modifiers(), termNames.CONSTRUCTOR, List(),
       List(List()), TypeTree(), Block(List(pendingSuperCall), Literal(Constant(()))))
   def classWith(name: TypeName, parents: List[Tree] = List(anyRef), body: List[DefDef] = Nil) =
     ClassDef(
@@ -174,7 +174,7 @@ trait TypeDefConstruction { self: QuasiquoteProperties =>
       TypeDef(
         Modifiers(), T, List(),
         CompoundTypeTree(
-          Template(List(Ident(A), Ident(B)), ValDef(Modifiers(PRIVATE), nme.WILDCARD, TypeTree(), EmptyTree), List())))
+          Template(List(Ident(A), Ident(B)), ValDef(Modifiers(PRIVATE), termNames.WILDCARD, TypeTree(), EmptyTree), List())))
   }
 
   property("splice trees into existential type tree") = forAll {
@@ -284,7 +284,7 @@ trait MethodConstruction { self: QuasiquoteProperties =>
   property("splice idents into annotation") = test {
     val idents = List(Ident(TypeName("annot1")), Ident(TypeName("annot2")))
     assertSameAnnots(q"@..$idents def foo",
-      idents.map { ident => Apply(Select(New(ident), nme.CONSTRUCTOR), List()) })
+      idents.map { ident => Apply(Select(New(ident), termNames.CONSTRUCTOR), List()) })
   }
 
   property("splice constructor calls into annotation") = test {
diff --git a/test/files/scalacheck/quasiquotes/DefinitionDeconstructionProps.scala b/test/files/scalacheck/quasiquotes/DefinitionDeconstructionProps.scala
index e2d1757d48..512b81c0e6 100644
--- a/test/files/scalacheck/quasiquotes/DefinitionDeconstructionProps.scala
+++ b/test/files/scalacheck/quasiquotes/DefinitionDeconstructionProps.scala
@@ -1,5 +1,5 @@
 import org.scalacheck._, Prop._, Gen._, Arbitrary._
-import scala.reflect.runtime.universe._, Flag._
+import scala.reflect.runtime.universe._, Flag._, internal.reificationSupport.SyntacticClassDef
 
 object DefinitionDeconstructionProps
   extends QuasiquoteProperties("definition deconstruction")
@@ -94,7 +94,7 @@ trait ClassDeconstruction { self: QuasiquoteProperties =>
   property("SI-7979") = test {
     val PARAMACCESSOR = (1 << 29).toLong.asInstanceOf[FlagSet]
     assertThrows[MatchError] {
-      val build.SyntacticClassDef(_, _, _, _, _, _, _, _, _) =
+      val SyntacticClassDef(_, _, _, _, _, _, _, _, _) =
         ClassDef(
           Modifiers(), TypeName("Foo"), List(),
           Template(
@@ -102,7 +102,7 @@ trait ClassDeconstruction { self: QuasiquoteProperties =>
             noSelfType,
             List(
               //ValDef(Modifiers(PRIVATE | LOCAL | PARAMACCESSOR), TermName("x"), Ident(TypeName("Int")), EmptyTree),
-              DefDef(Modifiers(), nme.CONSTRUCTOR, List(), List(List(ValDef(Modifiers(PARAM | PARAMACCESSOR), TermName("x"),
+              DefDef(Modifiers(), termNames.CONSTRUCTOR, List(), List(List(ValDef(Modifiers(PARAM | PARAMACCESSOR), TermName("x"),
                 Ident(TypeName("Int")), EmptyTree))), TypeTree(), Block(List(pendingSuperCall), Literal(Constant(())))))))
     }
   }
@@ -117,7 +117,7 @@ trait ModsDeconstruction { self: QuasiquoteProperties =>
 
   property("@$annot def foo") = forAll { (annotName: TypeName) =>
     val q"@$annot def foo" = q"@$annotName def foo"
-    annot ≈ Apply(Select(New(Ident(annotName)), nme.CONSTRUCTOR), List())
+    annot ≈ Apply(Select(New(Ident(annotName)), termNames.CONSTRUCTOR), List())
   }
 
   property("@$annot(..$args) def foo") = forAll { (annotName: TypeName, tree: Tree) =>
@@ -269,6 +269,6 @@ trait ImportDeconstruction { self: QuasiquoteProperties =>
         q"import $expr.{$plain, $oldname => $newname, $discard => _}"
 
     expr1 ≈ expr && plain11 == plain12 && plain12 == plain &&
-    oldname1 == oldname && newname1 == newname && discard1 == discard && wildcard == nme.WILDCARD
+    oldname1 == oldname && newname1 == newname && discard1 == discard && wildcard == termNames.WILDCARD
   }
 }
diff --git a/test/files/scalacheck/quasiquotes/ForProps.scala b/test/files/scalacheck/quasiquotes/ForProps.scala
index e71822aaea..b14d345edd 100644
--- a/test/files/scalacheck/quasiquotes/ForProps.scala
+++ b/test/files/scalacheck/quasiquotes/ForProps.scala
@@ -1,5 +1,5 @@
 import org.scalacheck._, Prop._, Gen._, Arbitrary._
-import scala.reflect.runtime.universe._, Flag._, build.{Ident => _, _}
+import scala.reflect.runtime.universe._, Flag._, internal.reificationSupport._
 
 object ForProps extends QuasiquoteProperties("for") {
   case class ForEnums(val value: List[Tree])
diff --git a/test/files/scalacheck/quasiquotes/PatternConstructionProps.scala b/test/files/scalacheck/quasiquotes/PatternConstructionProps.scala
index ca4c8609ac..fffaf1b363 100644
--- a/test/files/scalacheck/quasiquotes/PatternConstructionProps.scala
+++ b/test/files/scalacheck/quasiquotes/PatternConstructionProps.scala
@@ -7,7 +7,7 @@ object PatternConstructionProps extends QuasiquoteProperties("pattern constructi
   }
 
   property("splice name into bind") = forAll { (name: TermName) =>
-    pq"$name" ≈ Bind(name, Ident(nme.WILDCARD))
+    pq"$name" ≈ Bind(name, Ident(termNames.WILDCARD))
   }
 
   property("splice name and tree into bind") = forAll { (name: TermName, tree: Tree) =>
@@ -15,11 +15,11 @@ object PatternConstructionProps extends QuasiquoteProperties("pattern constructi
   }
 
   property("splice type name into typed") = forAll { (name: TypeName) =>
-    pq"_ : $name" ≈ Typed(Ident(nme.WILDCARD), Ident(name))
+    pq"_ : $name" ≈ Typed(Ident(termNames.WILDCARD), Ident(name))
   }
 
   property("splice tree into typed") = forAll { (typ: Tree) =>
-    pq"_ : $typ" ≈ Typed(Ident(nme.WILDCARD), typ)
+    pq"_ : $typ" ≈ Typed(Ident(termNames.WILDCARD), typ)
   }
 
   property("splice into apply") = forAll { (pat: Tree, subpat: Tree) =>
diff --git a/test/files/scalacheck/quasiquotes/QuasiquoteProperties.scala b/test/files/scalacheck/quasiquotes/QuasiquoteProperties.scala
index 5d84984514..6132244227 100644
--- a/test/files/scalacheck/quasiquotes/QuasiquoteProperties.scala
+++ b/test/files/scalacheck/quasiquotes/QuasiquoteProperties.scala
@@ -1,7 +1,7 @@
 import org.scalacheck._, Prop._, Gen._, Arbitrary._
 import scala.tools.reflect.{ToolBox, ToolBoxError}
 import scala.reflect.runtime.currentMirror
-import scala.reflect.runtime.universe._, Flag._
+import scala.reflect.runtime.universe._, Flag._, internal.reificationSupport.setSymbol
 
 class QuasiquoteProperties(name: String) extends Properties(name) with ArbitraryTreesAndNames with Helpers
 
@@ -116,5 +116,5 @@ trait Helpers {
     }
   }
 
-  val scalapkg = build.setSymbol(Ident(TermName("scala")), definitions.ScalaPackage)
+  val scalapkg = setSymbol(Ident(TermName("scala")), definitions.ScalaPackage)
 }
diff --git a/test/files/scalacheck/quasiquotes/TermConstructionProps.scala b/test/files/scalacheck/quasiquotes/TermConstructionProps.scala
index c1aa23ac23..4dbf746cfe 100644
--- a/test/files/scalacheck/quasiquotes/TermConstructionProps.scala
+++ b/test/files/scalacheck/quasiquotes/TermConstructionProps.scala
@@ -46,7 +46,7 @@ object TermConstructionProps extends QuasiquoteProperties("term construction") {
 
 
   property("splice tree into new") = forAll { (tree: Tree) =>
-    q"new $tree" ≈ Apply(Select(New(tree), nme.CONSTRUCTOR), List())
+    q"new $tree" ≈ Apply(Select(New(tree), termNames.CONSTRUCTOR), List())
   }
 
   property("splice tree into return") = forAll { (tree: Tree) =>
diff --git a/test/files/scalacheck/quasiquotes/TypeConstructionProps.scala b/test/files/scalacheck/quasiquotes/TypeConstructionProps.scala
index 08ed15e8a5..07875af326 100644
--- a/test/files/scalacheck/quasiquotes/TypeConstructionProps.scala
+++ b/test/files/scalacheck/quasiquotes/TypeConstructionProps.scala
@@ -1,5 +1,5 @@
 import org.scalacheck._, Prop._, Gen._, Arbitrary._
-import scala.reflect.runtime.universe._, Flag._
+import scala.reflect.runtime.universe._, Flag._, internal.reificationSupport.ScalaDot
 
 object TypeConstructionProps extends QuasiquoteProperties("type construction")  {
   property("bare idents contain type names") = test {
@@ -13,7 +13,7 @@ object TypeConstructionProps extends QuasiquoteProperties("type construction")
   property("tuple type") = test {
     val empty = List[Tree]()
     val ts = List(tq"t1", tq"t2")
-    assert(tq"(..$empty)" ≈ build.ScalaDot(TypeName("Unit")))
+    assert(tq"(..$empty)" ≈ ScalaDot(TypeName("Unit")))
     assert(tq"(..$ts)" ≈ tq"scala.Tuple2[t1, t2]")
     assert(tq"(t0, ..$ts)" ≈ tq"scala.Tuple3[t0, t1, t2]")
   }
diff --git a/test/files/scalacheck/quasiquotes/TypecheckedProps.scala b/test/files/scalacheck/quasiquotes/TypecheckedProps.scala
index 3afb47952c..8b1cb6cc49 100644
--- a/test/files/scalacheck/quasiquotes/TypecheckedProps.scala
+++ b/test/files/scalacheck/quasiquotes/TypecheckedProps.scala
@@ -1,5 +1,5 @@
 import org.scalacheck._, Prop._, Gen._, Arbitrary._
-import scala.reflect.runtime.universe._, Flag._, build.{Ident => _, _}
+import scala.reflect.runtime.universe._, Flag._, internal.reificationSupport._
 
 object TypecheckedProps extends QuasiquoteProperties("typechecked") {
   def original(tree: Tree) = tree match {