Add Comments object instead of Scanners.Comment case class

Author: felixmulder

dottydoc/src/dotty/tools/dottydoc/model/comment/CommentExpander.scala

@@ -77,7 +77,7 @@ trait CommentExpander {
    */
   def cookedDocComment(sym: Symbol, docStr: String = "")(implicit ctx: Context): String = cookedDocComments.getOrElseUpdate(sym, {
     var ownComment =
-      if (docStr.length == 0) ctx.docbase.docstring(sym).map(c => template(c.chrs)).getOrElse("")
+      if (docStr.length == 0) ctx.docbase.docstring(sym).map(c => template(c.raw)).getOrElse("")
       else template(docStr)
     ownComment = replaceInheritDocToInheritdoc(ownComment)
 
@@ -287,7 +287,7 @@ trait CommentExpander {
   def defineVariables(sym: Symbol)(implicit ctx: Context) = {
     val Trim = "(?s)^[\\s&&[^\n\r]]*(.*?)\\s*$".r
 
-    val raw = ctx.docbase.docstring(sym).map(_.chrs).getOrElse("")
+    val raw = ctx.docbase.docstring(sym).map(_.raw).getOrElse("")
     defs(sym) ++= defines(raw).map {
       str => {
         val start = skipWhitespace(str, "@define".length)

src/dotty/tools/dotc/ast/Trees.scala

@@ -4,7 +4,7 @@ package ast
 
 import core._
 import Types._, Names._, Flags._, util.Positions._, Contexts._, Constants._, SymDenotations._, Symbols._
-import Denotations._, StdNames._
+import Denotations._, StdNames._, Comments._
 import annotation.tailrec
 import language.higherKinds
 import collection.IndexedSeqOptimized
@@ -15,7 +15,6 @@ import printing.Printer
 import util.{Stats, Attachment, DotClass}
 import annotation.unchecked.uncheckedVariance
 import language.implicitConversions
-import parsing.Scanners.Comment
 
 object Trees {
 

src/dotty/tools/dotc/core/Comments.scala

@@ -0,0 +1,77 @@
+package dotty.tools
+package dotc
+package core
+
+import dotc.ast.{ untpd, tpd }
+import Decorators._
+import Symbols._
+import Contexts.Context
+import Flags.EmptyFlags
+import dotc.util.SourceFile
+import dotc.util.Positions.Position
+import dotc.parsing.Parsers.Parser
+import dotty.tools.dottydoc.model.comment.CommentUtils._
+
+object Comments {
+
+  case class Comment(pos: Position, raw: String)(implicit ctx: Context) {
+    val isDocComment = raw.startsWith("/**")
+
+    private[this] lazy val sections = tagIndex(raw)
+
+    private def fold[A](z: A)(op: => A) = if (!isDocComment) z else op
+
+    lazy val usecases = fold(List.empty[UseCase]) {
+      sections
+        .filter { startsWithTag(raw, _, "@usecase") }
+        .map { case (start, end) => decomposeUseCase(start, end) }
+    }
+
+    /** Turns a usecase section into a UseCase, with code changed to:
+     *  {{{
+     *  // From:
+     *  def foo: A
+     *  // To:
+     *  def foo: A = ???
+     *  }}}
+     */
+    private def decomposeUseCase(start: Int, end: Int): UseCase = {
+      val codeStart    = skipWhitespace(raw, start + "@usecase".length)
+      val codeEnd      = skipToEol(raw, codeStart)
+      val code         = raw.substring(codeStart, codeEnd)
+      val codePos      = Position(codeStart, codeEnd)
+      val commentStart = skipLineLead(raw, codeEnd + 1) min end
+      val comment      = "/** " + raw.substring(commentStart, end) + "*/"
+      val commentPos   = Position(commentStart, end)
+
+      UseCase(Comment(commentPos, comment), code + " = ???", codePos)
+    }
+  }
+
+  case class UseCase(comment: Comment, code: String, codePos: Position)(implicit ctx: Context) {
+    /** Entered by Namer */
+    var symbol: Symbol = _
+
+    lazy val untpdCode: untpd.Tree = {
+      val tree = new Parser(new SourceFile("<usecase>", code)).localDef(codePos.start, EmptyFlags)
+
+      tree match {
+        case tree: untpd.DefDef => tree
+        case _ =>
+          ctx.error("proper def was not found in `@usecase`", codePos)
+          tree
+      }
+    }
+
+    /** Set by typer calling `typeTree` */
+    var tpdCode: tpd.DefDef = _
+
+    def typeTree()(implicit ctx: Context): Unit = untpdCode match {
+      case df: untpd.DefDef => ctx.typer.typedDefDef(df, symbol) match {
+        case tree: tpd.DefDef => tpdCode = tree
+        case _ => ctx.error("proper def was not found in `@usecase`", codePos)
+      }
+      case _ => ctx.error("proper def was not found in `@usecase`", codePos)
+    }
+  }
+}

src/dotty/tools/dotc/core/Contexts.scala

@@ -13,6 +13,7 @@ import Scopes._
 import NameOps._
 import Uniques._
 import SymDenotations._
+import Comments._
 import Flags.ParamAccessor
 import util.Positions._
 import ast.Trees._
@@ -29,7 +30,6 @@ import printing._
 import config.{Settings, ScalaSettings, Platform, JavaPlatform, SJSPlatform}
 import language.implicitConversions
 import DenotTransformers.DenotTransformer
-import parsing.Scanners.Comment
 import xsbti.AnalysisCallback
 
 object Contexts {

src/dotty/tools/dotc/parsing/Parsers.scala

@@ -19,10 +19,10 @@ import StdNames._
 import util.Positions._
 import Constants._
 import ScriptParsers._
+import Comments._
 import scala.annotation.{tailrec, switch}
 import util.DotClass
 import rewrite.Rewrites.patch
-import Scanners.Comment
 
 object Parsers {
 

src/dotty/tools/dotc/parsing/Scanners.scala

@@ -3,7 +3,7 @@ package dotc
 package parsing
 
 import core.Names._, core.Contexts._, core.Decorators._, util.Positions._
-import core.StdNames._
+import core.StdNames._, core.Comments._
 import util.SourceFile
 import java.lang.Character.isDigit
 import scala.reflect.internal.Chars._
@@ -22,10 +22,6 @@ object Scanners {
   /** An undefined offset */
   val NoOffset: Offset = -1
 
-  case class Comment(pos: Position, chrs: String) {
-    def isDocComment = chrs.startsWith("/**")
-  }
-
   type Token = Int
 
   trait TokenData {