blackbox restriction #3: can't affect implicit search

When an application of a blackbox macro is used as an implicit candidate,
no expansion is performed until the macro is selected as the result of
the implicit search.

This makes it impossible to dynamically calculate availability of
implicit macros.

3 files changed, 33 insertions, 33 deletions

diff --git a/src/reflect/scala/reflect/macros/Enclosures.scala b/src/reflect/scala/reflect/macros/Enclosures.scala
index c3d019ccf3..31905c4739 100644
--- a/src/reflect/scala/reflect/macros/Enclosures.scala
+++ b/src/reflect/scala/reflect/macros/Enclosures.scala
@@ -45,18 +45,6 @@ trait Enclosures {
    */
   def enclosingMacros: List[BlackboxContext]
 
-  /** Information about one of the currently considered implicit candidates.
-   *  Candidates are used in plural form, because implicit parameters may themselves have implicit parameters,
-   *  hence implicit searches can recursively trigger other implicit searches.
-   *
-   *  Can be useful to get information about an application with an implicit parameter that is materialized during current macro expansion.
-   *  If we're in an implicit macro being expanded, it's included in this list.
-   *
-   *  Unlike `openImplicits`, this is a val, which means that it gets initialized when the context is created
-   *  and always stays the same regardless of whatever happens during macro expansion.
-   */
-  def enclosingImplicits: List[ImplicitCandidate]
-
   /** Tries to guess a position for the enclosing application.
    *  But that is simple, right? Just dereference `pos` of `macroApplication`? Not really.
    *  If we're in a synthetic macro expansion (no positions), we must do our best to infer the position of something that triggerd this expansion.
diff --git a/src/reflect/scala/reflect/macros/Typers.scala b/src/reflect/scala/reflect/macros/Typers.scala
index ec90ee8fe6..29c1af110b 100644
--- a/src/reflect/scala/reflect/macros/Typers.scala
+++ b/src/reflect/scala/reflect/macros/Typers.scala
@@ -23,27 +23,6 @@ trait Typers {
    */
   def openMacros: List[BlackboxContext]
 
-  /** Information about one of the currently considered implicit candidates.
-   *  Candidates are used in plural form, because implicit parameters may themselves have implicit parameters,
-   *  hence implicit searches can recursively trigger other implicit searches.
-   *
-   *  `pre` and `sym` provide information about the candidate itself.
-   *  `pt` and `tree` store the parameters of the implicit search the candidate is participating in.
-   */
-  case class ImplicitCandidate(pre: Type, sym: Symbol, pt: Type, tree: Tree)
-
-  /** Information about one of the currently considered implicit candidates.
-   *  Candidates are used in plural form, because implicit parameters may themselves have implicit parameters,
-   *  hence implicit searches can recursively trigger other implicit searches.
-   *
-   *  Can be useful to get information about an application with an implicit parameter that is materialized during current macro expansion.
-   *  If we're in an implicit macro being expanded, it's included in this list.
-   *
-   *  Unlike `enclosingImplicits`, this is a def, which means that it gets recalculated on every invocation,
-   *  so it might change depending on what is going on during macro expansion.
-   */
-  def openImplicits: List[ImplicitCandidate]
-
   /** Typechecks the provided tree against the expected type `pt` in the macro callsite context.
    *
    *  If `silent` is false, `TypecheckException` will be thrown in case of a typecheck error.
diff --git a/src/reflect/scala/reflect/macros/WhiteboxContext.scala b/src/reflect/scala/reflect/macros/WhiteboxContext.scala
index 76bc17746c..9d65a5c16e 100644
--- a/src/reflect/scala/reflect/macros/WhiteboxContext.scala
+++ b/src/reflect/scala/reflect/macros/WhiteboxContext.scala
@@ -40,4 +40,37 @@ trait WhiteboxContext extends BlackboxContext {
   /** @inheritdoc
    */
   def enclosingMacros: List[WhiteboxContext]
+
+  /** Information about one of the currently considered implicit candidates.
+   *  Candidates are used in plural form, because implicit parameters may themselves have implicit parameters,
+   *  hence implicit searches can recursively trigger other implicit searches.
+   *
+   *  `pre` and `sym` provide information about the candidate itself.
+   *  `pt` and `tree` store the parameters of the implicit search the candidate is participating in.
+   */
+  case class ImplicitCandidate(pre: Type, sym: Symbol, pt: Type, tree: Tree)
+
+  /** Information about one of the currently considered implicit candidates.
+   *  Candidates are used in plural form, because implicit parameters may themselves have implicit parameters,
+   *  hence implicit searches can recursively trigger other implicit searches.
+   *
+   *  Can be useful to get information about an application with an implicit parameter that is materialized during current macro expansion.
+   *  If we're in an implicit macro being expanded, it's included in this list.
+   *
+   *  Unlike `enclosingImplicits`, this is a def, which means that it gets recalculated on every invocation,
+   *  so it might change depending on what is going on during macro expansion.
+   */
+  def openImplicits: List[ImplicitCandidate]
+
+  /** Information about one of the currently considered implicit candidates.
+   *  Candidates are used in plural form, because implicit parameters may themselves have implicit parameters,
+   *  hence implicit searches can recursively trigger other implicit searches.
+   *
+   *  Can be useful to get information about an application with an implicit parameter that is materialized during current macro expansion.
+   *  If we're in an implicit macro being expanded, it's included in this list.
+   *
+   *  Unlike `openImplicits`, this is a val, which means that it gets initialized when the context is created
+   *  and always stays the same regardless of whatever happens during macro expansion.
+   */
+  def enclosingImplicits: List[ImplicitCandidate]
 }
\ No newline at end of file