Fix #9132: Align with Scala 2's handling of () infix arguments

A right argument of an infix operation is kept as an empty tuuple, instead
of being desugared to an empty parameter list.

The most involved part of the change was getting decent error messages, since
it required propagating the information that an apply is an infix all the way
into application checking. Hopefully, we can profit from the change when
we drop auto-tupling, since then similar info will be needed for error
messages in more situations.

Author: odersky

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

@@ -1191,13 +1191,14 @@ object desugar {
     def makeOp(fn: Tree, arg: Tree, selectPos: Span) = {
       val args: List[Tree] = arg match {
         case Parens(arg) => assignToNamedArg(arg) :: Nil
-        case Tuple(args) => args.mapConserve(assignToNamedArg)
+        case Tuple(args) if args.nonEmpty =>  // this case should be dropped if auto-tupling is removed
+          args.mapConserve(assignToNamedArg)
         case _ => arg :: Nil
       }
       val sel = Select(fn, op.name).withSpan(selectPos)
       if (left.sourcePos.endLine < op.sourcePos.startLine)
         sel.pushAttachment(MultiLineInfix, ())
-      Apply(sel, args)
+      InfixApply(sel, args)
     }
 
     if (isLeftAssoc(op.name))

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

@@ -443,15 +443,25 @@ object Trees {
     def forwardTo: Tree[T] = fun
   }
 
+  enum ApplyKind:
+    case Regular, Using, Infix
+
   /** fun(args) */
   case class Apply[-T >: Untyped] private[ast] (fun: Tree[T], args: List[Tree[T]])(implicit @constructorOnly src: SourceFile)
     extends GenericApply[T] {
     type ThisTree[-T >: Untyped] = Apply[T]
 
-    def isUsingApply = hasAttachment(untpd.ApplyGiven)
-    def setUsingApply() = { putAttachment(untpd.ApplyGiven, ()); this }
+    def setUsingApply() =
+      putAttachment(untpd.ApplyGiven, ())
+      this
+
+    def applyKind: ApplyKind =
+      if hasAttachment(untpd.ApplyGiven) then ApplyKind.Using
+      else ApplyKind.Regular
   }
 
+
+
   /** fun[args] */
   case class TypeApply[-T >: Untyped] private[ast] (fun: Tree[T], args: List[Tree[T]])(implicit @constructorOnly src: SourceFile)
     extends GenericApply[T] {

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

@@ -1370,5 +1370,5 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
 
   protected def FunProto(args: List[Tree], resType: Type)(using Context) =
-    ProtoTypes.FunProtoTyped(args, resType)(ctx.typer, isUsingApply = false)
+    ProtoTypes.FunProtoTyped(args, resType)(ctx.typer, ApplyKind.Regular)
 }

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

@@ -134,6 +134,13 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
       case _ => name
   }
 
+  /** Short-lived class created by desugar.binop and used by typedApply to
+   *  improve error messages for infix applications
+   */
+  class InfixApply(fun: Tree, args: List[Tree])(implicit @constructorOnly src: SourceFile)
+  extends Apply(fun, args):
+    override def applyKind = ApplyKind.Infix
+
   case class Number(digits: String, kind: NumberKind)(implicit @constructorOnly src: SourceFile) extends TermTree
 
   enum NumberKind {
@@ -780,5 +787,5 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   }
 
   protected def FunProto(args: List[Tree], resType: Type)(using Context) =
-    ProtoTypes.FunProto(args, resType)(ctx.typer, isUsingApply = false)
+    ProtoTypes.FunProto(args, resType)(ctx.typer, ApplyKind.Regular)
 }

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -388,7 +388,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         else
           toTextLocal(fun)
           ~ "("
-          ~ Str("using ").provided(app.isUsingApply && !homogenizedView)
+          ~ Str("using ").provided(app.applyKind == ApplyKind.Using && !homogenizedView)
           ~ toTextGlobal(args, ", ")
           ~ ")"
       case tree: TypeApply =>

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

@@ -248,6 +248,9 @@ trait Applications extends Compatibility {
     /** The type of typed arguments: either tpd.Tree or Type */
     type TypedArg
 
+    /** The kind of application that gets typed */
+    def applyKind: ApplyKind
+
     /** Given an original argument and the type of the corresponding formal
      *  parameter, produce a typed argument.
      */
@@ -609,7 +612,14 @@ trait Applications extends Compatibility {
 
         case nil =>
           args match {
-            case arg :: args1 => fail(s"too many arguments for $methString", arg)
+            case arg :: args1 =>
+              val msg = arg match
+                case untpd.Tuple(Nil)
+                if applyKind == ApplyKind.Infix && funType.widen.isNullaryMethod =>
+                  i"can't supply unit value with infix notation because nullary method $methString takes no arguments; use dotted invocation instead: (...).${methRef.name}()"
+                case _ =>
+                  i"too many arguments for $methString"
+              fail(msg, arg)
             case nil =>
           }
       }
@@ -624,6 +634,8 @@ trait Applications extends Compatibility {
     type TypedArg = Arg
     type Result = Unit
 
+    def applyKind = ApplyKind.Regular
+
     protected def argOK(arg: TypedArg, formal: Type): Boolean = argType(arg, formal) match {
       case ref: TermRef if ref.denot.isOverloaded =>
         // in this case we could not resolve overloading because no alternative
@@ -687,7 +699,8 @@ trait Applications extends Compatibility {
    *  types of arguments are either known or unknown.
    */
   abstract class TypedApply[T >: Untyped](
-    app: untpd.Apply, fun: Tree, methRef: TermRef, args: List[Trees.Tree[T]], resultType: Type)(using Context)
+    app: untpd.Apply, fun: Tree, methRef: TermRef, args: List[Trees.Tree[T]], resultType: Type,
+    override val applyKind: ApplyKind)(using Context)
   extends Application(methRef, fun.tpe, args, resultType) {
     type TypedArg = Tree
     def isVarArg(arg: Trees.Tree[T]): Boolean = untpd.isWildcardStarArg(arg)
@@ -795,16 +808,20 @@ trait Applications extends Compatibility {
   }
 
   /** Subclass of Application for type checking an Apply node with untyped arguments. */
-  class ApplyToUntyped(app: untpd.Apply, fun: Tree, methRef: TermRef, proto: FunProto, resultType: Type)(using Context)
-  extends TypedApply(app, fun, methRef, proto.args, resultType) {
+  class ApplyToUntyped(
+    app: untpd.Apply, fun: Tree, methRef: TermRef, proto: FunProto,
+    resultType: Type)(using Context)
+  extends TypedApply(app, fun, methRef, proto.args, resultType, proto.applyKind) {
     def typedArg(arg: untpd.Tree, formal: Type): TypedArg = proto.typedArg(arg, formal)
     def treeToArg(arg: Tree): untpd.Tree = untpd.TypedSplice(arg)
     def typeOfArg(arg: untpd.Tree): Type = proto.typeOfArg(arg)
   }
 
   /** Subclass of Application for type checking an Apply node with typed arguments. */
-  class ApplyToTyped(app: untpd.Apply, fun: Tree, methRef: TermRef, args: List[Tree], resultType: Type)(using Context)
-  extends TypedApply(app, fun, methRef, args, resultType) {
+  class ApplyToTyped(
+    app: untpd.Apply, fun: Tree, methRef: TermRef, args: List[Tree],
+    resultType: Type, applyKind: ApplyKind)(using Context)
+  extends TypedApply(app, fun, methRef, args, resultType, applyKind) {
     def typedArg(arg: Tree, formal: Type): TypedArg = arg
     def treeToArg(arg: Tree): Tree = arg
     def typeOfArg(arg: Tree): Type = arg.tpe
@@ -840,7 +857,8 @@ trait Applications extends Compatibility {
   def typedApply(tree: untpd.Apply, pt: Type)(using Context): Tree = {
 
     def realApply(using Context): Tree = {
-      val originalProto = new FunProto(tree.args, IgnoredProto(pt))(this, tree.isUsingApply)(using argCtx(tree))
+      val originalProto =
+        new FunProto(tree.args, IgnoredProto(pt))(this, tree.applyKind)(using argCtx(tree))
       record("typedApply")
       val fun1 = typedFunPart(tree.fun, originalProto)
 
@@ -998,7 +1016,7 @@ trait Applications extends Compatibility {
   def ApplyTo(app: untpd.Apply, fun: tpd.Tree, methRef: TermRef, proto: FunProto, resultType: Type)(using Context): tpd.Tree =
     val typer = ctx.typer
     if (proto.allArgTypesAreCurrent())
-      typer.ApplyToTyped(app, fun, methRef, proto.typedArgs(), resultType).result
+      typer.ApplyToTyped(app, fun, methRef, proto.typedArgs(), resultType, proto.applyKind).result
     else
       typer.ApplyToUntyped(app, fun, methRef, proto, resultType)(
         using fun.nullableInArgContext(using argCtx(app))).result
@@ -1655,7 +1673,7 @@ trait Applications extends Compatibility {
     def resolve(alts: List[TermRef]): List[TermRef] =
       pt match
         case pt: FunProto =>
-          if pt.isUsingApply then
+          if pt.applyKind == ApplyKind.Using then
             val alts0 = alts.filterConserve { alt =>
               val mt = alt.widen.stripPoly
               mt.isImplicitMethod || mt.isContextualMethod

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

@@ -225,9 +225,8 @@ object ProtoTypes {
   class UnapplySelectionProto(name: Name) extends SelectionProto(name, WildcardType, NoViewsAllowed, true)
 
   trait ApplyingProto extends ProtoType   // common trait of ViewProto and FunProto
-  trait FunOrPolyProto extends ProtoType { // common trait of PolyProto and FunProto
-    def isUsingApply: Boolean = false
-  }
+  trait FunOrPolyProto extends ProtoType: // common trait of PolyProto and FunProto
+    def applyKind: ApplyKind = ApplyKind.Regular
 
   class FunProtoState {
 
@@ -249,7 +248,7 @@ object ProtoTypes {
    *  [](args): resultType
    */
   case class FunProto(args: List[untpd.Tree], resType: Type)(typer: Typer,
-    override val isUsingApply: Boolean, state: FunProtoState = new FunProtoState)(using protoCtx: Context)
+    override val applyKind: ApplyKind, state: FunProtoState = new FunProtoState)(using protoCtx: Context)
   extends UncachedGroundType with ApplyingProto with FunOrPolyProto {
     override def resultType(using Context): Type = resType
 
@@ -263,7 +262,7 @@ object ProtoTypes {
 
     def derivedFunProto(args: List[untpd.Tree] = this.args, resultType: Type, typer: Typer = this.typer): FunProto =
       if ((args eq this.args) && (resultType eq this.resultType) && (typer eq this.typer)) this
-      else new FunProto(args, resultType)(typer, isUsingApply)
+      else new FunProto(args, resultType)(typer, applyKind)
 
     /** @return True if all arguments have types.
      */
@@ -353,7 +352,7 @@ object ProtoTypes {
       case pt: FunProto =>
         pt
       case _ =>
-        state.tupled = new FunProto(untpd.Tuple(args) :: Nil, resultType)(typer, isUsingApply)
+        state.tupled = new FunProto(untpd.Tuple(args) :: Nil, resultType)(typer, applyKind)
         tupled
     }
 
@@ -388,15 +387,15 @@ object ProtoTypes {
 
     override def withContext(newCtx: Context): ProtoType =
       if newCtx `eq` protoCtx then this
-      else new FunProto(args, resType)(typer, isUsingApply, state)(using newCtx)
+      else new FunProto(args, resType)(typer, applyKind, state)(using newCtx)
   }
 
   /** A prototype for expressions that appear in function position
    *
    *  [](args): resultType, where args are known to be typed
    */
-  class FunProtoTyped(args: List[tpd.Tree], resultType: Type)(typer: Typer, isUsingApply: Boolean)(using Context)
-  extends FunProto(args, resultType)(typer, isUsingApply):
+  class FunProtoTyped(args: List[tpd.Tree], resultType: Type)(typer: Typer, applyKind: ApplyKind)(using Context)
+  extends FunProto(args, resultType)(typer, applyKind):
     override def typedArgs(norm: (untpd.Tree, Int) => untpd.Tree)(using Context): List[tpd.Tree] = args
     override def typedArg(arg: untpd.Tree, formal: Type)(using Context): tpd.Tree = arg.asInstanceOf[tpd.Tree]
     override def allArgTypesAreCurrent()(using Context): Boolean = true
@@ -444,7 +443,7 @@ object ProtoTypes {
   }
 
   class UnapplyFunProto(argType: Type, typer: Typer)(using Context) extends FunProto(
-    untpd.TypedSplice(dummyTreeOfType(argType)(ctx.source))(ctx) :: Nil, WildcardType)(typer, isUsingApply = false)
+    untpd.TypedSplice(dummyTreeOfType(argType)(ctx.source))(ctx) :: Nil, WildcardType)(typer, applyKind = ApplyKind.Regular)
 
   /** A prototype for expressions [] that are type-parameterized:
    *

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

@@ -1092,7 +1092,7 @@ class Typer extends Namer
               val nestedCtx = outerCtx.fresh.setNewTyperState()
               inContext(nestedCtx) {
                 val protoArgs = args map (_ withType WildcardType)
-                val callProto = FunProto(protoArgs, WildcardType)(this, app.isUsingApply)
+                val callProto = FunProto(protoArgs, WildcardType)(this, app.applyKind)
                 val expr1 = typedExpr(expr, callProto)
                 if nestedCtx.reporter.hasErrors then NoType
                 else inContext(outerCtx) {
@@ -2887,7 +2887,7 @@ class Typer extends Namer
             errorTree(tree, NoMatchingOverload(altDenots, pt))
           def hasEmptyParams(denot: SingleDenotation) = denot.info.paramInfoss == ListOfNil
           pt match {
-            case pt: FunOrPolyProto if !pt.isUsingApply =>
+            case pt: FunOrPolyProto if pt.applyKind != ApplyKind.Using =>
               // insert apply or convert qualifier, but only for a regular application
               tryInsertApplyOrImplicit(tree, pt, locked)(noMatches)
             case _ =>
@@ -3063,7 +3063,7 @@ class Typer extends Namer
         }
       }
       pt.revealIgnored match {
-        case pt: FunProto if pt.isUsingApply =>
+        case pt: FunProto if pt.applyKind == ApplyKind.Using =>
           // We can end up here if extension methods are called with explicit given arguments.
           // See for instance #7119.
           tree
@@ -3535,8 +3535,9 @@ class Typer extends Namer
    *  Overridden in `ReTyper`, where all applications are treated the same
    */
   protected def matchingApply(methType: MethodOrPoly, pt: FunProto)(using Context): Boolean =
-    methType.isContextualMethod == pt.isUsingApply ||
-    methType.isImplicitMethod && pt.isUsingApply // for a transition allow `with` arguments for regular implicit parameters
+    val isUsingApply = pt.applyKind == ApplyKind.Using
+    methType.isContextualMethod == isUsingApply
+    || methType.isImplicitMethod && isUsingApply // for a transition allow `with` arguments for regular implicit parameters
 
   /** Check that `tree == x: pt` is typeable. Used when checking a pattern
    *  against a selector of type `pt`. This implementation accounts for

tests/neg/i2033.check

@@ -0,0 +1,9 @@
+-- Error: tests/neg/i2033.scala:7:30 -----------------------------------------------------------------------------------
+7 |    val arr = bos toByteArray ()  // error
+  |                              ^^
+  |can't supply unit value with infix notation because nullary method method toByteArray: (): Array[Byte] takes no arguments; use dotted invocation instead: (...).toByteArray()
+-- [E007] Type Mismatch Error: tests/neg/i2033.scala:20:35 -------------------------------------------------------------
+20 |  val out = new ObjectOutputStream(println) // error
+   |                                   ^^^^^^^
+   |                                   Found:    Unit
+   |                                   Required: String

tests/neg/i2033.scala

@@ -4,7 +4,7 @@ object Test {
   def check(obj: AnyRef): Unit = {
     val bos = new ByteArrayOutputStream()
     val out = new ObjectOutputStream(println)
-    val arr = bos toByteArray ()
+    val arr = bos toByteArray ()  // error
     val in = (())
     val deser = ()
     val lhs = mutable LinkedHashSet ()