Add CookComments miniphase

This miniphase is used to cook the comments when `-Ycook-comments` is
set. This phase is used by the compiler, the REPL, Dotty IDE and
Dottydoc.

Author: Duhemm

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -59,7 +59,8 @@ class Compiler {
   protected def transformPhases: List[List[Phase]] =
     List(new FirstTransform,         // Some transformations to put trees into a canonical form
          new CheckReentrant,         // Internal use only: Check that compiled program has no data races involving global vars
-         new ElimPackagePrefixes) :: // Eliminate references to package prefixes in Select nodes
+         new ElimPackagePrefixes,    // Eliminate references to package prefixes in Select nodes
+         new CookComments) ::        // Cook the comments: expand variables, doc, etc.
     List(new CheckStatic,            // Check restrictions that apply to @static members
          new ElimRepeated,           // Rewrite vararg parameters and arguments
          new ExpandSAMs,             // Expand single abstract method closures to anonymous classes

compiler/src/dotty/tools/dotc/fromtasty/ReadTastyTreesFromClasses.scala

@@ -45,9 +45,6 @@ class ReadTastyTreesFromClasses extends FrontEnd {
               else {
                 val unit = mkCompilationUnit(cls, cls.tree, forceTrees = true)
                 unit.pickled += (cls -> unpickler.unpickler.bytes)
-                if (ctx.settings.YcookComments.value) {
-                  ctx.typer.cookComments(cls.tree, cls)
-                }
                 Some(unit)
               }
             case tree: Tree[_] =>

compiler/src/dotty/tools/dotc/interactive/InteractiveCompiler.scala

@@ -13,6 +13,7 @@ class InteractiveCompiler extends Compiler {
   // This could be improved by reporting errors back to the IDE
   // after each phase group instead of waiting for the pipeline to finish.
   override def phases: List[List[Phase]] = List(
-    List(new FrontEnd)
+    List(new FrontEnd),
+    List(new transform.CookComments)
   )
 }

compiler/src/dotty/tools/dotc/interactive/InteractiveDriver.scala

@@ -33,6 +33,7 @@ class InteractiveDriver(val settings: List[String]) extends Driver {
   private val myInitCtx: Context = {
     val rootCtx = initCtx.fresh.addMode(Mode.ReadPositions).addMode(Mode.Interactive).addMode(Mode.ReadComments)
     rootCtx.setSetting(rootCtx.settings.YretainTrees, true)
+    rootCtx.setSetting(rootCtx.settings.YcookComments, true)
     val ctx = setup(settings.toArray, rootCtx)._2
     ctx.initialize()(ctx)
     ctx

compiler/src/dotty/tools/dotc/transform/CookComments.scala

@@ -0,0 +1,28 @@
+package dotty.tools.dotc.transform
+
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.typer.Docstrings
+
+class CookComments extends MegaPhase.MiniPhase {
+  override def phaseName = "cookComments"
+
+  override def transformTypeDef(tree: tpd.TypeDef)(implicit ctx: Context): tpd.Tree = {
+    if (ctx.settings.YcookComments.value && tree.isClassDef) {
+      val cls = tree.symbol
+      val cookingCtx = ctx.localContext(tree, cls).setNewScope
+      val template = tree.rhs.asInstanceOf[tpd.Template]
+      val owner = template.self.symbol.orElse(cls)
+
+      template.body.foreach { stat =>
+        Docstrings.cookComment(stat.symbol, owner)(cookingCtx)
+      }
+
+      Docstrings.cookComment(cls, cls)(cookingCtx)
+    }
+
+    tree
+
+  }
+
+}

compiler/src/dotty/tools/dotc/typer/Docstrings.scala

@@ -6,21 +6,7 @@ import core._
 import Contexts._, Symbols._, Decorators._, Comments._
 import ast.tpd
 
-trait Docstrings { self: Typer =>
-
-  /**
-   * Expands or cooks the documentation for all members of `cdef`.
-   *
-   * @see Docstrings#cookComment
-   */
-  def cookComments(cdef: tpd.Tree, cls: ClassSymbol)(implicit ctx: Context): Unit = {
-    // val cls = cdef.symbol
-    val cookingCtx = ctx.localContext(cdef, cls).setNewScope
-    cls.info.allMembers.foreach { member =>
-      cookComment(member.symbol, cls)(cookingCtx)
-    }
-    cookComment(cls, cls)(cookingCtx)
-  }
+object Docstrings {
 
   /**
    * Expands or cooks the documentation for `sym` in class `owner`.
@@ -47,8 +33,8 @@ trait Docstrings { self: Typer =>
       case _ =>
         expandComment(sym).map { expanded =>
           val typedUsecases = expanded.usecases.map { usecase =>
-            enterSymbol(createSymbol(usecase.untpdCode))
-            typedStats(usecase.untpdCode :: Nil, owner) match {
+            ctx.typer.enterSymbol(ctx.typer.createSymbol(usecase.untpdCode))
+            ctx.typer.typedStats(usecase.untpdCode :: Nil, owner) match {
               case List(df: tpd.DefDef) =>
                 usecase.typed(df)
               case _ =>

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -85,8 +85,7 @@ class Typer extends Namer
                with Implicits
                with Inferencing
                with Dynamic
-               with Checking
-               with Docstrings {
+               with Checking {
 
   import Typer._
   import tpd.{cpy => _, _}
@@ -1592,12 +1591,6 @@ class Typer extends Namer
 
       if (ctx.settings.YretainTrees.value) cls.treeOrProvider = cdef1
 
-      // Expand comments and type usecases if `-Ycook-comments` is set.
-      if (ctx.settings.YcookComments.value) {
-        cookComments(cdef1, cls)
-      }
-
-
       cdef1
 
       // todo later: check that

compiler/src/dotty/tools/repl/ReplCompiler.scala

@@ -14,7 +14,7 @@ import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.reporting.diagnostic.messages
 import dotty.tools.dotc.transform.PostTyper
-import dotty.tools.dotc.typer.{FrontEnd, ImportInfo, Typer}
+import dotty.tools.dotc.typer.ImportInfo
 import dotty.tools.dotc.util.Positions._
 import dotty.tools.dotc.util.SourceFile
 import dotty.tools.dotc.{CompilationUnit, Compiler, Run}
@@ -195,13 +195,11 @@ class ReplCompiler extends Compiler {
         if (stat.tpe.isError) stat.tpe.show
         else {
           val symbols = extractSymbols(stat)
-          val typer = new Typer()
           val doc = for {
             sym <- symbols
-            owner = sym.owner
-            cookingCtx = ctx.withOwner(owner)
-            cooked <- typer.cookComment(sym, owner)(cookingCtx)
-            body <- cooked.expandedBody
+            docCtx <- ctx.docCtx
+            comment <- docCtx.docstring(sym)
+            body <- comment.expandedBody
           } yield body
 
           if (doc.hasNext) doc.next()

compiler/src/dotty/tools/repl/ReplDriver.scala

@@ -65,6 +65,7 @@ class ReplDriver(settings: Array[String],
   /** Create a fresh and initialized context with IDE mode enabled */
   private[this] def initialCtx = {
     val rootCtx = initCtx.fresh.addMode(Mode.ReadPositions | Mode.Interactive | Mode.ReadComments)
+    rootCtx.setSetting(rootCtx.settings.YcookComments, true)
     val ictx = setup(settings, rootCtx)._2
     ictx.base.initialize()(ictx)
     ictx

doc-tool/src/dotty/tools/dottydoc/DocCompiler.scala

@@ -9,6 +9,7 @@ import dotc.core.Mode
 import dotc.{Compiler, Run}
 
 import dotty.tools.dotc.fromtasty.{ReadTastyTreesFromClasses, TASTYRun}
+import dotty.tools.dotc.transform.CookComments
 
 /** Custom Compiler with phases for the documentation tool
  *
@@ -41,6 +42,7 @@ class DocCompiler extends Compiler {
     Nil
 
   override protected def transformPhases: List[List[Phase]] =
+    List(new CookComments) ::
     List(new DocImplicitsPhase) ::
     List(new DocASTPhase) ::
     List(DocMiniTransformations(new UsecasePhase,

language-server/src/dotty/tools/languageserver/DottyLanguageServer.scala

@@ -368,16 +368,7 @@ class DottyLanguageServer extends LanguageServer
     if (tpw == NoType) null // null here indicates that no response should be sent
     else {
       val symbol = Interactive.enclosingSourceSymbol(trees, pos)
-      val docComment = ctx.docCtx.flatMap(_.docstring(symbol)).map {
-        case comment if !comment.isExpanded =>
-          val typer = new Typer()
-          val owner = symbol.owner
-          val cookingCtx = ctx.withOwner(owner)
-          typer.cookComment(symbol, owner)(cookingCtx)
-          ctx.docCtx.get.docstring(symbol).get
-        case comment =>
-          comment
-      }
+      val docComment = ctx.docCtx.flatMap(_.docstring(symbol))
       val content = hoverContent(tpw.show, docComment)
       new Hover(content, null)
     }