blackbox restriction #1: can't refine the official return type

When an application of a blackbox macro expands into a tree `x`,
the expansion is wrapped into a type ascription `(x: T)`, where `T` is
the declared return type of the blackbox macro with type arguments and
path dependencies applied in consistency with the particular macro
application being expanded.

This invalidates blackbox macros as an implementation vehicle
of type providers.

Author: xeno-by

src/compiler/scala/tools/nsc/typechecker/Macros.scala

@@ -604,21 +604,27 @@ trait Macros extends FastTrack with MacroRuntimes with Traces with Helpers {
    */
   def macroExpandApply(typer: Typer, expandee: Tree, mode: Mode, pt: Type): Tree = {
     object expander extends TermMacroExpander(APPLY_ROLE, typer, expandee, mode, pt) {
-      override def onSuccess(expanded: Tree) = {
+      override def onSuccess(expanded0: Tree) = {
+        def approximate(tp: Type) = {
+          // approximation is necessary for whitebox macros to guide type inference
+          // read more in the comments for onDelayed below
+          if (isBlackbox(expandee)) tp
+          else {
+            val undetparams = tp collect { case tp if tp.typeSymbol.isTypeParameter => tp.typeSymbol }
+            deriveTypeWithWildcards(undetparams)(tp)
+          }
+        }
+        val macroPt = approximate(if (isNullaryInvocation(expandee)) expandee.tpe.finalResultType else expandee.tpe)
+        val expanded = if (isBlackbox(expandee)) atPos(enclosingMacroPosition.focus)(Typed(expanded0, TypeTree(macroPt))) else expanded0
+
         // prematurely annotate the tree with a macro expansion attachment
         // so that adapt called indirectly by typer.typed knows that it needs to apply the existential fixup
         linkExpandeeAndExpanded(expandee, expanded)
-        // approximation is necessary for whitebox macros to guide type inference
-        // read more in the comments for onDelayed below
-        def approximate(tp: Type) = {
-          val undetparams = tp collect { case tp if tp.typeSymbol.isTypeParameter => tp.typeSymbol }
-          deriveTypeWithWildcards(undetparams)(tp)
-        }
-        val macroPtApprox = approximate(if (isNullaryInvocation(expandee)) expandee.tpe.finalResultType else expandee.tpe)
+
         // `macroExpandApply` is called from `adapt`, where implicit conversions are disabled
         // therefore we need to re-enable the conversions back temporarily
-        if (macroDebugVerbose) println(s"typecheck #1 (against macroPtApprox = $macroPtApprox): $expanded")
-        val expanded1 = typer.context.withImplicitsEnabled(typer.typed(expanded, mode, macroPtApprox))
+        if (macroDebugVerbose) println(s"typecheck #1 (against macroPt = $macroPt): $expanded")
+        val expanded1 = typer.context.withImplicitsEnabled(typer.typed(expanded, mode, macroPt))
         if (expanded1.isErrorTyped) {
           if (macroDebugVerbose) println(s"typecheck #1 has failed: ${typer.context.reportBuffer.errors}")
           expanded1

test/files/neg/macro-blackbox-structural.check

@@ -0,0 +1,4 @@
+Test_2.scala:4: error: value x is not a member of Any
+  println(Macros.foo.x)
+                     ^
+one error found

test/files/neg/macro-blackbox-structural/Impls_Macros_1.scala

@@ -0,0 +1,15 @@
+import scala.language.experimental.macros
+
+object Macros {
+  def impl(c: scala.reflect.macros.BlackboxContext) = {
+    import c.universe._
+    q"""
+      trait Foo {
+        def x = 2
+      }
+      new Foo {}
+    """
+  }
+
+  def foo = macro impl
+}

test/files/neg/macro-blackbox-structural/Test_2.scala

@@ -0,0 +1,5 @@
+import Macros._
+
+object Test extends App {
+  println(Macros.foo.x)
+}

test/files/neg/t5903a/Macros_1.scala

@@ -1,4 +1,4 @@
-import scala.reflect.macros.BlackboxContext
+import scala.reflect.macros.WhiteboxContext
 import language.experimental.macros
 
 trait Tree
@@ -13,7 +13,7 @@ object NewQuasiquotes {
 }
 
 object QuasiquoteMacros {
-  def unapplyImpl(c: BlackboxContext)(t: c.Tree) = {
+  def unapplyImpl(c: WhiteboxContext)(t: c.Tree) = {
     import c.universe._
     q"""
       new {

test/files/neg/t5903e/Macros_1.scala

@@ -1,4 +1,4 @@
-import scala.reflect.macros.BlackboxContext
+import scala.reflect.macros.WhiteboxContext
 import language.experimental.macros
 
 object Interpolation {
@@ -10,7 +10,7 @@ object Interpolation {
 }
 
 object Macros {
-  def unapplyImpl(c: BlackboxContext)(x: c.Tree) = {
+  def unapplyImpl(c: WhiteboxContext)(x: c.Tree) = {
     import c.universe._
     q"""
       new {

test/files/run/macro-bodyexpandstoimpl/Impls_1.scala

@@ -1,11 +1,11 @@
 import scala.language.experimental.macros
-import scala.reflect.macros.BlackboxContext
+import scala.reflect.macros.{BlackboxContext, WhiteboxContext}
 
 object Impls {
   def foo(c: BlackboxContext)(x: c.Expr[Int]) = x
 
   def refToFoo(dummy: Int) = macro refToFoo_impl
-  def refToFoo_impl(c: BlackboxContext)(dummy: c.Expr[Int]) = {
+  def refToFoo_impl(c: WhiteboxContext)(dummy: c.Expr[Int]) = {
     import c.universe._
     val body = Select(Ident(TermName("Impls")), TermName("foo"))
     val global = c.universe.asInstanceOf[scala.tools.nsc.Global]

test/files/run/macro-expand-unapply-a/Impls_Macros_1.scala

@@ -1,11 +1,11 @@
-import scala.reflect.macros.BlackboxContext
+import scala.reflect.macros.WhiteboxContext
 
 object Helper {
   def unapplySeq[T](x: List[T]): Option[Seq[T]] = List.unapplySeq[T](x)
 }
 
 object Macros {
-  def impl[T: c.WeakTypeTag](c: BlackboxContext)(x: c.Expr[List[T]]) = {
+  def impl[T: c.WeakTypeTag](c: WhiteboxContext)(x: c.Expr[List[T]]) = {
     c.universe.reify(Helper.unapplySeq(x.splice))
   }
 

test/files/run/macro-invalidusage-badret.check

@@ -1,5 +1,5 @@
 reflective compilation has failed:
 
 type mismatch;
- found   : Int(42)
+ found   : Int
  required: String

test/files/run/macro-system-properties.check

@@ -14,9 +14,15 @@ scala>     object GrabContext {
 defined object GrabContext
 
 scala>     object Test { class C(implicit a: Any) { GrabContext.grab } }
+<console>:12: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
+           object Test { class C(implicit a: Any) { GrabContext.grab } }
+                                                                ^
 defined object Test
 
 scala>     object Test { class C(implicit a: Any) { GrabContext.grab } }
+<console>:12: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
+           object Test { class C(implicit a: Any) { GrabContext.grab } }
+                                                                ^
 defined object Test
 
 scala>