Fix rendering of dependent function types

Author: bracevac

local/project/dummy/arrows.scala

@@ -59,4 +59,18 @@ trait Arrows:
   def contextPure(f: AnyRef^{a} ?-> Int): Int
   def contextImpure(f: AnyRef^{a} ?=> Int): Int
   def contextImpure2(f: AnyRef^{a} ?->{b,c} Int): Int
-  def contextImpure3(f: AnyRef^{a} ?->{b,c} Int => AnyRef^{a} ?=> Int): Int
+  def contextImpure3(f: AnyRef^{a} ?->{b,c} Int => AnyRef^{a} ?=> Int): Int
+
+  val noParams: () -> () -> Int
+  val noParams2: () ->{} () ->{} Int
+  val noParamsImpure: () => () => Int => Unit
+
+  val uncurried: (x: AnyRef^, y: AnyRef^) -> AnyRef^{x,y} => Int ->{x,y} Int
+  val uncurried2: (x: AnyRef^, y: AnyRef^) -> AnyRef => Int ->{x,y} Int
+  val uncurried3: (x: AnyRef^, y: AnyRef^) => AnyRef
+  val uncurried4: (x: AnyRef^, y: AnyRef^) ->{a,b} AnyRef^ => Int ->{x,y} Int
+
+  val contextUncurried: (x: AnyRef^{a}, y: AnyRef^{b}) ?-> AnyRef^{x,y} ?-> Int ?->{x,y} Int
+  val contextUncurried2: (x: AnyRef^{a}, y: AnyRef^{b}) ?-> AnyRef ?-> Int ?->{x,y} Int
+  val contextUncurried3: (x: AnyRef^{a}, y: AnyRef^{b}) ?=> AnyRef
+  val contextUncurried4: (x: AnyRef^{a}, y: AnyRef^{b}) ?->{a,b} AnyRef^ ?=> Int ?->{x,y} Int

local/project/dummy/nocc.scala

@@ -4,3 +4,4 @@ trait NoCaptureChecking:
   def byName(f: => Int): Int
   def impure(f: Int => Int): Int
   def context(f: Int ?=> Int): Int
+  def dependent(f: (x: Int) => x.type): Int

scaladoc/src/dotty/tools/scaladoc/tasty/TypesSupport.scala

@@ -140,6 +140,8 @@ trait TypesSupport:
       case CapturingType(base, refs) => base match
         case t @ AppliedType(base, args) if t.isFunctionType =>
           functionType(base, args, skipThisTypePrefix)(using inCC = Some(refs))
+        case t : Refinement if t.isFunctionType =>
+          inner(base, skipThisTypePrefix)(using inCC = Some(refs))
         case _ => inner(base, skipThisTypePrefix) ++ renderCapturing(refs, skipThisTypePrefix)
       case AnnotatedType(tpe, _) =>
         inner(tpe, skipThisTypePrefix)
@@ -213,12 +215,19 @@ trait TypesSupport:
             val isCtx = isContextualMethod(m)
             if isDependentMethod(m) then
               val paramList = getParamList(m)
-              val arrow = keyword(if isCtx then " ?=> " else " => ").l
-              val resType = inner(m.resType, skipThisTypePrefix)
-              paramList ++ arrow ++ resType
+              val arrPrefix = if isCtx then "?" else ""
+              val arrow =
+                if ccEnabled then
+                  inCC match
+                    case None | Some(Nil) => keyword(arrPrefix + "->").l
+                    case Some(List(c)) if c.isCaptureRoot => keyword(arrPrefix + "=>").l
+                    case Some(refs) => keyword(arrPrefix + "->") :: renderCaptureSet(refs, skipThisTypePrefix)
+                else keyword(arrPrefix + "=>").l
+              val resType = inner(m.resType, skipThisTypePrefix)(using inCC = None)
+              paramList ++ (plain(" ") :: arrow) ++ (plain(" ") :: resType)
             else
               val sym = defn.FunctionClass(m.paramTypes.length, isCtx)
-              inner(sym.typeRef.appliedTo(m.paramTypes :+ m.resType), skipThisTypePrefix)
+              inner(sym.typeRef.appliedTo(m.paramTypes :+ m.resType), skipThisTypePrefix)(using inCC = None)
           case other => noSupported("Dependent function type without MethodType refinement")
         }
 
@@ -523,13 +532,14 @@ trait TypesSupport:
           else
             report.error(s"Cannot render function arrow: expected a (Context)Function* or Impure(Context)Function*, but got: ${funTy.show}")
             Nil
-        case Some(refs) => // there is some capture set
+        case Some(refs) =>
+          // there is some capture set
           refs match
             case Nil => List(Keyword(prefix + "->"))
             case List(ref) if ref.isCaptureRoot => List(Keyword(prefix + "=>"))
             case refs => Keyword(prefix + "->") :: renderCaptureSet(using q)(refs, skipThisTypePrefix)
 
-  private def renderByNameArrow(using q: Quotes)(captures: Option[List[reflect.TypeRepr]], skipThisTypePrefix: Boolean)(
+  private def renderByNameArrow(using Quotes)(captures: Option[List[reflect.TypeRepr]], skipThisTypePrefix: Boolean)(
     using elideThis: reflect.ClassDef, originalOwner: reflect.Symbol
   ): SSignature =
-    renderFunctionArrow(using q)(CaptureDefs.Function1.typeRef, captures, skipThisTypePrefix)
+    renderFunctionArrow(CaptureDefs.Function1.typeRef, captures, skipThisTypePrefix)