Cross-compile dotty-doc with the 2.13 stdlib

Author: smarter

doc-tool/src/dotty/tools/dottydoc/model/JavaConverters.scala

@@ -241,12 +241,12 @@ object JavaConverters {
     }.asJava
   }
 
-  implicit class JavaMap(val map: collection.Map[String, Package]) extends AnyVal {
+  implicit class JavaMap(val map: collection.immutable.Map[String, Package]) extends AnyVal {
     def toJavaList: LinkedList[AnyRef] =
-      convertToList(map.mapValues(_.asJava))
+      convertToList(map.transform((_, v) => v.asJava).toMap)
 
     def flattened: LinkedList[AnyRef] =
-      convertToList(map.mapValues(flattenEntity))
+      convertToList(map.transform((_, v) => flattenEntity(v)).toMap)
 
     private[this] def convertToList(ms: collection.Map[String, AnyRef]): LinkedList[AnyRef] =
       ms.toList.sortBy(_._1)

doc-tool/src/dotty/tools/dottydoc/model/comment/BodyEntities.scala

@@ -2,7 +2,7 @@ package dotty.tools.dottydoc
 package model
 package comment
 
-import scala.collection._
+import scala.collection.SortedMap
 
 /** A body of text. A comment has a single body, which is composed of
   * at least one block. Inside every body is exactly one summary (see

doc-tool/src/dotty/tools/dottydoc/model/comment/Comment.scala

@@ -87,8 +87,8 @@ trait MarkupConversion[T] extends MemberLookup {
     see                     = filterEmpty(parsed.see).map(markupToHtml),
     result                  = single("@result", parsed.result).map(markupToHtml),
     throws                  = linkedExceptions(parsed.throws),
-    valueParams             = filterEmpty(parsed.valueParams).mapValues(markupToHtml),
-    typeParams              = filterEmpty(parsed.typeParams).mapValues(markupToHtml),
+    valueParams             = filterEmpty(parsed.valueParams).transform((_, v) => markupToHtml(v)).toMap,
+    typeParams              = filterEmpty(parsed.typeParams).transform((_, v) => markupToHtml(v)).toMap,
     version                 = single("@version", parsed.version).map(markupToHtml),
     since                   = single("@since", parsed.since).map(markupToHtml),
     todo                    = filterEmpty(parsed.todo).map(markupToHtml),
@@ -97,9 +97,9 @@ trait MarkupConversion[T] extends MemberLookup {
     example                 = filterEmpty(parsed.example).map(markupToHtml),
     constructor             = single("@constructor", parsed.constructor).map(markupToHtml),
     group                   = single("@group", parsed.group).map(markupToHtml),
-    groupDesc               = filterEmpty(parsed.groupDesc).mapValues(markupToHtml),
-    groupNames              = filterEmpty(parsed.groupNames).mapValues(markupToHtml),
-    groupPrio               = filterEmpty(parsed.groupPrio).mapValues(markupToHtml),
+    groupDesc               = filterEmpty(parsed.groupDesc).transform((_, v) => markupToHtml(v)).toMap,
+    groupNames              = filterEmpty(parsed.groupNames).transform((_, v) => markupToHtml(v)).toMap,
+    groupPrio               = filterEmpty(parsed.groupPrio).transform((_, v) => markupToHtml(v)).toMap,
     hideImplicitConversions = filterEmpty(parsed.hideImplicitConversions).map(markupToHtml)
   )
 }
@@ -130,16 +130,16 @@ extends MarkupConversion[MarkdownNode] {
       .map(stringToMarkup)
 
   def filterEmpty(xs: Map[String, String])(implicit ctx: Context) =
-    xs.mapValues(_.trim)
+    xs.transform((_, v) => v.trim)
       .filterNot { case (_, v) => v.isEmpty }
-      .mapValues(stringToMarkup)
+      .transform((_, v) => stringToMarkup(v))
 }
 
 case class WikiComment(ent: Entity, parsed: ParsedComment, span: Span)
 extends MarkupConversion[Body] {
 
   def filterEmpty(xs: Map[String,String])(implicit ctx: Context) =
-    xs.mapValues(_.toWiki(ent, ctx.docbase.packages, span))
+    xs.transform((_, v) => v.toWiki(ent, ctx.docbase.packages, span))
       .filterNot { case (_, v) => v.blocks.isEmpty }
 
   def filterEmpty(xs: List[String])(implicit ctx: Context) =
@@ -157,7 +157,7 @@ extends MarkupConversion[Body] {
   }
 
   def linkedExceptions(m: Map[String, String])(implicit ctx: Context) = {
-    m.mapValues(_.toWiki(ent, ctx.docbase.packages, span)).map { case (targetStr, body) =>
+    m.transform((_, v) => v.toWiki(ent, ctx.docbase.packages, span)).map { case (targetStr, body) =>
       val link = lookup(Some(ent), ctx.docbase.packages, targetStr)
       val newBody = body match {
         case Body(List(Paragraph(Chain(content)))) =>

doc-tool/src/dotty/tools/dottydoc/model/comment/CommentCleaner.scala

@@ -19,7 +19,7 @@ trait CommentCleaner {
     val javadoclessComment = JavadocTags.replaceAllIn(safeComment, { javadocReplacement(_) })
     val markedTagComment =
       SafeTags.replaceAllIn(javadoclessComment, { mtch =>
-        Matcher.quoteReplacement(safeTagMarker + mtch.matched + safeTagMarker)
+        Matcher.quoteReplacement(s"${safeTagMarker}${mtch.matched}${safeTagMarker}")
       })
     markedTagComment.linesIterator.toList map (cleanLine)
   }

doc-tool/src/dotty/tools/dottydoc/model/comment/WikiParser.scala

@@ -97,7 +97,7 @@ private[comment] final class WikiParser(
         line = listLine(indent, style)
       }
       val constructor = listStyles(style)
-      constructor(lines)
+      constructor(lines.toList)
     }
 
     val indent = countWhitespace
@@ -370,7 +370,7 @@ private[comment] final class WikiParser(
 
     // maxSkip - size of the longest common whitespace prefix of non-empty lines
     val nonEmptyLines = lines.filter(_.trim.nonEmpty)
-    val maxSkip = if (nonEmptyLines.isEmpty) 0 else nonEmptyLines.map(line => line.prefixLength(_ == ' ')).min
+    val maxSkip = if (nonEmptyLines.isEmpty) 0 else nonEmptyLines.map(line => line.takeWhile(_ == ' ').length).min
 
     // remove common whitespace prefix
     lines.map(line => if (line.trim.nonEmpty) line.substring(maxSkip) else line).mkString("\n")

doc-tool/src/dotty/tools/dottydoc/staticsite/Page.scala

@@ -99,15 +99,15 @@ trait Page {
     _yaml = updatedYaml {
       yamlCollector
       .getData().asScala
-      .mapValues {
-        case xs if xs.size == 1 =>
+      .toMap
+      .transform {
+        case (_, xs) if xs.size == 1 =>
           val str = xs.get(0)
           if (str.length > 0 && str.head == '"' && str.last == '"')
             str.substring(1, str.length - 1)
           else str
-        case xs => xs
+        case (_, xs) => xs
       }
-      .toMap
     }
 
     // YAML must start with "---" and end in either "---" or "..."

doc-tool/src/dotty/tools/dottydoc/staticsite/Site.scala

@@ -155,7 +155,7 @@ case class Site(
         "js/tether.min.js" -> "/js/tether.min.js",
         "js/highlight.pack.js" -> "/js/highlight.pack.js"
       )
-      .mapValues(getResource)
+      .transform((_, v) => getResource(v))
       .foreach { case (path, resource) =>
         val source = new ByteArrayInputStream(resource.getBytes(StandardCharsets.UTF_8))
         val target = mkdirs(fs.getPath(outDir.getAbsolutePath, path))