Use same kind of Attachment for Using and Infix applies

Author: odersky

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

@@ -537,7 +537,7 @@ object desugar {
       val nu = vparamss.foldLeft(makeNew(classTypeRef)) { (nu, vparams) =>
         val app = Apply(nu, vparams.map(refOfDef))
         vparams match {
-          case vparam :: _ if vparam.mods.is(Given) => app.setUsingApply()
+          case vparam :: _ if vparam.mods.is(Given) => app.setApplyKind(ApplyKind.Using)
           case _ => app
         }
       }
@@ -1188,18 +1188,19 @@ object desugar {
       case Assign(Ident(name), rhs) => cpy.NamedArg(arg)(name, rhs)
       case _ => arg
     }
-    def makeOp(fn: Tree, arg: Tree, selectPos: Span) = {
-      val args: List[Tree] = arg match {
-        case Parens(arg) => assignToNamedArg(arg) :: Nil
-        case Tuple(args) if args.nonEmpty =>  // this case should be dropped if auto-tupling is removed
-          args.mapConserve(assignToNamedArg)
-        case _ => arg :: Nil
-      }
+    def makeOp(fn: Tree, arg: Tree, selectPos: Span) =
       val sel = Select(fn, op.name).withSpan(selectPos)
       if (left.sourcePos.endLine < op.sourcePos.startLine)
         sel.pushAttachment(MultiLineInfix, ())
-      InfixApply(sel, args)
-    }
+      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
+          Apply(sel, args.mapConserve(assignToNamedArg))
+        case _ =>
+          Apply(sel, arg :: Nil)
 
     if (isLeftAssoc(op.name))
       makeOp(left, right, Span(left.span.start, op.span.end, op.span.start))

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

@@ -444,20 +444,21 @@ object Trees {
   }
 
   enum ApplyKind:
-    case Regular, Using, Infix
+    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
 
   /** 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 setUsingApply() =
-      putAttachment(untpd.ApplyGiven, ())
+    def setApplyKind(kind: ApplyKind) =
+      putAttachment(untpd.KindOfApply, kind)
       this
 
     def applyKind: ApplyKind =
-      if hasAttachment(untpd.ApplyGiven) then ApplyKind.Using
-      else ApplyKind.Regular
+      attachmentOrElse(untpd.KindOfApply, ApplyKind.Regular)
   }
 
 

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

@@ -134,13 +134,6 @@ 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 {
@@ -351,7 +344,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   val OriginalSymbol: Property.Key[Symbol] = Property.Key()
 
   /** Property key for contextual Apply trees of the form `fn given arg` */
-  val ApplyGiven: Property.StickyKey[Unit] = Property.StickyKey()
+  val KindOfApply: Property.StickyKey[ApplyKind] = Property.StickyKey()
 
   // ------ Creation methods for untyped only -----------------
 

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -2354,7 +2354,7 @@ object Parsers {
 
     def mkApply(fn: Tree, args: (List[Tree], Boolean)): Tree =
       val res = Apply(fn, args._1)
-      if args._2 then res.setUsingApply()
+      if args._2 then res.setApplyKind(ApplyKind.Using)
       res
 
     val argumentExpr: () => Tree = () => expr(Location.InArgs) match

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.Infix && funType.widen.isNullaryMethod =>
+                if applyKind == ApplyKind.InfixUnit && 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"

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

@@ -242,7 +242,7 @@ object EtaExpansion extends LiftImpure {
     if (mt.paramInfos.nonEmpty && mt.paramInfos.last.isRepeatedParam)
       ids = ids.init :+ repeated(ids.last)
     val app = Apply(lifted, ids)
-    if (mt.isContextualMethod) app.setUsingApply()
+    if (mt.isContextualMethod) app.setApplyKind(ApplyKind.Using)
     val body = if (isLastApplication) app else PostfixOp(app, Ident(nme.WILDCARD))
     val fn =
       if (mt.isContextualMethod) new untpd.FunctionWithMods(params, body, Modifiers(Given))

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

@@ -3047,7 +3047,7 @@ class Typer extends Namer
             }
             tryEither {
               val app = cpy.Apply(tree)(untpd.TypedSplice(tree), namedArgs)
-              if (wtp.isContextualMethod) app.setUsingApply()
+              if (wtp.isContextualMethod) app.setApplyKind(ApplyKind.Using)
               typr.println(i"try with default implicit args $app")
               typed(app, pt, locked)
             } { (_, _) =>