WIP: record application style

Co-authored-by: Abdullah Arif Jafri <[email protected]>

Author: mbovel

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

@@ -513,6 +513,12 @@ object Trees {
     case Using        // r.f(using x)
     case InfixTuple   // r f (x1, ..., xN) where N != 1;  needs to be treated specially for an error message in typedApply
 
+  enum ApplyStyle:
+    case Parentheses    // f(x)
+    case TrailingLambda // f { x => ... }
+    case Colon          // f: x => ...
+    case Unknown
+
   /** fun(args) */
   case class Apply[+T <: Untyped] private[ast] (fun: Tree[T], args: List[Tree[T]])(implicit @constructorOnly src: SourceFile)
     extends GenericApply[T] {
@@ -527,6 +533,13 @@ object Trees {
      */
     def applyKind: ApplyKind =
       attachmentOrElse(untpd.KindOfApply, ApplyKind.Regular)
+
+    def setApplyStyle(style: ApplyStyle) =
+      putAttachment(untpd.StyleOfApply, style)
+      this
+
+    def applyStyle: ApplyStyle =
+      attachmentOrElse(untpd.StyleOfApply, ApplyStyle.Unknown)
   }
 
   /** fun[args] */

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

@@ -386,6 +386,12 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   /** Property key for contextual Apply trees of the form `fn given arg` */
   val KindOfApply: Property.StickyKey[ApplyKind] = Property.StickyKey()
 
+  /** Property key for Apply, which is used to mark the kind of apply that is
+   *  being used: parentheses (`f(x)`), trailing lambda (`f {x => ...}`) , or
+   *  column `f: x => ...`.
+   */
+  val StyleOfApply: Property.StickyKey[ApplyStyle] = Property.StickyKey()
+
   // ------ Creation methods for untyped only -----------------
 
   def Ident(name: Name)(implicit src: SourceFile): Ident = new Ident(name)

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

@@ -2805,7 +2805,8 @@ object Parsers {
           val tapp = atSpan(startOffset(t), in.offset) { TypeApply(t, typeArgs(namedOK = true, wildOK = false)) }
           simpleExprRest(tapp, location, canApply = true)
         case LPAREN | LBRACE | INDENT if canApply =>
-          val app = atSpan(startOffset(t), in.offset) { mkApply(t, argumentExprs()) }
+          val openingToken = in.token
+          val app = atSpan(startOffset(t), in.offset) { mkApply(t, argumentExprs(), openingToken) }
           if in.rewriteToIndent then
             app match
               case Apply(Apply(_, List(Block(_, _))), List(blk @ Block(_, _))) =>
@@ -2892,8 +2893,15 @@ object Parsers {
     def argumentExprs(): (List[Tree], Boolean) =
       if (in.isNestedStart) (blockExpr() :: Nil, false) else parArgumentExprs()
 
-    def mkApply(fn: Tree, args: (List[Tree], Boolean)): Tree =
+    def mkApply(fn: Tree, args: (List[Tree], Boolean), openingToken: Token): Tree =
       val res = Apply(fn, args._1)
+      println(openingToken)
+      val applyStyle =
+        openingToken match
+          case LPAREN => ApplyStyle.Parentheses
+          case LBRACE => ApplyStyle.TrailingLambda
+          case COLONop => ApplyStyle.Colon
+      res.setApplyStyle(applyStyle)
       if args._2 then res.setApplyKind(ApplyKind.Using)
       res
 
@@ -2905,7 +2913,9 @@ object Parsers {
      */
     def argumentExprss(fn: Tree): Tree = {
       argumentStart()
-      if (in.token == LPAREN || in.isNestedStart) argumentExprss(mkApply(fn, argumentExprs()))
+      if in.token == LPAREN || in.isNestedStart then
+        val openingToken = in.token
+        argumentExprss(mkApply(fn, argumentExprs(), openingToken))
       else fn
     }
 
@@ -2931,7 +2941,7 @@ object Parsers {
       }
       if (in.token == LPAREN && (!inClassConstrAnnots || isLegalAnnotArg))
         parArgumentExprss(
-          atSpan(startOffset(fn)) { mkApply(fn, parArgumentExprs()) }
+          atSpan(startOffset(fn)) { mkApply(fn, parArgumentExprs(), LPAREN) }
         )
       else fn
     }
@@ -4046,7 +4056,7 @@ object Parsers {
     def selfInvocation(): Tree =
       atSpan(accept(THIS)) {
         argumentStart()
-        argumentExprss(mkApply(Ident(nme.CONSTRUCTOR), argumentExprs()))
+        argumentExprss(mkApply(Ident(nme.CONSTRUCTOR), argumentExprs(), LPAREN))
       }
 
     /** TypeDef ::=  id [HkTypeParamClause] {FunParamClause} TypeAndCtxBounds [‘=’ Type]