kills introduceTopLevel

As we've figured out from the practice, introduceTopLevel is seductively
useful but unfortunately not robust, potentially bringing compilation
order problems.

Therefore, as discussed, I'm removing it from the public macro API.
Alternatives are either: 1) delving into internals, or
2) using macro paradise and experimenting with macro annotations:
http://docs.scala-lang.org/overviews/macros/annotations.html.

5 files changed, 3 insertions, 178 deletions

diff --git a/src/compiler/scala/reflect/macros/contexts/Context.scala b/src/compiler/scala/reflect/macros/contexts/Context.scala
index bd1d7d5248..1355a839d9 100644
--- a/src/compiler/scala/reflect/macros/contexts/Context.scala
+++ b/src/compiler/scala/reflect/macros/contexts/Context.scala
@@ -14,7 +14,6 @@ abstract class Context extends scala.reflect.macros.Context
                           with Parsers
                           with Evals
                           with ExprUtils
-                          with Synthetics
                           with Traces {
 
   val universe: Global
diff --git a/src/compiler/scala/reflect/macros/contexts/Synthetics.scala b/src/compiler/scala/reflect/macros/contexts/Synthetics.scala
deleted file mode 100644
index ada16a8113..0000000000
--- a/src/compiler/scala/reflect/macros/contexts/Synthetics.scala
+++ /dev/null
@@ -1,66 +0,0 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- */
-
-package scala.reflect.macros
-package contexts
-
-import scala.reflect.internal.Flags._
-import scala.reflect.internal.util.BatchSourceFile
-import scala.reflect.io.VirtualFile
-
-trait Synthetics {
-  self: Context =>
-
-  import global._
-  import mirror.wrapMissing
-
-  // getClassIfDefined and getModuleIfDefined cannot be used here
-  // because they don't work for stuff declared in the empty package
-  // (as specified in SLS, code inside non-empty packages cannot see
-  // declarations from the empty package, so compiler internals
-  // default to ignoring contents of the empty package)
-  // to the contrast, staticModule and staticClass are designed
-  // to be a part of the reflection API and, therefore, they
-  // correctly resolve all names
-  private def topLevelSymbol(name: Name): Symbol = wrapMissing {
-    if (name.isTermName) mirror.staticModule(name.toString)
-    else mirror.staticClass(name.toString)
-  }
-
-  def topLevelDef(name: Name): Tree =
-    enclosingRun.units.toList.map(_.body).flatMap {
-      // it's okay to check `stat.symbol` here, because currently macros expand strictly after namer
-      // which means that by the earliest time one can call this method all top-level definitions will have already been entered
-      case PackageDef(_, stats) => stats filter (stat => stat.symbol != NoSymbol && stat.symbol == topLevelSymbol(name))
-      case _ => Nil // should never happen, but better be safe than sorry
-    }.headOption getOrElse EmptyTree
-
-  def topLevelRef(name: Name): Tree = {
-    if (topLevelDef(name).nonEmpty) gen.mkUnattributedRef(name)
-    else EmptyTree
-  }
-
-  def introduceTopLevel[T: PackageSpec](packagePrototype: T, definition: universe.ImplDef): RefTree =
-    introduceTopLevel(packagePrototype, List(definition)).head
-
-  def introduceTopLevel[T: PackageSpec](packagePrototype: T, definitions: universe.ImplDef*): List[RefTree] =
-    introduceTopLevel(packagePrototype, definitions.toList)
-
-  private def introduceTopLevel[T: PackageSpec](packagePrototype: T, definitions: List[universe.ImplDef]): List[RefTree] = {
-    val code @ PackageDef(pid, _) = implicitly[PackageSpec[T]].mkPackageDef(packagePrototype, definitions)
-    universe.currentRun.compileLate(code)
-    definitions map (definition => Select(pid, definition.name))
-  }
-
-  protected def mkPackageDef(name: String, stats: List[Tree]) = gen.mkPackageDef(name, stats)
-
-  protected def mkPackageDef(name: TermName, stats: List[Tree]) = gen.mkPackageDef(name.toString, stats)
-
-  protected def mkPackageDef(tree: RefTree, stats: List[Tree]) = PackageDef(tree, stats)
-
-  protected def mkPackageDef(sym: Symbol, stats: List[Tree]) = {
-    assert(sym hasFlag PACKAGE, s"expected a package or package class symbol, found: $sym")
-    gen.mkPackageDef(sym.fullName.toString, stats)
-  }
-}
diff --git a/src/compiler/scala/tools/nsc/CompilationUnits.scala b/src/compiler/scala/tools/nsc/CompilationUnits.scala
index b52e6fdf57..efe436f004 100644
--- a/src/compiler/scala/tools/nsc/CompilationUnits.scala
+++ b/src/compiler/scala/tools/nsc/CompilationUnits.scala
@@ -57,8 +57,8 @@ trait CompilationUnits { self: Global =>
     // SBT compatibility (SI-6875)
     //
     // imagine we have a file named A.scala, which defines a trait named Foo and a module named Main
-    // Main contains a call to a macro, which calls c.introduceTopLevel to define a mock for Foo
-    // c.introduceTopLevel creates a virtual file Virt35af32.scala, which contains a class named FooMock extending Foo,
+    // Main contains a call to a macro, which calls compileLate to define a mock for Foo
+    // compileLate creates a virtual file Virt35af32.scala, which contains a class named FooMock extending Foo,
     // and macro expansion instantiates FooMock. the stage is now set. let's see what happens next.
     //
     // without this workaround in scalac or without being patched itself, sbt will think that
diff --git a/src/reflect/scala/reflect/macros/Context.scala b/src/reflect/scala/reflect/macros/Context.scala
index 434b7c1b9c..b0c816f4ad 100644
--- a/src/reflect/scala/reflect/macros/Context.scala
+++ b/src/reflect/scala/reflect/macros/Context.scala
@@ -37,8 +37,7 @@ trait Context extends Aliases
                  with Typers
                  with Parsers
                  with Evals
-                 with ExprUtils
-                 with Synthetics {
+                 with ExprUtils {
 
   /** The compile-time universe. */
   val universe: Universe
diff --git a/src/reflect/scala/reflect/macros/Synthetics.scala b/src/reflect/scala/reflect/macros/Synthetics.scala
deleted file mode 100644
index 5e422ee89f..0000000000
--- a/src/reflect/scala/reflect/macros/Synthetics.scala
+++ /dev/null
@@ -1,107 +0,0 @@
-package scala
-package reflect
-package macros
-
-/**
- * <span class="badge badge-red" style="float: right;">EXPERIMENTAL</span>
- *
- *  A slice of [[scala.reflect.macros.Context the Scala macros context]] that
- *  exposes functions to introduce synthetic definitions.
- *
- *  @define TOPLEVEL_TREE Top-level tree is a tree that represents a non-inner class or object in one of the currently compiled source files.
- *  Note that top-level isn't equivalent to [[scala.reflect.api.Symbols#SymbolApi.isStatic]],
- *  because static also embraces definitions nested in static objects
- *
- *  @define INTRODUCE_TOP_LEVEL Allowed definitions include classes (represented by `ClassDef` trees), traits (represented
- *  by `ClassDef` trees having the `TRAIT` flag set in `mods`) and objects (represented by `ModuleDef` trees).
- *
- *  The definitions are put into the package with a prototype provided in `packagePrototype`.
- *  Supported prototypes are (see [[PackageSpec]] for more details):
- *    * Strings and names representing a fully-qualified name of the package
- *    * Trees that can work as package ids
- *    * Package or package class symbols
- *
- *  Typical value for a package prototype is a fully-qualified name in a string.
- *  For example, to generate a class available at `foo.bar.Test`, call this method as follows:
- *
- *    introduceTopLevel("foo.bar", ClassDef(<mods>, TypeName("Test"), <tparams>, <template>))
- *
- *  It is possible to add definitions to the empty package by using `nme.EMPTY_PACKAGE_NAME.toString`, but
- *  that's not recommended, since such definitions cannot be seen from outside the empty package.
- *
- *  Only the multi-parameter overload of this method can be used to introduce companions.
- *  If companions are introduced by two different calls, then they will be put into different virtual files, and `scalac`
- *  will show an error about companions being defined in different files. By the way, this also means that there's currently no way
- *  to define a companion for an existing class or module
- */
-trait Synthetics {
-  self: Context =>
-
-  import universe._
-
-  /** Looks up a top-level definition tree with a given fully-qualified name
-   *  (term name for modules, type name for classes). $TOPLEVEL_TREE.
-   *  If such a tree does not exist, returns `EmptyTree`.
-   */
-  def topLevelDef(name: Name): Tree
-
-  /** Returns a reference to a top-level definition tree with a given fully-qualified name
-   *  (term name for modules, type name for classes). $TOPLEVEL_TREE.
-   *  If such a tree does not exist, returns `EmptyTree`.
-   */
-  def topLevelRef(name: Name): Tree
-
-  /** Adds a top-level definition to the compiler's symbol table. $INTRODUCE_TOP_LEVEL.
-   *
-   *  Returns a fully-qualified reference to the introduced definition.
-   */
-  def introduceTopLevel[T: PackageSpec](packagePrototype: T, definition: ImplDef): RefTree
-
-  /** Adds a list of top-level definitions to the compiler's symbol table. $INTRODUCE_TOP_LEVEL.
-   *
-   *  Returns a list of fully-qualified references to the introduced definitions.
-   */
-  def introduceTopLevel[T: PackageSpec](packagePrototype: T, definitions: ImplDef*): List[RefTree]
-
-  /** A factory which can create a package def from a prototype and a list of declarations.
-   */
-  trait PackageSpec[T] { def mkPackageDef(prototype: T, stats: List[Tree]): PackageDef }
-
-  /** Hosts supported package specs.
-   */
-  object PackageSpec {
-    /** Package def can be created from a fully-qualified name and a list of definitions.
-     *  The name is converted into an Ident or a chain of Selects.
-     */
-    implicit val stringIsPackageSpec = new PackageSpec[String] {
-      def mkPackageDef(prototype: String, stats: List[Tree]): PackageDef = self.mkPackageDef(prototype, stats)
-    }
-
-    /** Package def can be created from a fully-qualified term name and a list of definitions.
-     *  The name is converted into an Ident or a chain of Selects.
-     */
-    implicit val termNameIsPackageSpec = new PackageSpec[TermName] {
-      def mkPackageDef(prototype: TermName, stats: List[Tree]): PackageDef = self.mkPackageDef(prototype, stats)
-    }
-
-    /** Package def can be created from a package id tree and a list of definitions.
-     *  If the tree is not a valid package id, i.e. is not a term-name ident or a chain of term-name selects,
-     *  then the produced PackageDef will fail compilation at some point in the future.
-     */
-    implicit val refTreeIsPackageSpec = new PackageSpec[RefTree] {
-      def mkPackageDef(prototype: RefTree, stats: List[Tree]): PackageDef = self.mkPackageDef(prototype, stats)
-    }
-
-    /** Package def can be created from a package/package class symbol and a list of definitions.
-     *  If the provided symbol is not a package symbol or a package class symbol, package construction will throw an exception.
-     */
-    implicit val SymbolIsPackageSpec = new PackageSpec[Symbol] {
-      def mkPackageDef(prototype: Symbol, stats: List[Tree]): PackageDef = self.mkPackageDef(prototype, stats)
-    }
-  }
-
-  protected def mkPackageDef(name: String, stats: List[Tree]): PackageDef
-  protected def mkPackageDef(name: TermName, stats: List[Tree]): PackageDef
-  protected def mkPackageDef(tree: RefTree, stats: List[Tree]): PackageDef
-  protected def mkPackageDef(sym: Symbol, stats: List[Tree]): PackageDef
-}