Fine-tune condition when to eta expand

Author: odersky

compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -477,7 +477,9 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
     case _ => false
   }
 
-  /** Is tree a compiler-generated `.apply` node? */
+  /** Is tree a compiler-generated `.apply` node that refers to the
+   *  apply of a function class? (implicit functions are excluded)
+   */
   def isSyntheticApply(tree: Tree): Boolean = tree match {
     case Select(qual, nme.apply) => tree.pos.end == qual.pos.end
     case _ => false

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -809,8 +809,8 @@ class Definitions {
    */
   def erasedFunctionClass(cls: Symbol): Symbol = {
     val arity = scalaClassName(cls).functionArity
-    if (arity > 22) defn.FunctionXXLClass
-    else if (arity >= 0) defn.FunctionClass(arity)
+    if (arity > 22) FunctionXXLClass
+    else if (arity >= 0) FunctionClass(arity)
     else NoSymbol
   }
 

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

@@ -2011,17 +2011,25 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
             if (nparams > 0 || pt.eq(AnyFunctionProto)) nparams
             else -1 // no eta expansion in this case
           }
-
-        if (wtp.isImplicit)
-          err.typeMismatch(tree, pt)
-        else if (arity >= 0 &&
-                 !tree.symbol.isConstructor &&
-                 !ctx.mode.is(Mode.Pattern) &&
-                 !isApplyProto(pt) &&
-                 !isSyntheticApply(tree))
+        def isExpandableApply =
+          defn.isImplicitFunctionClass(tree.symbol.maybeOwner) && defn.isFunctionType(ptNorm)
+
+        // Reasons NOT to eta expand:
+        //  - we reference a constructor
+        //  - we are in a patterm
+        //  - the current tree is a synthetic non-implicit apply (eta-expasion would simply undo that)
+        //  - the current tree is a synthetic implicit apply and the expected
+        //    type is a function type (this rule is needed so we can pass an implicit function
+        //    to a regular function type)
+        if (arity >= 0 &&
+            !tree.symbol.isConstructor &&
+            !ctx.mode.is(Mode.Pattern) &&
+            !(isSyntheticApply(tree) && !isExpandableApply))
           typed(etaExpand(tree, wtp, arity), pt)
         else if (wtp.paramInfos.isEmpty)
           adaptInterpolated(tpd.Apply(tree, Nil), pt, EmptyTree)
+        else if (wtp.isImplicit)
+          err.typeMismatch(tree, pt)
         else
           missingArgs
       case _ =>