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)
  - 3.0: auto-application takes precedence, but otherwise we always eta-expand

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
  - 2.14: expected type is a SAM that is not annotated with `@FunctionalInterface`

(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`

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,7 @@ 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.")
 
     def allLintWarnings = values.toSeq.asInstanceOf[Seq[LintWarning]]
   }
@@ -134,6 +135,7 @@ trait Warnings {
   def lintImplicitNotFound       = lint contains ImplicitNotFound
   def warnSerialization          = lint contains Serial
   def lintValPatterns            = lint contains ValPattern
+  def warnEtaZero                = lint contains EtaZero
 
   // The Xlint warning group.
   val lint = MultiChoiceSetting(

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

@@ -779,11 +779,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 canAutoApply), apply it to ()
+     *  (4.3) otherwise, if the method is not a constructor, and can be eta-expanded (see canEtaExpand), 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
@@ -874,46 +872,98 @@ 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
+          }
 
-        def cantAdapt =
-          if (context.implicitsEnabled) MissingArgsForMethodTpeError(tree, meth) else UnstableTreeError(tree)
 
-        // 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)
+        val arity = mt.params.length
+
+        val sourceLevel2_14 = settings.isScala214
+        val sourceLevel3 = sourceLevel2_14 && settings.isScala300
+
+        def warnTree = original orElse tree
+
+        def 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.")
+        }
+
+        def warnEtaSam() = {
+          val sam = samOf(pt)
+          if (sam.exists && !sam.owner.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 ${sam.owner} is not annotated with `@FunctionalInterface`; add annotation to suppress warning.")
         }
-        // (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)
+        // note that isFunctionProto(pt) does not work properly for Function0
+        lazy val ptUnderlying =
+          (pt match {
+            case oapt: OverloadedArgFunProto => oapt.underlying
+            case pt                          => pt
+          }).dealiasWiden
+
+        lazy val expectingFunctionOfArity = {
+          val ptSym = ptUnderlying.typeSymbolDirect
+          (ptSym eq FunctionClass(arity)) || (arity > 0 && (ptSym eq FunctionClass(1))) // allowing for tupling conversion
+        }
+        lazy val expectingSamOfArity = {
+          val sam = samOf(ptUnderlying)
+          sam.exists && sam.info.params.lengthCompare(arity) == 0
         }
-        else cantAdapt
+
+        // (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)
+        // 3.0: auto-application takes precedence, but otherwise we always eta-expand
+        //
+        // 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 canEtaExpand: Boolean =
+          if (arity == 0) {
+            val doEtaZero =
+              if (sourceLevel3) !canAutoApply
+              else expectingFunctionOfArity || sourceLevel2_14 && expectingSamOfArity
+
+            doEtaZero && { if (settings.warnEtaZero) warnEtaZero(); true }
+          } else sourceLevel2_14 || expectingFunctionOfArity || expectingSamOfArity
+
+
+        // (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`
+        def canAutoApply: Boolean =
+          if (sourceLevel3) meth.isJavaDefined
+          else {
+            if (sourceLevel2_14 && !meth.isJavaDefined)
+              context.deprecationWarning(tree.pos, NoSymbol, s"Auto-application to `()` is deprecated. Write ${Apply(warnTree, Nil)} to invoke method ${meth.decodedName}," +
+                                                             s"or remove the empty argument list from its definition (Java-defined methods are exempt).\n"+
+                                                             s"In Scala 3, an unapplied method will be eta-expanded, as in: ${Function(Nil, Apply(warnTree, Nil))}.", "2.14.0")
+            true
+          }
+
+        if (!meth.isConstructor && canEtaExpand) { if (!expectingFunctionOfArity) warnEtaSam(); typedEtaExpansion(tree, mode, pt) }
+        else if (arity == 0 && canAutoApply) 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 = {
@@ -1200,8 +1250,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

@@ -729,7 +729,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/neg/t7187-2.14.check

@@ -1,11 +1,23 @@
-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`; add annotation to suppress warning.
+  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
 //
+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

test/files/neg/t7187.check

@@ -1,40 +1,46 @@
-t7187.scala:8: error: _ must follow method; cannot follow () => String
+t7187.scala:12: warning: An unapplied 0-arity method was eta-expanded (due to the expected type () => Any), rather than applied to `()`.
+Write foo() to invoke method foo, or change the expected type.
+  val t1b: () => Any = foo   // eta-expansion, but lint warning
+                       ^
+t7187.scala:16: error: _ must follow method; cannot follow () => String
   val t1f: Any       = foo() _ // error: _ must follow method
                           ^
-t7187.scala:11: error: type mismatch;
+t7187.scala:19: error: type mismatch;
  found   : String
  required: () => Any
-  val t2a: () => Any = bar   // error: no eta-expansion of zero-arglist-methods
+  val t2a: () => Any = bar   // error: no eta-expansion of zero-arglist-methods (nullary methods)
                        ^
-t7187.scala:12: error: not enough arguments for method apply: (i: Int)Char in class StringOps.
+t7187.scala:20: error: not enough arguments for method apply: (i: Int)Char in class StringOps.
 Unspecified value parameter i.
   val t2b: () => Any = bar() // error: bar doesn't take arguments, so expanded to bar.apply(), which misses an argument
                           ^
-t7187.scala:15: error: not enough arguments for method apply: (i: Int)Char in class StringOps.
+t7187.scala:23: error: not enough arguments for method apply: (i: Int)Char in class StringOps.
 Unspecified value parameter i.
   val t2e: Any       = bar() _ // error: not enough arguments for method apply
                           ^
-t7187.scala:18: error: type mismatch;
- found   : String
- required: () => Any
-  val t3a: () => Any = baz   // eta-expansion (deprecated) in 2.12, error in 2.13
+t7187.scala:26: warning: An unapplied 0-arity method was eta-expanded (due to the expected type () => Any), rather than applied to `()`.
+Write baz() to invoke method baz, or change the expected type.
+  val t3a: () => Any = baz   // eta-expansion, but lint warning
                        ^
-t7187.scala:21: error: _ must follow method; cannot follow String
+t7187.scala:29: error: _ must follow method; cannot follow String
   val t3d: Any       = baz() _ // error: _ must follow method
                           ^
-t7187.scala:24: error: type mismatch;
- found   : String
- required: () => Any
-  val t4a: () => Any = zap     // eta-expansion (deprecated) in 2.12, error in 2.13
+t7187.scala:32: warning: An unapplied 0-arity method was eta-expanded (due to the expected type () => Any), rather than applied to `()`.
+Write zap() to invoke method zap, or change the expected type.
+  val t4a: () => Any = zap     // eta-expansion, but lint warning
                        ^
-t7187.scala:25: error: type mismatch;
- found   : String
- required: () => Any
+t7187.scala:33: warning: An unapplied 0-arity method was eta-expanded (due to the expected type () => Any), rather than applied to `()`.
+Write zap()() to invoke method zap, or change the expected type.
   val t4b: () => Any = zap()   // ditto
                           ^
-t7187.scala:30: error: missing argument list for method zup in class EtaExpandZeroArg
+t7187.scala:38: error: missing argument list for method zup in class EtaExpandZeroArg
 Unapplied methods are only converted to functions when a function type is expected.
 You can make this conversion explicit by writing `zup _` or `zup(_)` instead of `zup`.
   val t5a = zup // error in 2.13, eta-expansion in 2.14
             ^
-9 errors found
+t7187.scala:40: warning: Eta-expansion performed to meet expected type AcciSamOne, which is SAM-equivalent to Int => Int,
+even though trait AcciSamOne is not annotated with `@FunctionalInterface`; add annotation to suppress warning.
+  val t5AcciSam: AcciSamOne = zup // ok, but warning
+                              ^
+5 warnings found
+6 errors found