Merge pull request #11513 from lampepfl/scaladoc/enum-children-missing

Scaladoc: Enums and enum cases fix

Author: pikinier20

scaladoc-testcases/src/tests/enumSignatures.scala

@@ -9,19 +9,19 @@ enum Enum1
   case C
 }
 enum Enum2(val i: Int):
-  case A(val s: String) extends Enum2(1)
-  case B(val t: String) extends Enum2(2)
-  case C(val u: String) extends Enum2(3)
+  case A(s: String) extends Enum2/*<-*/(1)/*->*/
+  case B(t: String) extends Enum2/*<-*/(2)/*->*/
+  case C(u: String) extends Enum2/*<-*/(3)/*->*/
 
 enum Enum3(val param: Int):
-  case A extends Enum3(1) with A
-  case B extends Enum3(2)
-  case C extends Enum3(3)
+  case A extends Enum3/*<-*/(1)/*->*/ with A
+  case B extends Enum3/*<-*/(2)/*->*/
+  case C extends Enum3/*<-*/(3)/*->*/
 
 enum Enum4[+T]:
   case G(s: String)
   case B extends Enum4[Int] with A
-  case C[V](s:String) extends Enum4[V]
+  case C[V](s: String) extends Enum4[V]
   case D[T](s: String) extends Enum4[T]
 
 trait A

scaladoc/src/dotty/tools/scaladoc/api.scala

@@ -54,8 +54,8 @@ enum Kind(val name: String){
   case Object extends Kind("object") with Classlike
   case Trait(typeParams: Seq[TypeParameter], argsLists: Seq[ParametersList])
     extends Kind("trait") with Classlike
-  case Enum extends Kind("enum") with Classlike
-  case EnumCase(kind: Object.type | Type | Val.type) extends Kind("case")
+  case Enum(typeParams: Seq[TypeParameter], argsLists: Seq[ParametersList]) extends Kind("enum") with Classlike
+  case EnumCase(kind: Object.type | Type | Val.type | Class) extends Kind("case")
   case Def(typeParams: Seq[TypeParameter], argsLists: Seq[ParametersList])
     extends Kind("def")
   case Extension(on: ExtensionTarget, m: Kind.Def) extends Kind("def")

scaladoc/src/dotty/tools/scaladoc/renderers/DotDiagramBuilder.scala

@@ -9,8 +9,8 @@ object DotDiagramBuilder:
       case _ : Kind.Class => "fill: #45AD7D;"
       case Kind.Object => "fill: #285577;"
       case _ : Kind.Trait => "fill: #1CAACF;"
-      case Kind.Enum => "fill: #B66722;"
-      case _ : Kind.EnumCase => "fill: #B66722;"
+      case e if e.isInstanceOf[Kind.Enum] => "fill: #B66722;"
+      case e if e.isInstanceOf[Kind.EnumCase] => "fill: #B66722;"
       case other => report.error(s"unexpected value: $other")
 
     val vWithId = diagram.verteciesWithId

scaladoc/src/dotty/tools/scaladoc/renderers/MemberRenderer.scala

@@ -283,7 +283,7 @@ class MemberRenderer(signatureRenderer: SignatureRenderer)(using DocContext) ext
       buildGroup("Type members", Seq(
         ("Classlikes", rest.filter(m => m.kind.isInstanceOf[Classlike])),
         ("Types", rest.filter(_.kind.isInstanceOf[Kind.Type])),
-        ("Enum entries", rest.filter(_.kind == Kind.EnumCase)),
+        ("Enum entries", rest.filter(_.kind.isInstanceOf[Kind.EnumCase])),
       )),
       buildGroup("Value members", Seq(
         ("Constructors", rest.filter(_.kind.isInstanceOf[Kind.Constructor])),

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

@@ -11,7 +11,8 @@ trait ClassLikeSupport:
   private def bareClasslikeKind(symbol: Symbol): Kind =
      if symbol.flags.is(Flags.Module) then Kind.Object
         else if symbol.flags.is(Flags.Trait) then  Kind.Trait(Nil, Nil)
-        else if symbol.flags.is(Flags.Enum) then Kind.Enum
+        else if symbol.flags.is(Flags.Enum) then Kind.Enum(Nil, Nil)
+        else if symbol.flags.is(Flags.Enum) && symbol.flags.is(Flags.Case) then Kind.EnumCase(Kind.Object)
         else Kind.Class(Nil, Nil)
 
   private def kindForClasslike(classDef: ClassDef): Kind =
@@ -39,7 +40,8 @@ trait ClassLikeSupport:
     if classDef.symbol.flags.is(Flags.Module) then Kind.Object
     else if classDef.symbol.flags.is(Flags.Trait) then
       Kind.Trait(typeArgs, args)
-    else if classDef.symbol.flags.is(Flags.Enum) then Kind.Enum
+    else if classDef.symbol.flags.is(Flags.Enum) && classDef.symbol.flags.is(Flags.Case) then Kind.EnumCase(Kind.Class(typeArgs, args))
+    else if classDef.symbol.flags.is(Flags.Enum) then Kind.Enum(typeArgs, args)
     else Kind.Class(typeArgs, args)
 
   def mkClass(classDef: ClassDef)(
@@ -284,7 +286,7 @@ trait ClassLikeSupport:
 
   def parseClasslike(classDef: ClassDef, signatureOnly: Boolean = false): Member = classDef match
     case c: ClassDef if classDef.symbol.flags.is(Flags.Module) => parseObject(c, signatureOnly)
-    case c: ClassDef if classDef.symbol.flags.is(Flags.Enum) => parseEnum(c, signatureOnly)
+    case c: ClassDef if classDef.symbol.flags.is(Flags.Enum) && !classDef.symbol.flags.is(Flags.Case) => parseEnum(c, signatureOnly)
     case clazz => mkClass(classDef)(signatureOnly = signatureOnly)
 
   def parseObject(classDef: ClassDef, signatureOnly: Boolean = false): Member =
@@ -310,13 +312,15 @@ trait ClassLikeSupport:
       case c: ClassDef if c.symbol.flags.is(Flags.Case) && c.symbol.flags.is(Flags.Enum) => processTree(c)(parseClasslike(c))
     }.flatten
 
-    val classlikie = mkClass(classDef)(modifiers = extraModifiers, signatureOnly = signatureOnly)
-    val cases =
-      enumNested.map(_.withKind(Kind.EnumCase(Kind.Object))) ++
-      enumTypes.map(et => et.withKind(Kind.EnumCase(et.kind.asInstanceOf[Kind.Type]))) ++
-      enumVals.map(_.withKind(Kind.EnumCase(Kind.Val)))
+    val enumClass = mkClass(classDef)(modifiers = extraModifiers, signatureOnly = signatureOnly)
 
-    classlikie.withNewMembers(cases)
+    val cases = (
+      enumNested ++
+      enumTypes ++
+      enumVals.map(m => m.copy(dri = m.dri.copy(location = enumClass.dri.location)))
+    )
+
+    enumClass.withMembers(cases)
 
   def parseMethod(
       c: ClassDef,
@@ -411,14 +415,17 @@ trait ClassLikeSupport:
       case LambdaTypeTree(params, body) => (params.map(mkTypeArgument(_)), body)
       case tpe => (Nil, tpe)
 
-    val kind = Kind.Type(!isTreeAbstract(typeDef.rhs), typeDef.symbol.isOpaque, generics)
+    val defaultKind = Kind.Type(!isTreeAbstract(typeDef.rhs), typeDef.symbol.isOpaque, generics).asInstanceOf[Kind.Type]
+    val kind = if typeDef.symbol.flags.is(Flags.Enum) then Kind.EnumCase(defaultKind)
+      else defaultKind
     mkMember(typeDef.symbol, kind, tpeTree.asSignature)(deprecated = typeDef.symbol.isDeprecated())
 
   def parseValDef(c: ClassDef, valDef: ValDef): Member =
     def defaultKind = if valDef.symbol.flags.is(Flags.Mutable) then Kind.Var else Kind.Val
     val memberInfo = unwrapMemberInfo(c, valDef.symbol)
     val kind = if valDef.symbol.flags.is(Flags.Implicit) then
         Kind.Implicit(Kind.Val, extractImplicitConversion(valDef.tpt.tpe))
+        else if valDef.symbol.flags.is(Flags.Enum) then Kind.EnumCase(Kind.Val)
         else defaultKind
 
     mkMember(valDef.symbol, kind, memberInfo.res.asSignature)(deprecated = valDef.symbol.isDeprecated())

scaladoc/src/dotty/tools/scaladoc/transformers/InheritanceInformationTransformer.scala

@@ -17,10 +17,12 @@ class InheritanceInformationTransformer(using DocContext) extends (Module => Mod
   private def bareClasslikeKind(kind: Kind): Kind = kind match
     case _: Kind.Trait => Kind.Trait(Nil, Nil)
     case _: Kind.Class => Kind.Class(Nil, Nil)
+    case e if e.isInstanceOf[Kind.Enum] => Kind.Enum(Nil, Nil)
+    case ec if ec.isInstanceOf[Kind.EnumCase] => Kind.EnumCase(Kind.Object)
     case o => o
 
   private def getSupertypes(c: Member): Seq[(DRI, LinkToType)] =
     val selfMapping =
-      if !c.kind.isInstanceOf[Classlike] then Nil
-      else c.directParents.map(_._2 -> c.asLink)
+      if !c.kind.isInstanceOf[Classlike] && !c.kind.isInstanceOf[Kind.EnumCase] then Nil
+      else c.directParents.map(p => p.dri -> c.asLink)
     c.members.flatMap(getSupertypes) ++ selfMapping

scaladoc/src/dotty/tools/scaladoc/translators/ScalaSignatureProvider.scala

@@ -26,7 +26,9 @@ object ScalaSignatureProvider:
         givenPropertySignature(documentable, builder)
       case cls: Kind.Class =>
         classSignature(documentable, cls, builder)
-      case Kind.Object | Kind.Enum =>
+      case enm: Kind.Enum =>
+        enumSignature(documentable, enm, builder)
+      case Kind.Object =>
         objectSignature(documentable, builder)
       case trt: Kind.Trait =>
         traitSignature(documentable, trt, builder)
@@ -44,7 +46,7 @@ object ScalaSignatureProvider:
   private def enumEntrySignature(member: Member, cls: Kind.Class, bdr: SignatureBuilder): SignatureBuilder =
     val withPrefixes: SignatureBuilder = bdr
       .text("case ")
-      .memberName(member.name, member.dri)
+      .name(member.name, member.dri)
       .generics(cls.typeParams)
 
     val withParameters = withPrefixes.functionParameters(cls.argsLists)
@@ -107,6 +109,15 @@ object ScalaSignatureProvider:
 
     parentsSignature(clazz, selfSignature)
 
+  private def enumSignature(clazz: Member, cls: Kind.Enum, builder: SignatureBuilder): SignatureBuilder =
+    val selfSignature = builder
+      .modifiersAndVisibility(clazz, clazz.kind.name)
+      .name(clazz.name, clazz.dri)
+      .generics(cls.typeParams)
+      .functionParameters(cls.argsLists)
+
+    parentsSignature(clazz, selfSignature)
+
   private def extensionSignature(extension: Member, fun: Kind.Def, builder: SignatureBuilder): SignatureBuilder =
     val withSignature = builder
       .modifiersAndVisibility(extension, "def")

scaladoc/test/dotty/tools/scaladoc/signatures/TranslatableSignaturesTestCases.scala

@@ -43,7 +43,7 @@ class ExtensionMethodSignature extends SignatureTest("extensionMethodSignatures"
 
 class ClassModifiers extends SignatureTest("classModifiers", SignatureTest.classlikeKinds)
 
-// class EnumSignatures extends SignatureTest("enumSignatures", SignatureTest.all)
+class EnumSignatures extends SignatureTest("enumSignatures", SignatureTest.all)
 
 class StructuralTypes extends SignatureTest("structuralTypes", SignatureTest.members)