Fix enum and export parsing in Scaladoc

Author: pikinier20

scaladoc-testcases/src/tests/exports.scala

@@ -21,7 +21,7 @@ class A: //unexpected
    = ???
   def fn[T, U]: T => U
    = ???
-  object Object //expected: val Obj: Object.type
+  object Object //expected: final val Obj: Object.type
   val x: HKT[List, Int]
    = ???
   class Class(val a: Int, val b: Int) extends Serializable //expected: final type Class = Class

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

@@ -170,10 +170,10 @@ trait ClassLikeSupport:
           case rhs => rhs
         }.map(_.tpe.termSymbol).filter(_.exists).map(_.tree).map {
           case v: ValDef if v.symbol.flags.is(Flags.Module) && !v.symbol.flags.is(Flags.Synthetic) =>
-            v.symbol.owner -> Symbol.newVal(c.symbol, dd.name, v.tpt.tpe, Flags.Final, Symbol.noSymbol).tree
+            v.symbol.owner -> Symbol.newVal(v.symbol.owner, dd.name, v.tpt.tpe, Flags.Final, Symbol.noSymbol).tree
           case other => other.symbol.owner -> other
         }.flatMap { (originalOwner, tree) =>
-          parseMember(c)(tree)
+          parseMember(originalOwner.tree.asInstanceOf[ClassDef])(tree)
             .map { m => m
               .withDRI(dd.symbol.dri)
               .withName(dd.symbol.normalizedName)
@@ -316,7 +316,7 @@ trait ClassLikeSupport:
 
     val enumVals = companion.membersToDocument.collect {
       case vd: ValDef if !isSyntheticField(vd.symbol) && vd.symbol.flags.is(Flags.Enum) && vd.symbol.flags.is(Flags.Case) => vd
-    }.toList.map(parseValDef(classDef, _))
+    }.toList.map(parseValDef(companion, _))
 
     val enumTypes = companion.membersToDocument.collect {
       case td: TypeDef if !td.symbol.flags.is(Flags.Synthetic) && td.symbol.flags.is(Flags.Enum) && td.symbol.flags.is(Flags.Case) => td

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

@@ -259,7 +259,7 @@ trait TypesSupport:
       case tr @ TermRef(qual, typeName) =>
         tr.termSymbol.tree match
           case vd: ValDef => inner(vd.tpt.tpe)
-          case _          => tpe(tr.termSymbol)
+          case _          => tpe(tr.termSymbol) :+ plain(".type")
 
 
         // convertTypeOrBoundsToReference(reflect)(qual) match {