Refine synthesized lambda criterion

 - Don't eta expand at all if expected type is Unit. That way we do not
   have to figure out whether it was an eta expansion after the fact.
 - For statements the expected type is not Unit, but we do have the original
   and we can check whether it was a function or a partial function.

Author: odersky

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

@@ -329,6 +329,11 @@ trait UntypedTreeInfo extends TreeInfo[Untyped] { self: Trees.Instance[Untyped]
   def isFunctionWithUnknownParamType(tree: Tree): Boolean =
     functionWithUnknownParamType(tree).isDefined
 
+  def isFunction(tree: Tree): Boolean = tree match
+    case Function(_, _) | Match(EmptyTree, _) => true
+    case Block(Nil, expr) => isFunction(expr)
+    case _ => false
+
   /** Is `tree` an context function or closure, possibly nested in a block? */
   def isContextualClosure(tree: Tree)(using Context): Boolean = unsplice(tree) match {
     case tree: FunctionWithMods => tree.mods.is(Given)

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

@@ -3415,6 +3415,7 @@ class Typer extends Namer
          && !tree.symbol.isAllOf(InlineMethod)
          && !ctx.mode.is(Mode.Pattern)
          && !(isSyntheticApply(tree) && !functionExpected)
+         && !pt.isRef(defn.UnitClass)
       then
         if (!defn.isFunctionType(pt))
           pt match {
@@ -3830,17 +3831,8 @@ class Typer extends Namer
       && isPureExpr(tree)
       && !isSelfOrSuperConstrCall(tree)
     then tree match
-      case closureDef(meth)
-      if meth.span == meth.rhs.span.toSynthetic
-          && !original.isInstanceOf[untpd.Function] =>
+      case closureDef(meth) if !untpd.isFunction(original) =>
         // It's a synthesized lambda, for instance via an eta expansion: report a hard error
-        // There are two tests for synthetic lambdas which both have to be true.
-        // The first test compares spans of closure definition with the closure's right hand
-        // side. This is usually accurate but can fail for compiler-generated test code.
-        // See repl.DocTests for two failing tests. The second tests rules out closures
-        // if the original tree was a lambda. This does not work always either since
-        // sometimes we do not have the original anymore and use the transformed tree instead.
-        // But taken together, the two criteria are quite accurate.
         missingArgs(tree, tree.tpe.widen)
       case _ =>
         report.warning(PureExpressionInStatementPosition(original, exprOwner), original.srcPos)