Add tastyreflect comment API

compiler/src/dotty/tools/dotc/consumetasty/TastyFromClass.scala

@@ -1,5 +1,8 @@
 package dotty.tools.dotc.consumetasty
 
+import dotty.tools.dotc.Run
+import dotty.tools.dotc.core.Mode
+import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.Phases.Phase
 import dotty.tools.dotc.fromtasty._
 
@@ -17,4 +20,9 @@ class TastyFromClass(consumer: TastyConsumer) extends TASTYCompiler {
   override protected def backendPhases: List[List[Phase]] =
     List(new TastyConsumerPhase(consumer)) ::  // Print all loaded classes
     Nil
+
+  override def newRun(implicit ctx: Context): Run = {
+    reset()
+    new TASTYRun(this, ctx.fresh.addMode(Mode.ReadPositions).addMode(Mode.ReadComments))
+  }
 }

compiler/src/dotty/tools/dotc/tastyreflect/CommentOpsImpl.scala

@@ -0,0 +1,10 @@
+package dotty.tools.dotc.tastyreflect
+
+trait CommentOpsImpl extends scala.tasty.reflect.CommentOps with CoreImpl {
+
+  implicit def CommentDeco(com: Comment): CommentAPI = new CommentAPI {
+    override def raw: String = com.raw
+    override def expanded: Option[String] = com.expanded
+    override def usecases: List[(String, Option[DefDef])] = com.usecases.map { uc => (uc.code, uc.tpdCode) }
+  }
+}

compiler/src/dotty/tools/dotc/tastyreflect/CoreImpl.scala

@@ -115,6 +115,8 @@ trait CoreImpl extends scala.tasty.reflect.Core {
 
   type Position = util.SourcePosition
 
+  type Comment = core.Comments.Comment
+
   type Constant = Constants.Constant
 
   type Symbol = core.Symbols.Symbol

compiler/src/dotty/tools/dotc/tastyreflect/ReflectionImpl.scala

@@ -8,6 +8,7 @@ class ReflectionImpl(val rootContext: Contexts.Context)
     with CaseDefOpsImpl
     with ConstantOpsImpl
     with ContextOpsImpl
+    with CommentOpsImpl
     with FlagsOpsImpl
     with IdOpsImpl
     with ImportSelectorOpsImpl

compiler/src/dotty/tools/dotc/tastyreflect/SymbolOpsImpl.scala

@@ -28,6 +28,16 @@ trait SymbolOpsImpl extends scala.tasty.reflect.SymbolOps with CoreImpl {
 
     def pos(implicit ctx: Context): Position = symbol.sourcePos
 
+    def comment(implicit ctx: Context): Option[Comment] = {
+      import dotty.tools.dotc.core.Comments.CommentsContext
+      val docCtx = ctx.docCtx.getOrElse {
+        throw new RuntimeException(
+          "DocCtx could not be found and comments are unavailable. This is a compiler-internal error."
+        )
+      }
+      docCtx.docstring(symbol)
+    }
+
     def owner(implicit ctx: Context): Symbol = symbol.owner
 
     def isLocalDummy(implicit ctx: Context): Boolean = symbol.isLocalDummy

library/src/scala/tasty/Reflection.scala

@@ -7,6 +7,7 @@ abstract class Reflection
     with CaseDefOps
     with ConstantOps
     with ContextOps
+    with CommentOps
     with FlagsOps
     with IdOps
     with ImportSelectorOps

library/src/scala/tasty/reflect/CommentOps.scala

@@ -0,0 +1,19 @@
+package scala.tasty.reflect
+
+trait CommentOps extends Core {
+
+  trait CommentAPI {
+
+    /** Raw comment string */
+    def raw: String
+
+    /** Expanded comment string, if any */
+    def expanded: Option[String]
+
+    /** List of usecases and their corresponding trees, if any */
+    def usecases: List[(String, Option[DefDef])]
+
+  }
+  implicit def CommentDeco(com: Comment): CommentAPI
+
+}

library/src/scala/tasty/reflect/Core.scala

@@ -410,6 +410,9 @@ trait Core {
   /** Source position */
   type Position <: AnyRef
 
+  /** Comment */
+  type Comment <: AnyRef
+
   /** Constant value represented as the constant itself */
   type Constant <: AnyRef
 

library/src/scala/tasty/reflect/SymbolOps.scala

@@ -37,6 +37,9 @@ trait SymbolOps extends Core {
     /** The position of this symbol */
     def pos(implicit ctx: Context): Position
 
+    /** The comment for this symbol, if any */
+    def comment(implicit ctx: Context): Option[Comment]
+
     def localContext(implicit ctx: Context): Context
 
     /** Unsafe cast as to PackageSymbol. Use IsPackageSymbol to safly check and cast to PackageSymbol */

tests/run-with-compiler/tasty-comment-consumer.check

@@ -0,0 +1,7 @@
+/** Object with comment */
+/** Object with comment */
+
+
+
+/** Val with comment */
+

tests/run-with-compiler/tasty-comment-consumer/Foo.scala

@@ -0,0 +1,8 @@
+/** Object with comment */
+object Foo {
+
+  /** Val with comment */
+  val x = null
+
+  val y = null // val without comment
+}

tests/run-with-compiler/tasty-comment-consumer/Test.scala

@@ -0,0 +1,31 @@
+import scala.tasty.Reflection
+import scala.tasty.file._
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    ConsumeTasty("", List("Foo"), new CommentConsumer)
+  }
+}
+
+class CommentConsumer extends TastyConsumer {
+
+  final def apply(reflect: Reflection)(root: reflect.Tree): Unit = {
+    import reflect._
+    object Traverser extends TreeTraverser {
+
+      override def traverseTree(tree: Tree)(implicit ctx: Context): Unit = tree match {
+        case IsDefinition(tree) =>
+          tree.symbol.comment match {
+            case Some(com) => println(com.raw)
+            case None => println()
+          }
+          super.traverseTree(tree)
+        case tree =>
+          super.traverseTree(tree)
+      }
+
+    }
+    Traverser.traverseTree(root)(reflect.rootContext)
+  }
+
+}

tests/run/tasty-comments.check

@@ -0,0 +1,3 @@
+/** Object with a docstring */
+/** Val with a docstring */
+

tests/run/tasty-comments/quoted_1.scala

@@ -0,0 +1,19 @@
+import scala.quoted._
+
+import scala.tasty._
+
+object Macros {
+
+  inline def printComment[T](t: => T): Unit =
+    ${ impl('t) }
+
+  def impl[T](x: Expr[T])(implicit reflect: Reflection): Expr[Unit] = {
+    import reflect._
+
+    val tree = x.unseal
+    tree.symbol.comment.map(_.raw) match {
+      case Some(str) => '{ println(${str.toExpr}) }
+      case None => '{ println() }
+    }
+  }
+}

tests/run/tasty-comments/quoted_2.scala

@@ -0,0 +1,18 @@
+import Macros._
+
+object Test {
+
+  /** Object with a docstring */
+  object Obj
+
+  /** Val with a docstring */
+  val x: Null = null
+
+  val y: Null = null // val without a docstring
+
+  def main(args: Array[String]): Unit = {
+    printComment(Obj)
+    printComment(x)
+    printComment(y)
+  }
+}