Reject trailing _ syntax under -strict mode.

The reason to do this only under -strict mode for now is so that
we can still compile the same code under both Scala 2 and Dotty.
If we rejected trailing `_` outright, Scala 2 code would need to
get either explicitly eta-expanded or get an expected type to still work.
But in Dotty, we can simply drop `_` for functions with arity >= 1.
So to keep code dual compilable, we'd need to add boilerplate
which under Dotty would be no longer needed.

Author: odersky

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -1538,15 +1538,31 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     val pt1 = if (defn.isFunctionType(pt)) pt else AnyFunctionProto
     var res = typed(qual, pt1)
     if (pt1.eq(AnyFunctionProto) && !defn.isFunctionClass(res.tpe.classSymbol)) {
-      def msg = i"not a function: ${res.tpe}; cannot be followed by `_'"
+      ctx.errorOrMigrationWarning(i"not a function: ${res.tpe}; cannot be followed by `_'", tree.pos)
       if (ctx.scala2Mode) {
         // Under -rewrite, patch `x _` to `(() => x)`
-        ctx.migrationWarning(msg, tree.pos)
         patch(Position(tree.pos.start), "(() => ")
         patch(Position(qual.pos.end, tree.pos.end), ")")
         res = typed(untpd.Function(Nil, untpd.TypedSplice(res)))
       }
-      else ctx.error(msg, tree.pos)
+    }
+    else if (ctx.settings.strict.value) {
+      lazy val (prefix, suffix) = res match {
+        case Block(mdef @ DefDef(_, _, vparams :: Nil, _, _) :: Nil, _: Closure) =>
+          val arity = vparams.length
+          if (arity > 0) ("", "") else ("(() => ", "())")
+        case _ =>
+          ("(() => ", ")")
+      }
+      def remedy =
+        if ((prefix ++ suffix).isEmpty) "simply leave out the trailing ` _`"
+        else s"use `$prefix<function>$suffix` instead"
+      ctx.errorOrMigrationWarning(i"""The syntax `<function> _` is no longer supported;
+                                     |you can $remedy""", tree.pos)
+      if (ctx.scala2Mode) {
+        patch(Position(tree.pos.start), prefix)
+        patch(Position(qual.pos.end, tree.pos.end), suffix)
+      }
     }
     res
   }
@@ -2053,7 +2069,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
 
         // Reasons NOT to eta expand:
         //  - we reference a constructor
-        //  - we are in a patterm
+        //  - we are in a pattern
         //  - the current tree is a synthetic apply which is not expandable (eta-expasion would simply undo that)
         if (arity >= 0 &&
             !tree.symbol.isConstructor &&

compiler/test/dotc/tests.scala

@@ -196,6 +196,7 @@ class tests extends CompilerTest {
   @Test def neg_valueclasses_doubledefs = compileFile(negCustomArgs, "valueclasses-doubledefs")(allowDoubleBindings)
   @Test def neg_valueclasses_doubledefs2 = compileFile(negCustomArgs, "valueclasses-doubledefs2")(allowDoubleBindings)
   @Test def neg_valueclasses_pavlov = compileFile(negCustomArgs, "valueclasses-pavlov")(allowDoubleBindings)
+  @Test def neg_trailingUnderscore = compileFile(negCustomArgs, "trailingUnderscore")(List("-strict"))
 
   val negTailcallDir = negDir + "tailcall/"
   @Test def neg_tailcall_t1672b = compileFile(negTailcallDir, "t1672b")

tests/neg/customArgs/trailingUnderscore.scala

@@ -0,0 +1,11 @@
+// to be compiled with -strict
+object trailingUnderscore {
+
+  def f(x: Int) = x
+  def g() = f(2)
+  def h = g()
+
+  val x1 = f _ // error
+  val x2 = g _ // error
+  val x3 = h _ // error
+}