Leave arguments of infix operations tupled.

Leave arguments of infix operations tupled in desugaring. Untuple them in typer
unless the function type is unary. This allows us to simply omit the operation in typer
when auto tupling is disabled.

Author: odersky

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

@@ -1195,10 +1195,10 @@ object desugar {
       arg match
         case Parens(arg) =>
           Apply(sel, assignToNamedArg(arg) :: Nil)
-        case Tuple(Nil) =>
-          Apply(sel, arg :: Nil).setApplyKind(ApplyKind.InfixUnit)
-        case Tuple(args) if args.nonEmpty =>  // this case should be dropped if auto-tupling is removed
+        case Tuple(args) if args.exists(_.isInstanceOf[Assign]) =>
           Apply(sel, args.mapConserve(assignToNamedArg))
+        case Tuple(args) =>
+          Apply(sel, arg :: Nil).setApplyKind(ApplyKind.InfixTuple)
         case _ =>
           Apply(sel, arg :: Nil)
 

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

@@ -448,7 +448,7 @@ object Trees {
   enum ApplyKind:
     case Regular      // r.f(x)
     case Using        // r.f(using x)
-    case InfixUnit    // r f (), needs to be treated specially for an error message in typedApply
+    case InfixTuple   // r f (x1, ..., xN) where N != 1;  needs to be treated specially for an error message in typedApply
 
   /** fun(args) */
   case class Apply[-T >: Untyped] private[ast] (fun: Tree[T], args: List[Tree[T]])(implicit @constructorOnly src: SourceFile)

compiler/src/dotty/tools/dotc/transform/SymUtils.scala

@@ -218,4 +218,12 @@ class SymUtils(val self: Symbol) extends AnyVal {
   def isScalaStatic(using Context): Boolean =
     self.hasAnnotation(ctx.definitions.ScalaStaticAnnot)
 
+  /** Is symbol assumed or declared as an infix symbol? */
+  def isDeclaredInfix(using Context): Boolean =
+    self.hasAnnotation(defn.InfixAnnot)
+    || defn.isInfix(self)
+    || self.name.isUnapplyName
+       && self.owner.is(Module)
+       && self.owner.linkedClass.is(Case)
+       && self.owner.linkedClass.isDeclaredInfix
 }

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

@@ -615,7 +615,7 @@ trait Applications extends Compatibility {
             case arg :: args1 =>
               val msg = arg match
                 case untpd.Tuple(Nil)
-                if applyKind == ApplyKind.InfixUnit && funType.widen.isNullaryMethod =>
+                if applyKind == ApplyKind.InfixTuple && funType.widen.isNullaryMethod =>
                   i"can't supply unit value with infix notation because nullary $methString takes no arguments; use dotted invocation instead: (...).${methRef.name}()"
                 case _ =>
                   i"too many arguments for $methString"
@@ -862,14 +862,15 @@ trait Applications extends Compatibility {
       record("typedApply")
       val fun1 = typedFunPart(tree.fun, originalProto)
 
-      // Warning: The following lines are dirty and fragile. We record that auto-tupling was demanded as
-      // a side effect in adapt. If it was, we assume the tupled proto-type in the rest of the application,
+      // Warning: The following lines are dirty and fragile.
+      // We record that auto-tupling or untupling was demanded as a side effect in adapt.
+      // If it was, we assume the tupled-dual proto-type in the rest of the application,
       // until, possibly, we have to fall back to insert an implicit on the qualifier.
       // This crucially relies on he fact that `proto` is used only in a single call of `adapt`,
       // otherwise we would get possible cross-talk between different `adapt` calls using the same
       // prototype. A cleaner alternative would be to return a modified prototype from `adapt` together with
       // a modified tree but this would be more convoluted and less efficient.
-      val proto = if (originalProto.isTupled) originalProto.tupled else originalProto
+      val proto = if (originalProto.hasTupledDual) originalProto.tupledDual else originalProto
 
       // If some of the application's arguments are function literals without explicitly declared
       // parameter types, relate the normalized result type of the application with the

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

@@ -810,21 +810,13 @@ trait Checking {
    *  operator is alphanumeric, it must be declared `@infix`.
    */
   def checkValidInfix(tree: untpd.InfixOp, meth: Symbol)(using Context): Unit = {
-
-    def isInfix(sym: Symbol): Boolean =
-      sym.hasAnnotation(defn.InfixAnnot) ||
-      defn.isInfix(sym) ||
-      sym.name.isUnapplyName &&
-        sym.owner.is(Module) && sym.owner.linkedClass.is(Case) &&
-        isInfix(sym.owner.linkedClass)
-
     tree.op match {
       case id @ Ident(name: Name) =>
         name.toTermName match {
           case name: SimpleName
           if !untpd.isBackquoted(id) &&
              !name.isOperatorName &&
-             !isInfix(meth) &&
+             !meth.isDeclaredInfix &&
              !meth.maybeOwner.is(Scala2x) &&
              !infixOKSinceFollowedBy(tree.right) &&
              sourceVersion.isAtLeast(`3.1`) =>

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

@@ -236,8 +236,8 @@ object ProtoTypes {
     /** A map in which typed arguments can be stored to be later integrated in `typedArgs`. */
     var typedArg: SimpleIdentityMap[untpd.Tree, Tree] = SimpleIdentityMap.Empty
 
-    /** The tupled version of this prototype, if it has been computed */
-    var tupled: Type = NoType
+    /** The tupled or untupled version of this prototype, if it has been computed */
+    var tupledDual: Type = NoType
 
     /** If true, the application of this prototype was canceled. */
     var toDrop: Boolean = false
@@ -348,16 +348,19 @@ object ProtoTypes {
     }
 
     /** The same proto-type but with all arguments combined in a single tuple */
-    def tupled: FunProto = state.tupled match {
+    def tupledDual: FunProto = state.tupledDual match {
       case pt: FunProto =>
         pt
       case _ =>
-        state.tupled = new FunProto(untpd.Tuple(args) :: Nil, resultType)(typer, applyKind)
-        tupled
+        val dualArgs = args match
+          case untpd.Tuple(elems) :: Nil => elems
+          case _ => untpd.Tuple(args) :: Nil
+        state.tupledDual = new FunProto(dualArgs, resultType)(typer, applyKind)
+        tupledDual
     }
 
-    /** Somebody called the `tupled` method of this prototype */
-    def isTupled: Boolean = state.tupled.isInstanceOf[FunProto]
+    /** Somebody called the `tupledDual` method of this prototype */
+    def hasTupledDual: Boolean = state.tupledDual.isInstanceOf[FunProto]
 
     /** Cancel the application of this prototype. This can happen for a nullary
      *  application `f()` if `f` refers to a symbol that exists both in parameterless

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

@@ -2930,14 +2930,31 @@ class Typer extends Namer
         false
     }
 
+    /** Should we tuple or untuple the argument before application?
+     *  If auto-tupling is enabled then
+     *
+     *   - we tuple n-ary arguments where n > 0 if the function consists
+     *     only of unary alternatives
+     *   - we untuple tuple arguments of infix operations if the function
+     *     does not consist only of unary alternatives.
+     */
+    def needsTupledDual(funType: Type, pt: FunProto): Boolean = {
+      pt.args match
+        case untpd.Tuple(elems) :: Nil =>
+          elems.length > 1
+          && pt.applyKind == ApplyKind.InfixTuple
+          && !isUnary(funType)
+        case args =>
+          args.lengthCompare(1) > 0
+          && isUnary(funType)
+    } && autoTuplingEnabled
+
     def adaptToArgs(wtp: Type, pt: FunProto): Tree = wtp match {
       case wtp: MethodOrPoly =>
         def methodStr = methPart(tree).symbol.showLocated
         if (matchingApply(wtp, pt))
-          if (pt.args.lengthCompare(1) > 0 && isUnary(wtp) && autoTuplingEnabled)
-            adapt(tree, pt.tupled, locked)
-          else
-            tree
+          if needsTupledDual(wtp, pt) then adapt(tree, pt.tupledDual, locked)
+          else tree
         else if (wtp.isContextualMethod)
           def isContextBoundParams = wtp.stripPoly match
             case MethodType(EvidenceParamName(_) :: _) => true
@@ -3465,8 +3482,8 @@ class Typer extends Namer
         case ref: TermRef =>
           pt match {
             case pt: FunProto
-            if pt.args.lengthCompare(1) > 0 && isUnary(ref) && autoTuplingEnabled =>
-              adapt(tree, pt.tupled, locked)
+            if needsTupledDual(ref, pt) && autoTuplingEnabled =>
+              adapt(tree, pt.tupledDual, locked)
             case _ =>
               adaptOverloaded(ref)
           }