Merge pull request scala#3237 from xeno-by/topic/macrodef-returntype-inference

deprecates macro def return type inference

Author: retronym

src/compiler/scala/reflect/macros/compiler/Validators.scala

@@ -155,7 +155,7 @@ trait Validators {
         else mmap(macroDdef.vparamss)(param)
       val macroDefRet =
         if (!macroDdef.tpt.isEmpty) typer.typedType(macroDdef.tpt).tpe
-        else computeMacroDefTypeFromMacroImplRef(macroDdef, macroImplRef)
+        else computeMacroDefTypeFromMacroImplRef(macroDdef, macroImplRef) orElse AnyTpe
       val implReturnType = sigma(increaseMetalevel(ctxPrefix, macroDefRet))
 
       object SigmaTypeMap extends TypeMap {

src/compiler/scala/reflect/macros/util/Helpers.scala

@@ -77,7 +77,8 @@ trait Helpers {
 
   /** Decreases metalevel of the type, i.e. transforms:
    *    * c.Expr[T] to T
-   *    * Anything else to Any
+   *    * Nothing to Nothing
+   *    * Anything else to NoType
    *
    *  @see Metalevels.scala for more information and examples about metalevels
    */
@@ -86,7 +87,10 @@ trait Helpers {
     import runDefinitions._
     transparentShallowTransform(RepeatedParamClass, tp) {
       case ExprClassOf(runtimeType) => runtimeType
-      case _ => AnyTpe // so that macro impls with rhs = ??? don't screw up our inference
+      // special-casing Nothing here is a useful convention
+      // that enables no-hassle prototyping with `macro ???` and `macro { ...; ??? }`
+      case nothing if nothing =:= NothingTpe => NothingTpe
+      case _ => NoType
     }
   }
 }

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

@@ -5517,7 +5517,23 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
 
       val isMacroBodyOkay = !tree.symbol.isErroneous && !(tree1 exists (_.isErroneous)) && tree1 != EmptyTree
       val shouldInheritMacroImplReturnType = ddef.tpt.isEmpty
-      if (isMacroBodyOkay && shouldInheritMacroImplReturnType) computeMacroDefTypeFromMacroImplRef(ddef, tree1) else AnyTpe
+      if (isMacroBodyOkay && shouldInheritMacroImplReturnType) {
+        val commonMessage = "macro defs must have explicitly specified return types"
+        def reportFailure() = {
+          ddef.symbol.setFlag(IS_ERROR)
+          unit.error(ddef.pos, commonMessage)
+        }
+        def reportWarning(inferredType: Type) = {
+          val explanation = s"inference of $inferredType from macro impl's c.Expr[$inferredType] is deprecated and is going to stop working in 2.12"
+          unit.deprecationWarning(ddef.pos, s"$commonMessage ($explanation)")
+        }
+        computeMacroDefTypeFromMacroImplRef(ddef, tree1) match {
+          case ErrorType => ErrorType
+          case NothingTpe => NothingTpe
+          case NoType => reportFailure(); AnyTpe
+          case tpe => reportWarning(tpe); tpe
+        }
+      } else AnyTpe
     }
 
     def transformedOr(tree: Tree, op: => Tree): Tree = transformed remove tree match {

test/files/neg/macro-blackbox-extractor/Macros_1.scala

@@ -2,7 +2,7 @@ import scala.reflect.macros.BlackboxContext
 import language.experimental.macros
 
 object Extractor {
-  def unapply(x: Int) = macro Macros.unapplyImpl
+  def unapply(x: Int): Any = macro Macros.unapplyImpl
 }
 
 object Macros {

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

@@ -11,5 +11,5 @@ object Macros {
     """
   }
 
-  def foo = macro impl
+  def foo: Any = macro impl
 }

test/files/neg/macro-bundle-object.check

@@ -1,5 +1,5 @@
 macro-bundle-object.scala:10: error: macro implementation has incompatible shape:
- required: (c: scala.reflect.macros.BlackboxContext): c.Expr[Any]
+ required: (c: scala.reflect.macros.BlackboxContext): c.Expr[Nothing]
  or      : (c: scala.reflect.macros.BlackboxContext): c.Tree
  found   : : Nothing
 number of parameter sections differ

test/files/neg/macro-invalidret.check

@@ -12,4 +12,24 @@ Macros_Test_2.scala:3: error: macro implementation has incompatible shape:
 type mismatch for return type: reflect.runtime.universe.Literal does not conform to c.Expr[Any]
   def foo2 = macro Impls.foo2
                          ^
-two errors found
+Macros_Test_2.scala:6: error: macro defs must have explicitly specified return types
+  def foo5 = macro Impls.foo5
+      ^
+Macros_Test_2.scala:7: warning: macro defs must have explicitly specified return types (inference of Int from macro impl's c.Expr[Int] is deprecated and is going to stop working in 2.12)
+  def foo6 = macro Impls.foo6
+      ^
+Macros_Test_2.scala:14: error: exception during macro expansion:
+scala.NotImplementedError: an implementation is missing
+	at scala.Predef$.$qmark$qmark$qmark(Predef.scala:227)
+	at Impls$.foo3(Impls_1.scala:7)
+
+  foo3
+  ^
+Macros_Test_2.scala:15: error: macro implementation is missing
+  foo4
+  ^
+Macros_Test_2.scala:17: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
+  foo6
+  ^
+two warnings found
+5 errors found

test/files/neg/macro-invalidret.flags

@@ -1 +1,3 @@
--language:experimental.macros
+-language:experimental.macros
+-Xfatal-warnings
+-deprecation

test/files/neg/macro-invalidret/Impls_1.scala

@@ -4,4 +4,7 @@ import scala.reflect.runtime.{universe => ru}
 object Impls {
   def foo1(c: BlackboxContext) = 2
   def foo2(c: BlackboxContext) = ru.Literal(ru.Constant(42))
+  def foo3(c: BlackboxContext) = ???
+  def foo5(c: BlackboxContext) = c.universe.Literal(c.universe.Constant(42))
+  def foo6(c: BlackboxContext) = c.Expr[Int](c.universe.Literal(c.universe.Constant(42)))
 }

test/files/neg/macro-invalidret/Macros_Test_2.scala

@@ -1,10 +1,18 @@
 object Macros {
   def foo1 = macro Impls.foo1
   def foo2 = macro Impls.foo2
+  def foo3 = macro Impls.foo3
+  def foo4 = macro ???
+  def foo5 = macro Impls.foo5
+  def foo6 = macro Impls.foo6
 }
 
 object Test extends App {
   import Macros._
   foo1
   foo2
+  foo3
+  foo4
+  foo5
+  foo6
 }