Eta-expand 0-arity method if expected type is Function0

Reverse course from the deprecation introduced in 2.12.

(4.3) condition for eta-expansion by -Xsource level:

  - until 2.13:
    - for arity > 0: function or sam type is expected
    - for arity == 0: Function0 is expected -- SAM types do not eta-expand
      because it could be an accidental SAM scala/bug#9489
  - 2.14:
    - for arity > 0: unconditional
    - for arity == 0: a function-ish type of arity 0 is expected (including SAM)

warnings:
  - 2.12: eta-expansion of zero-arg methods was deprecated (scala/bug#7187)
  - 2.13: deprecation dropped in favor of setting the scene for uniform eta-expansion in 3.0
          warning still available under -Xlint:eta-zero
  - 2.14: expected type is a SAM that is not annotated with `@FunctionalInterface`
          if it's a Java-defined interface (under `-Xlint:eta-sam`)

(4.2) condition for auto-application by -Xsource level:

  - until 2.14: none (assuming condition for (4.3) was not met)
  - in 3.0: `meth.isJavaDefined`
    TODO decide -- currently the condition is more involved to give slack to
    Scala methods overriding Java-defined ones; I think we should resolve that
    by introducing slack in overriding e.g. a Java-defined `def toString()`
    by a Scala-defined `def toString`. This also works better for dealing
    with accessors overriding Java-defined methods.

    The current strategy in methodSig is problematic:
    > // Add a () parameter section if this overrides some method with () parameters
    > val vparamSymssOrEmptyParamsFromOverride =

    This means an accessor that overrides a Java-defined method gets a
    MethodType instead of a `NullaryMethodType`, which breaks lots of
    assumptions about accessors

Author: adriaanm

project/ScalaOptionParser.scala

@@ -108,7 +108,7 @@ object ScalaOptionParser {
     "-g" -> List("line", "none", "notailcails", "source", "vars"),
     "-target" -> List("jvm-1.5", "jvm-1.6", "jvm-1.7", "jvm-1.8"))
   private def multiChoiceSettingNames = Map[String, List[String]](
-    "-Xlint" -> List("adapted-args", "nullary-unit", "inaccessible", "nullary-override", "infer-any", "missing-interpolator", "doc-detached", "private-shadow", "type-parameter-shadow", "poly-implicit-overload", "option-implicit", "delayedinit-select", "package-object-classes", "stars-align", "constant", "unused"),
+    "-Xlint" -> List("adapted-args", "nullary-unit", "inaccessible", "nullary-override", "infer-any", "missing-interpolator", "doc-detached", "private-shadow", "type-parameter-shadow", "poly-implicit-overload", "option-implicit", "delayedinit-select", "package-object-classes", "stars-align", "constant", "unused", "eta-zero"),
     "-language" -> List("help", "_", "dynamics", "postfixOps", "reflectiveCalls", "implicitConversions", "higherKinds", "existentials", "experimental.macros"),
     "-opt" -> List("unreachable-code", "simplify-jumps", "compact-locals", "copy-propagation", "redundant-casts", "box-unbox", "nullness-tracking", "closure-invocations" , "allow-skip-core-module-init", "assume-modules-non-null", "allow-skip-class-loading", "inline", "l:none", "l:default", "l:method", "l:inline", "l:project", "l:classpath"),
     "-Ywarn-unused" -> List("imports", "patvars", "privates", "locals", "explicits", "implicits", "params"),

spec/06-expressions.md

@@ -1397,16 +1397,19 @@ type $T$ by evaluating the expression to which $m$ is bound.
 If the method takes only implicit parameters, implicit
 arguments are passed following the rules [here](07-implicits.html#implicit-parameters).
 
-###### Empty Application
-Otherwise, if $e$ has method type $()T$, it is implicitly applied to the empty
-argument list, yielding $e()$.
-
 ###### Eta Expansion
 Otherwise, if the method is not a constructor,
-and the expected type $\mathit{pt}$ is a function type (potentially after sam conversion)
+and the expected type $\mathit{pt}$ is a function type, or,
+for methods of non-zero arity, a type [sam-convertible](#sam-conversion) to a function type,
 $(\mathit{Ts}') \Rightarrow T'$, [eta-expansion](#eta-expansion)
 is performed on the expression $e$.
 
+(The exception for zero-arity methods is to avoid surprises due to unexpected sam conversion.)
+
+###### Empty Application
+Otherwise, if $e$ has method type $()T$, it is implicitly applied to the empty
+argument list, yielding $e()$.
+
 ### Overloading Resolution
 
 If an identifier or selection $e$ references several members of a

src/compiler/scala/tools/nsc/settings/Warnings.scala

@@ -109,6 +109,8 @@ trait Warnings {
     val ImplicitNotFound       = LintWarning("implicit-not-found",        "Check @implicitNotFound and @implicitAmbiguous messages.")
     val Serial                 = LintWarning("serial",                    "@SerialVersionUID on traits and non-serializable classes.")
     val ValPattern             = LintWarning("valpattern",                "Enable pattern checks in val definitions.")
+    val EtaZero                = LintWarning("eta-zero",                  "Warn on eta-expansion (rather than auto-application) of zero-ary method.")
+    val EtaSam                 = LintWarning("eta-sam",                   "Warn on eta-expansion to meet a Java-defined functional interface that is not explicitly annotated with @FunctionalInterface.")
 
     def allLintWarnings = values.toSeq.asInstanceOf[Seq[LintWarning]]
   }
@@ -134,6 +136,8 @@ trait Warnings {
   def lintImplicitNotFound       = lint contains ImplicitNotFound
   def warnSerialization          = lint contains Serial
   def lintValPatterns            = lint contains ValPattern
+  def warnEtaZero                = lint contains EtaZero
+  def warnEtaSam                 = lint contains EtaSam
 
   // The Xlint warning group.
   val lint = MultiChoiceSetting(

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

@@ -785,11 +785,9 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
      *      store these instances in context.undetparams,
      *      unless followed by explicit type application.
      *  (4) Do the following to unapplied methods used as values:
-     *  (4.1) If the method has only implicit parameters pass implicit arguments
-     *  (4.2) otherwise, if the method is nullary with a result type compatible to `pt`
-     *        and it is not a constructor, apply it to ()
-     *  (4.3) otherwise, if `pt` is a function type and method is not a constructor,
-     *        convert to function by eta-expansion,
+     *  (4.1) If the method has only implicit parameters, pass implicit arguments (see adaptToImplicitMethod)
+     *  (4.2) otherwise, if the method is 0-ary and it can be auto-applied (see checkCanAutoApply), apply it to ()
+     *  (4.3) otherwise, if the method is not a constructor, and can be eta-expanded (see checkCanEtaExpand), eta-expand
      *  otherwise issue an error
      *  (5) Convert constructors in a pattern as follows:
      *  (5.1) If constructor refers to a case class factory, set tree's type to the unique
@@ -880,46 +878,109 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
           )
       }
 
-      def instantiateToMethodType(mt: MethodType): Tree = {
-        val meth = tree match {
-          // a partial named application is a block (see comment in EtaExpansion)
-          //
-          // TODO: document why we need to peel off one layer to begin with, and, if we do, why we don't need to recurse??
-          // (and why we don't need to look at the stats to make sure it's the block created by eta-expansion)
-          // I don't see how we call etaExpand on a constructor..
-          //
-          // I guess we don't need to recurse because the outer block and a nested block will refer to the same method
-          // after eta-expansion (if that's what generated these blocks), so we can just look at the outer one.
-          //
-          // How about user-written blocks? Can they ever have a MethodType?
-          case Block(_, tree1) => tree1.symbol
-          case _               => tree.symbol
+      def adaptMethodTypeToExpr(mt: MethodType): Tree = {
+        val meth =
+          tree match {
+            // a partial named application is a block (see comment in EtaExpansion)
+            // How about user-written blocks? Can they ever have a MethodType?
+            case Block(_, tree1) => tree1.symbol
+            case _               => tree.symbol
+          }
+
+
+        val arity = mt.params.length
+
+        val sourceLevel2_14 = currentRun.isScala214
+
+        def warnTree = original orElse tree
+
+        def warnEtaSam() = {
+          val sam = samOf(pt)
+          val samClazz = sam.owner
+          // TODO: we allow a Java class as a SAM type, whereas Java only allows the @FunctionalInterface on interfaces -- align?
+          if (sam.exists && (!samClazz.hasFlag(JAVA) || samClazz.hasFlag(INTERFACE)) && !samClazz.hasAnnotation(definitions.FunctionalInterfaceClass))
+            reporter.warning(tree.pos, s"Eta-expansion performed to meet expected type $pt, which is SAM-equivalent to ${samToFunctionType(pt)},\n" +
+                                       s"even though ${samClazz} is not annotated with `@FunctionalInterface`;\n" +
+                                       s"to suppress warning, add the annotation or write out the equivalent function literal.")
         }
 
-        def cantAdapt =
-          if (context.implicitsEnabled) MissingArgsForMethodTpeError(tree, meth) else UnstableTreeError(tree)
+        // note that isFunctionProto(pt) does not work properly for Function0
+        lazy val ptUnderlying =
+          (pt match {
+            case oapt: OverloadedArgProto => oapt.underlying
+            case pt                       => pt
+          }).dealiasWiden
 
-        // constructors do not eta-expand
-        if (meth.isConstructor) cantAdapt
-        // (4.2) apply to empty argument list
-        else if (mt.params.isEmpty && (settings.isScala213 || !isFunctionType(pt))) {
-          // Starting with 2.13, always insert `()`, regardless of expected type.
-          // On older versions, expected type must not be a FunctionN (can be a SAM)
-          //
-          // scala/bug#7187 deprecates eta-expansion of zero-arg method values (since 2.12; was never introduced for SAM types: scala/bug#9536).
-          // The next step is to also deprecate insertion of `()` (except for java-defined methods), as dotty already requires explicitly writing them.
-          // Once explicit application to () is required, we can more aggressively eta-expand method references, even if they are 0-arity
-          adapt(typed(Apply(tree, Nil) setPos tree.pos), mode, pt, original)
+        // (4.3) condition for eta-expansion by -Xsource level
+        //
+        // until 2.13:
+        //   - for arity > 0: function or sam type is expected
+        //   - for arity == 0: Function0 is expected -- SAM types do not eta-expand because it could be an accidental SAM scala/bug#9489
+        // 2.14:
+        //   - for arity > 0: unconditional
+        //   - for arity == 0: a function-ish type of arity 0 is expected (including SAM)
+        //
+        // warnings:
+        //   - 2.12: eta-expansion of zero-arg methods was deprecated (scala/bug#7187)
+        //   - 2.13: deprecation dropped in favor of setting the scene for uniform eta-expansion in 3.0
+        //           (arity > 0) expected type is a SAM that is not annotated with `@FunctionalInterface`
+        //   - 2.14: (arity == 0) expected type is a SAM that is not annotated with `@FunctionalInterface`
+        def checkCanEtaExpand(): Boolean = {
+          def expectingSamOfArity = {
+            val sam = samOf(ptUnderlying)
+            sam.exists && sam.info.params.lengthCompare(arity) == 0
+          }
+
+          val expectingFunctionOfArity = {
+            val ptSym = ptUnderlying.typeSymbolDirect
+            (ptSym eq FunctionClass(arity)) || (arity > 0 && (ptSym eq FunctionClass(1))) // allowing for tupling conversion
+          }
+
+          val doIt =
+            if (arity == 0) {
+              val doEtaZero =
+                expectingFunctionOfArity || sourceLevel2_14 && expectingSamOfArity
+
+              if (doEtaZero && settings.warnEtaZero) {
+                val ptHelp =
+                  if (expectingFunctionOfArity) pt
+                  else s"$pt, which is SAM-equivalent to ${samToFunctionType(pt)}"
+
+                reporter.warning(tree.pos, s"An unapplied 0-arity method was eta-expanded (due to the expected type ${ptHelp}), rather than applied to `()`.\n" +
+                                           s"Write ${Apply(warnTree, Nil)} to invoke method ${meth.decodedName}, or change the expected type.")
+              }
+              doEtaZero
+            } else sourceLevel2_14 || expectingFunctionOfArity || expectingSamOfArity
+
+          if (doIt && !expectingFunctionOfArity && settings.warnEtaSam) warnEtaSam()
+
+          doIt
         }
-        // (4.3) eta-expand method value when function or sam type is expected (for experimentation, always eta-expand under 2.14 source level)
-        else if (isFunctionProto(pt) || settings.isScala214) { // TODO: decide on `settings.isScala214`
-          if (settings.isScala212 && mt.params.isEmpty) // implies isFunctionType(pt)
-             currentRun.reporting.deprecationWarning(tree.pos, NoSymbol, "Eta-expansion of zero-argument methods is deprecated. "+
-                    s"To avoid this warning, write ${Function(Nil, Apply(tree, Nil))}.", "2.12.0")
 
-          typedEtaExpansion(tree, mode, pt)
+
+        // (4.2) condition for auto-application by -Xsource level
+        //
+        // until 2.14: none (assuming condition for (4.3) was not met)
+        // in 3.0: `meth.isJavaDefined`
+        //         (TODO decide -- currently the condition is more involved to give slack to Scala methods overriding Java-defined ones;
+        //          I think we should resolve that by introducing slack in overriding e.g. a Java-defined `def toString()` by a Scala-defined `def toString`.
+        //          This also works better for dealing with accessors overriding Java-defined methods. The current strategy in methodSig is problematic:
+        //          > // Add a () parameter section if this overrides some method with () parameters
+        //          > val vparamSymssOrEmptyParamsFromOverride =
+        //          This means an accessor that overrides a Java-defined method gets a MethodType instead of a NullaryMethodType, which breaks lots of assumptions about accessors)
+        def checkCanAutoApply(): Boolean = {
+          if (sourceLevel2_14 && !meth.isJavaDefined)
+            context.deprecationWarning(tree.pos, NoSymbol, s"Auto-application to `()` is deprecated. Supply the empty argument list `()` explicitly to invoke method ${meth.decodedName},\n" +
+                                                           s"or remove the empty argument list from its definition (Java-defined methods are exempt).\n"+
+                                                           s"In Scala 3, an unapplied method like this will be eta-expanded into a function.", "2.14.0")
+          true
         }
-        else cantAdapt
+
+        if (!meth.isConstructor && checkCanEtaExpand()) typedEtaExpansion(tree, mode, pt)
+        else if (arity == 0 && checkCanAutoApply()) adapt(typed(Apply(tree, Nil) setPos tree.pos), mode, pt, original)
+        else
+          if (context.implicitsEnabled) MissingArgsForMethodTpeError(tree, meth) // `context.implicitsEnabled` implies we are not in a pattern
+          else UnstableTreeError(tree)
       }
 
       def adaptType(): Tree = {
@@ -1209,8 +1270,8 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
 
         case mt: MethodType if mode.typingExprNotFunNotLhs && mt.isImplicit => // (4.1)
           adaptToImplicitMethod(mt)
-        case mt: MethodType if mode.typingExprNotFunNotLhs && !hasUndetsInMonoMode && !treeInfo.isMacroApplicationOrBlock(tree) =>
-          instantiateToMethodType(mt)
+        case mt: MethodType if mode.typingExprNotFunNotLhs && !hasUndetsInMonoMode && !treeInfo.isMacroApplicationOrBlock(tree) => // (4.2) - (4.3)
+          adaptMethodTypeToExpr(mt)
         case _ =>
           vanillaAdapt(tree)
       }

src/reflect/scala/reflect/internal/Definitions.scala

@@ -728,7 +728,7 @@ trait Definitions extends api.StandardDefinitions {
     // Are we expecting something function-ish? This considers FunctionN / SAM / ProtoType that matches functions
     def isFunctionProto(pt: Type): Boolean =
       (isFunctionType(pt)
-       || (pt match { case pt: ProtoType => pt.expectsFunctionType  case _ => false })
+       || (pt match { case pt: ProtoType => pt.expectsFunctionType  case _ => false }) // TODO: this does not work for Function0
        || samOf(pt).exists
       )
 

test/files/jvm/future-spec/FutureTests.scala

@@ -1,5 +1,3 @@
-/* scalac: -Xsource:3.0 */
-
 import scala.concurrent._
 import scala.concurrent.duration._
 import scala.concurrent.duration.Duration.Inf
@@ -41,8 +39,7 @@ class FutureTests extends MinimalScalaTest {
       val ms = new concurrent.TrieMap[Throwable, Unit]
       implicit val ec = scala.concurrent.ExecutionContext.fromExecutor(new java.util.concurrent.ForkJoinPool(), {
         t =>
-        val u = ()
-        ms += (t -> u)
+        ms.addOne((t, ()))
       })
 
       class ThrowableTest(m: String) extends Throwable(m)

test/files/neg/t7187-2.14.check

@@ -1,11 +1,24 @@
-t7187-2.14.scala:8: error: type mismatch;
+t7187-2.14.scala:13: error: type mismatch;
  found   : Int
  required: () => Any
   val t1: () => Any  = m1   // error
                        ^
-t7187-2.14.scala:9: error: type mismatch;
- found   : Int
- required: () => Any
-  val t2: () => Any  = m2   // error, no eta-expansion of zero-args methods
+t7187-2.14.scala:14: warning: An unapplied 0-arity method was eta-expanded (due to the expected type () => Any), rather than applied to `()`.
+Write m2() to invoke method m2, or change the expected type.
+  val t2: () => Any  = m2   // eta-expanded with lint warning
+                       ^
+t7187-2.14.scala:15: warning: An unapplied 0-arity method was eta-expanded (due to the expected type AcciSamZero, which is SAM-equivalent to () => Int), rather than applied to `()`.
+Write m2() to invoke method m2, or change the expected type.
+  val t2AcciSam: AcciSamZero = m2   // eta-expanded with lint warning + sam warning
+                               ^
+t7187-2.14.scala:15: warning: Eta-expansion performed to meet expected type AcciSamZero, which is SAM-equivalent to () => Int,
+even though trait AcciSamZero is not annotated with `@FunctionalInterface`;
+to suppress warning, add the annotation or write out the equivalent function literal.
+  val t2AcciSam: AcciSamZero = m2   // eta-expanded with lint warning + sam warning
+                               ^
+t7187-2.14.scala:16: warning: An unapplied 0-arity method was eta-expanded (due to the expected type SamZero, which is SAM-equivalent to () => Int), rather than applied to `()`.
+Write m2() to invoke method m2, or change the expected type.
+  val t2Sam: SamZero = m2   // eta-expanded with lint warning
                        ^
-two errors found
+four warnings found
+one error found

test/files/neg/t7187-2.14.scala

@@ -1,12 +1,19 @@
-// scalac: -Xsource:2.14
+// scalac: -Xsource:2.14 -Xlint:eta-zero -Xlint:eta-sam
 //
+trait AcciSamZero { def apply(): Int }
+
+@FunctionalInterface
+trait SamZero { def apply(): Int }
+
 class EtaExpand214 {
   def m1 = 1
   def m2() = 1
   def m3(x: Int) = x
 
   val t1: () => Any  = m1   // error
-  val t2: () => Any  = m2   // error, no eta-expansion of zero-args methods
+  val t2: () => Any  = m2   // eta-expanded with lint warning
+  val t2AcciSam: AcciSamZero = m2   // eta-expanded with lint warning + sam warning
+  val t2Sam: SamZero = m2   // eta-expanded with lint warning
   val t3: Int => Any = m3   // ok
 
   val t4 = m1 // apply