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

@@ -133,6 +133,8 @@ trait TypesSupport:
       case CapturingType(base, refs) => base match
         case t @ AppliedType(base, args) if t.isFunctionType =>
           functionType(base, args)(using inCC = Some(refs))
+        case t : Refinement if t.isFunctionType =>
+          inner(base)(using inCC = Some(refs))
         case _ => inner(base) ++ renderCapturing(refs)
       case AnnotatedType(tpe, _) =>
         inner(tpe)
@@ -203,12 +205,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)
-              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)
+                else keyword(arrPrefix + "=>").l
+              val resType = inner(m.resType)(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))
+              inner(sym.typeRef.appliedTo(m.paramTypes :+ m.resType))(using inCC = None)
           case other => noSupported("Dependent function type without MethodType refinement")
         }
 
@@ -499,11 +508,12 @@ 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(refs)
 
   private def renderByNameArrow(using Quotes)(captures: Option[List[reflect.TypeRepr]])(using elideThis: reflect.ClassDef): SSignature =
-    renderFunctionArrow(CaptureDefs.Function1.typeRef, captures)
+    renderFunctionArrow(CaptureDefs.Function1.typeRef, captures)