Avoid over-eager eta-expansion

For neg/typedapply.scala we had an infinite sequence of
eta-expansions, followed by `.apply` selections.

Author: odersky

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

@@ -280,6 +280,13 @@ trait UntypedTreeInfo extends TreeInfo[Untyped] { self: Trees.Instance[Untyped]
     case _ => false
   }
 
+  /** Is tree a Function or Closure node, possibly preceded by definitions? (currently unused) */
+  def isClosure(tree: Tree)(implicit ctx: Context): Boolean = unsplice(tree) match {
+    case _: Function | _: Closure => true
+    case Block(_, expr) => isClosure(expr)
+    case _ => false
+  }
+
   /** Is `tree` an implicit function or closure, possibly nested in a block? */
   def isImplicitClosure(tree: Tree)(implicit ctx: Context): Boolean = unsplice(tree) match {
     case Function((param: untpd.ValDef) :: _, _) => param.mods.is(Implicit)
@@ -470,6 +477,12 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
     case _ => false
   }
 
+  /** Is tree a compiler-generated `.apply` node? */
+  def isSyntheticApply(tree: Tree): Boolean = tree match {
+    case Select(qual, nme.apply) => tree.pos.end == qual.pos.end
+    case _ => false
+  }
+
   /** Strips layers of `.asInstanceOf[T]` / `_.$asInstanceOf[T]()` from an expression */
   def stripCast(tree: Tree)(implicit ctx: Context): Tree = {
     def isCast(sel: Tree) = sel.symbol == defn.Any_asInstanceOf

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

@@ -2012,12 +2012,16 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
             else -1 // no eta expansion in this case
           }
 
-        if (arity >= 0 && !tree.symbol.isConstructor && !ctx.mode.is(Mode.Pattern))
+        if (wtp.isImplicit)
+          err.typeMismatch(tree, pt)
+        else if (arity >= 0 &&
+                 !tree.symbol.isConstructor &&
+                 !ctx.mode.is(Mode.Pattern) &&
+                 !isApplyProto(pt) &&
+                 !isSyntheticApply(tree))
           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 _ =>

tests/neg/typedapply.scala

@@ -6,8 +6,18 @@ object typedapply {
 
   foo[Int, String, String](1, "abc") // error: wrong number of type parameters
 
+  def fuz(x: Int, y: String) = (x, y)
+
+  val x1 = fuz.curried // OK
+  val x2: Int => String => (Int, String) = x1
+
   def bar(x: Int) = x
 
-  bar[Int](1) // error: does not take parameters
+  bar[Int](1) // error: does not take type parameters
+
+  bar.baz // error: baz is not a member of Int => Int
+
 
 }
+
+