Port Inlay hints for name parameters

Author: zielinsky

presentation-compiler/src/main/dotty/tools/pc/PcInlayHintsProvider.scala

@@ -17,6 +17,8 @@ import scala.meta.pc.SymbolSearch
 import dotty.tools.dotc.ast.tpd.*
 import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.Flags
+import dotty.tools.dotc.core.NameOps.fieldName
+import dotty.tools.dotc.core.Names.Name
 import dotty.tools.dotc.core.StdNames.*
 import dotty.tools.dotc.core.Symbols.*
 import dotty.tools.dotc.core.Types.*
@@ -116,26 +118,69 @@ class PcInlayHintsProvider(
               InlayHintKind.Type,
             )
             .addDefinition(adjustedPos.start)
-      case ByNameParameters(byNameParams) =>
-        def adjustByNameParameterPos(pos: SourcePosition): SourcePosition =
-          val adjusted = adjustPos(pos)
-          val start = text.indexWhere(!_.isWhitespace, adjusted.start)
-          val end = text.lastIndexWhere(!_.isWhitespace, adjusted.end - 1)
+      case Parameters(isInfixFun, args) =>        
+        def isNamedParam(pos: SourcePosition): Boolean =
+          val start = text.indexWhere(!_.isWhitespace, pos.start)
+          val end = text.lastIndexWhere(!_.isWhitespace, pos.end - 1)
 
+          text.slice(start, end).contains('=')
+
+        def isBlockParam(pos: SourcePosition): Boolean =
+          val start = text.indexWhere(!_.isWhitespace, pos.start)
+          val end = text.lastIndexWhere(!_.isWhitespace, pos.end - 1)
           val startsWithBrace = text.lift(start).contains('{')
           val endsWithBrace = text.lift(end).contains('}')
 
-          if startsWithBrace && endsWithBrace then
-            adjusted.withStart(start + 1)
+          startsWithBrace && endsWithBrace
+
+        def adjustBlockParamPos(pos: SourcePosition): SourcePosition =
+          if isBlockParam(pos) then
+            pos.withStart(pos.start + 1)
           else
-            adjusted
+            pos
+
+        val adjustedArgs = args.map {
+          case (name, pos, isByName) => (name, adjustPos(pos), isByName)
+        }
+
+        val namedParams = 
+          if params.namedParameters() && !isInfixFun then
+            adjustedArgs.collect {
+              // We don't want to show parameter names for block parameters or named parameters
+              case (name, pos, _) if !isBlockParam(pos) && !isNamedParam(pos) => (name, pos)
+            }
+          else Nil
 
-        byNameParams.foldLeft(inlayHints) {
-          case (ih, pos) => 
-            val adjusted = adjustByNameParameterPos(pos)
+        val byNameParams = 
+          if params.byNameParameters() then
+            adjustedArgs.collect {
+              case (name, pos, isByName) if isByName => (name, pos)
+            }
+          else Nil
+
+        val namedAndByNameInlayHints = 
+          namedParams.collect { 
+            case param@(name, pos) if byNameParams.contains(param) =>
+              (name.toString() + " = => ", adjustBlockParamPos(pos))
+          }
+        
+        val namedInlayHints = 
+          namedParams.collect { 
+            case param@(name, pos) if !byNameParams.contains(param) =>
+              (name.toString() + " = ", pos)
+          }
+        
+        val byNameInlayHints = 
+          byNameParams.collect {
+          case param@(_, pos) if !namedParams.contains(param) && (!isInfixFun || (isInfixFun && isBlockParam(pos))) => 
+            ("=> ", adjustBlockParamPos(pos))
+        }
+
+        (namedAndByNameInlayHints ++ namedInlayHints ++ byNameInlayHints).foldLeft(inlayHints) {
+          case (ih, (labelStr, pos)) => 
             ih.add(
-              adjusted.startPos.toLsp,
-              List(LabelPart("=> ")),
+              pos.startPos.toLsp,
+              List(LabelPart(labelStr)),
               InlayHintKind.Parameter
             )
         }
@@ -412,27 +457,55 @@ object InferredType:
 
 end InferredType
 
-object ByNameParameters:
-  def unapply(tree: Tree)(using params: InlayHintsParams, ctx: Context): Option[List[SourcePosition]] =
-    def shouldSkipSelect(sel: Select) = 
-      isForComprehensionMethod(sel) || sel.symbol.name == nme.unapply
+object Parameters:
+  def unapply(tree: Tree)(using params: InlayHintsParams, ctx: Context): Option[(Boolean, List[(Name, SourcePosition, Boolean)])] = 
+    def shouldSkipFun(fun: Tree)(using Context): Boolean = 
+      fun match
+        case sel: Select => isForComprehensionMethod(sel) || sel.symbol.name == nme.unapply
+        case _ => false
+
+    def isInfixFun(fun: Tree, args: List[Tree])(using Context): Boolean = 
+      val isInfixSelect = fun match
+        case Select(sel, _) => sel.isInfix
+        case _ => false
+      val source = fun.source
+      if args.isEmpty then isInfixSelect
+      else 
+        (!(fun.span.end until args.head.span.start)
+        .map(source.apply)
+        .contains('.') && fun.symbol.is(Flags.ExtensionMethod)) || isInfixSelect
+
+    def isRealApply(tree: Tree) =
+      !tree.symbol.isOneOf(Flags.GivenOrImplicit) && !tree.span.isZeroExtent
+
+    def getUnderlyingFun(tree: Tree): Tree =
+      tree match
+        case Apply(fun, _) => getUnderlyingFun(fun)
+        case TypeApply(fun, _) => getUnderlyingFun(fun)
+        case t => t
 
-    if (params.byNameParameters()){
+    if (params.namedParameters() || params.byNameParameters()) then
       tree match
-        case Apply(TypeApply(sel: Select, _), _) if shouldSkipSelect(sel) => 
-          None 
-        case Apply(sel: Select, _) if shouldSkipSelect(sel) => 
-          None
-        case Apply(fun, args) =>
-          val funTp = fun.typeOpt.widenTermRefExpr
-          val params = funTp.paramInfoss.flatten
-          Some(
-            args
-            .zip(params)
-            .collect {
-              case (tree, param) if param.isByName => tree.sourcePos
-            }
-          )
+        case Apply(fun, args) if isRealApply(fun) => 
+          val underlyingFun = getUnderlyingFun(fun)
+          if shouldSkipFun(underlyingFun) then
+            None
+          else
+            val funTp = fun.typeOpt.widenTermRefExpr
+            val paramNames = funTp.paramNamess.flatten
+            val paramInfos = funTp.paramInfoss.flatten
+            Some(
+              // Check if the function is an infix function or the underlying function is an infix function
+              isInfixFun(fun, args) || underlyingFun.isInfix,
+              (
+                args
+                .zip(paramNames)
+                .zip(paramInfos)
+                .collect {
+                  case ((arg, paramName), paramInfo) if !arg.span.isZeroExtent => (paramName.fieldName, arg.sourcePos, paramInfo.isByName)
+                }
+              )
+            )
         case _ => None
-    } else None
-end ByNameParameters
+    else None
+end Parameters