Scala3doc: update Dotty dependency to latest snapshot

Author: abgruszecki

scala3doc/build.sbt

@@ -1,7 +1,7 @@
 // re-expose subproject settings
 val `example-project` = ExampleProject.`example-project`
 
-val dottyVersion = "0.27.0-RC1"
+val dottyVersion = "3.0.0-M1-bin-SNAPSHOT"
 val dokkaVersion = "1.4.10.2"
 val flexmarkVersion = "0.42.12"
 val jacksonVersion = "2.9.8"
@@ -12,9 +12,8 @@ libraryDependencies ++= Seq(
   "org.jetbrains.dokka" % "dokka-test-api" % dokkaVersion % "test", // TODO move testing utils to dokka-site
   "com.virtuslab.dokka" % "dokka-site" % dokkaSiteVersion,
 
-  "ch.epfl.lamp" %% "dotty-tasty-inspector" % dottyVersion,
-  "ch.epfl.lamp" %% "dotty-compiler" % dottyVersion,
-  "ch.epfl.lamp" %% "dotty-library" % dottyVersion,
+  "org.scala-lang" %% "scala3-tasty-inspector" % dottyVersion,
+  "org.scala-lang" %% "scala3-compiler" % dottyVersion,
   "org.scala-sbt" % "io_2.13" % "1.3.4",
 
   "com.vladsch.flexmark" % "flexmark-all" % flexmarkVersion,
@@ -27,7 +26,6 @@ libraryDependencies ++= Seq(
 resolvers += Resolver.jcenterRepo
 resolvers += Resolver.bintrayRepo("kotlin", "kotlin-dev")
 resolvers += Resolver.bintrayRepo("virtuslab", "dokka")
-resolvers += Resolver.mavenLocal
 
 lazy val root = project
   .in(file("."))

scala3doc/src/main/scala/dotty/dokka/DottyDokkaConfig.scala

@@ -19,7 +19,8 @@ case class DottyDokkaConfig(docConfiguration: DocConfiguration) extends DokkaCon
 
   private object OurConfig extends DokkaConfiguration.PluginConfiguration:
     override def getFqPluginName = "ExternalDocsTooKey"
-    override def getSerializationFormat: DokkaConfiguration$SerializationFormat = DokkaConfiguration$SerializationFormat.JSON
+    override def getSerializationFormat: DokkaConfiguration$SerializationFormat =
+      DokkaConfiguration$SerializationFormat.JSON.asInstanceOf[DokkaConfiguration$SerializationFormat]
     override def getValues: String = docConfiguration.args.docsRoot.getOrElse("")
 
   override def getPluginsConfiguration: JList[DokkaConfiguration.PluginConfiguration] = List(OurConfig).asJava

scala3doc/src/main/scala/dotty/dokka/tasty/BasicSupport.scala

@@ -24,7 +24,7 @@ trait BasicSupport:
     val params = annotTerm match 
       case Apply(target, appliedWith) => {
         appliedWith.map {
-          case Literal(Constant(value)) => Annotation.PrimitiveParameter(None, value match {
+          case Literal(constant) => Annotation.PrimitiveParameter(None, constant.value match {
             case s: String => "\"" + s"$s" + "\""
             case other => other.toString()
           })
@@ -40,7 +40,7 @@ trait BasicSupport:
 
 
   extension (sym: reflect.Symbol):
-    def documentation(using cxt: reflect.Context) = sym.comment match
+    def documentation(using cxt: reflect.Context) = sym.documentation match
       case Some(comment) =>
           Map(sourceSet.getSourceSet -> parseComment(comment, sym.tree))
       case None =>

scala3doc/src/main/scala/dotty/dokka/tasty/ScalaDocSupport.scala

@@ -13,7 +13,7 @@ trait ScaladocSupport { self: TastyParser =>
   import reflect._
 
   def parseComment(
-    commentNode: reflect.Comment,
+    commentNode: reflect.Documentation,
     tree: reflect.Tree
   ): dkkd.DocumentationNode = {
     val preparsed =

scala3doc/src/main/scala/dotty/dokka/tasty/SyntheticSupport.scala

@@ -38,7 +38,7 @@ trait SyntheticsSupport:
     def getAllMembers: List[Symbol] = hackGetAllMembers(self.reflect)(s)
 
   def isSyntheticField(c: Symbol) =
-    c.flags.is(Flags.CaseAcessor) || c.flags.is(Flags.Object)
+    c.flags.is(Flags.CaseAccessor) || c.flags.is(Flags.Object)
 
   def isValidPos(pos: Position) =
     pos.exists && pos.start != pos.end
@@ -101,11 +101,11 @@ trait SyntheticsSupport:
     cSym.typeRef.appliedTo(cSym.typeParams.map(_.typeRef)).asInstanceOf[r.Type]
 
   object MatchTypeCase:
-    def unapply(tpe: Type): Option[(TypeOrBounds, TypeOrBounds)] =
+    def unapply(tpe: Type): Option[(Type, Type)] =
       tpe match
-        case AppliedType(t, Seq(from, to)) if t == MatchCaseType =>
+        case AppliedType(t, Seq(from, to)) /*if t == MatchCaseType*/ =>
             Some((from, to))
-        case TypeLambda(paramNames, paramTypes, AppliedType(t, Seq(from, to))) if t == MatchCaseType =>
+        case TypeLambda(paramNames, paramTypes, AppliedType(t, Seq(from, to))) /*if t == MatchCaseType*/ =>
             Some((from, to))
         case _ =>
           None

scala3doc/src/main/scala/dotty/dokka/tasty/TastyParser.scala

@@ -87,7 +87,7 @@ case class SbtDokkaTastyInspector(
 
     override def run(implicit ctx: Context): Unit =
       val qctx = QuoteContextImpl()
-      self.processCompilationUnit(qctx.tasty)(ctx.compilationUnit.tpdTree.asInstanceOf[qctx.tasty.Tree])
+      self.processCompilationUnit(using qctx)(ctx.compilationUnit.tpdTree.asInstanceOf[qctx.tasty.Tree])
 
   end TastyInspectorPhase
 
@@ -100,8 +100,8 @@ trait DokkaBaseTastyInspector:
 
   private val topLevels = Seq.newBuilder[Documentable]
 
-  def processCompilationUnit(reflect: Reflection)(root: reflect.Tree): Unit =
-    val parser = new TastyParser(reflect, this, config)
+  def processCompilationUnit(using ctx: quoted.QuoteContext)(root: ctx.reflect.Tree): Unit =
+    val parser = new TastyParser(ctx.reflect, this, config)
     topLevels ++= parser.parseRootTree(root.asInstanceOf[parser.reflect.Tree])
 
   def result(): List[DPackage] =

scala3doc/src/main/scala/dotty/dokka/tasty/TypesSupport.scala

@@ -14,10 +14,10 @@ trait TypesSupport:
           inner(tpeTree.tpe)
         case other => None
 
-      def inner(tpe: TypeOrBounds): Option[Symbol] = tpe match
+      def inner(tpe: Type): Option[Symbol] = tpe match
         case ThisType(tpe) => inner(tpe)
         case AnnotatedType(tpe, _) => inner(tpe)
-        case AppliedType(tpe, typeOrBoundsList) => inner(tpe)
+        case AppliedType(tpe, _) => inner(tpe)
         case tp @ TermRef(qual, typeName) =>
           qual match
             case _: Type | _: NoPrefix => Some(tp.termSymbol)
@@ -45,8 +45,8 @@ trait TypesSupport:
 
                 new GenericTypeConstructor(tpeTree.symbol.dri, data.asJava, null)
 
-    given TypeOrBoundsSyntax as AnyRef:
-        extension (tpe: TypeOrBounds):
+    given TypeSyntax as AnyRef:
+        extension (tpe: Type):
             def dokkaType(using ctx: reflect.Context): Bound =
                 val data = inner(tpe)
                 val dri = data.collect{
@@ -74,7 +74,7 @@ trait TypesSupport:
         tpeAnnotation.tpe.typeSymbol.toString == "class Repeated"
 
     // TODO #23 add support for all types signatures that makes sense
-    private def inner(tp: reflect.TypeOrBounds)(using cxt: reflect.Context): List[JProjection] =
+    private def inner(tp: reflect.Type)(using cxt: reflect.Context): List[JProjection] =
         def noSupported(name: String): List[JProjection] =
             println(s"WARN: Unsupported type: $name: ${tp.show}") 
             List(text(s"Unsupported[$name]")) 
@@ -118,7 +118,7 @@ trait TypesSupport:
                         .reduceLeftOption((acc: List[JProjection], elem: List[JProjection]) => acc ++ texts(", ") ++ elem).getOrElse(List())
                     ++ texts(")")
 
-                def parseRefinedElem(name: String, info: TypeOrBounds, polyTyped: List[JProjection] = Nil): List[JProjection] = ( info match {
+                def parseRefinedElem(name: String, info: Type, polyTyped: List[JProjection] = Nil): List[JProjection] = ( info match {
                     case m: MethodType => {
                         val paramList = getParamList(m)
                         texts(s"def $name") ++ polyTyped ++ paramList ++ texts(": ") ++ inner(m.resType)
@@ -137,7 +137,7 @@ trait TypesSupport:
                     case other => noSupported(s"Not supported type in refinement $info")
                 } ) ++ texts("; ")
 
-                def parsePolyFunction(info: TypeOrBounds): List[JProjection] = info match {
+                def parsePolyFunction(info: Type): List[JProjection] = info match {
                     case t: PolyType =>
                         val paramBounds = getParamBounds(t)
                         val method = t.resType.asInstanceOf[MethodType]
@@ -156,16 +156,16 @@ trait TypesSupport:
                     prefix ++ texts("{ ") ++ refinedElems.flatMap(e => parseRefinedElem(e.name, e.info)) ++ texts(" }")
                 }
             }
-            case t @ AppliedType(tpe, typeOrBoundsList) =>
+            case t @ AppliedType(tpe, typeList) =>
                 import scala.internal.Chars._
-                if !t.typeSymbol.name.forall(isIdentifierPart) && typeOrBoundsList.size == 2 then
-                    inner(typeOrBoundsList.head) 
+                if !t.typeSymbol.name.forall(isIdentifierPart) && typeList.size == 2 then
+                    inner(typeList.head) 
                     ++ texts(" ") 
                     ++ inner(tpe) 
                     ++ texts(" ") 
-                    ++ inner(typeOrBoundsList.last)
+                    ++ inner(typeList.last)
                 else if t.isFunctionType then
-                    typeOrBoundsList match
+                    typeList match
                         case Nil => 
                             Nil
                         case Seq(rtpe) => 
@@ -175,12 +175,12 @@ trait TypesSupport:
                         case args => 
                             texts("(") ++ commas(args.init.map(inner)) ++ texts(") => ") ++ inner(args.last)
                 else if t.isTupleType then 
-                    typeOrBoundsList match
+                    typeList match
                         case Nil => 
                             Nil
                         case args => 
                             texts("(") ++ commas(args.map(inner)) ++ texts(")")
-                else inner(tpe) ++ texts("[") ++ commas(typeOrBoundsList.map(inner)) ++ texts("]")
+                else inner(tpe) ++ texts("[") ++ commas(typeList.map(inner)) ++ texts("]")
 
             case tp @ TypeRef(qual, typeName) =>
                 qual match {

scala3doc/src/main/scala/dotty/dokka/tasty/comments/MarkdownConverter.scala

@@ -163,14 +163,14 @@ class MarkdownConverter(val repr: Repr) extends BaseConverter {
     case _ =>
       println(s"!!! DEFAULTING @ ${n.getNodeName}")
       emit(dkkd.P(
-        List(
+        List[dkkd.DocTag](
           dkkd.Span(
             List(dkk.text(s"!!! DEFAULTING @ ${n.getNodeName}")).asJava,
             kt.emptyMap,
           ),
           dkk.text(MarkdownParser.renderToText(n))
         ).asJava,
-        kt.emptyMap
+        kt.emptyMap[String, String]
       ))
   }
 

scala3doc/src/main/scala/dotty/dokka/tasty/comments/MemberLookup.scala

@@ -104,12 +104,15 @@ trait MemberLookup {
       matched.map(hackResolveModule)
     }
 
-    owner.tree match {
-      case tree: r.ClassDef =>
-        findMatch(tree.body.iterator.collect { case t: r.Definition => t.symbol })
-      case _ =>
-        findMatch(hackMembersOf(owner))
-    }
+    if owner.isPackageDef then
+      findMatch(hackMembersOf(owner))
+    else
+      owner.tree match {
+        case tree: r.ClassDef =>
+          findMatch(tree.body.iterator.collect { case t: r.Definition => t.symbol })
+        case _ =>
+          findMatch(hackMembersOf(owner))
+      }
   }
 
   private def downwardLookup(using r: Reflection)(query: List[String], owner: r.Symbol): Option[r.Symbol] =

scala3doc/src/test/scala/dotty/dokka/DottyTestRunner.scala

@@ -98,7 +98,7 @@ abstract class DottyAbstractCoreTest extends AbstractCoreTest:
         // e.g. to remove '(0)' from object IAmACaseObject extends CaseImplementThis/*<-*/(0)/*->*/ 
         val CommentRegexp = """\/\*<-\*\/[^\/]+\/\*->\*\/"""
 
-        def (s: String).doesntStartWithAnyOfThese(c: Char*) = c.forall(char => !s.startsWith(char.toString))
+        extension (s: String) def doesntStartWithAnyOfThese(c: Char*) = c.forall(char => !s.startsWith(char.toString))
         val lines = s.getLines().map(_.trim).toList
             .filter(_.doesntStartWithAnyOfThese('=',':','{','}'))
             .filterNot(_.trim.isEmpty)