Add printing of definition names and kinds

Author: felixmulder

repl/src/dotty/tools/repl/Repl.scala

@@ -6,9 +6,15 @@ import scala.annotation.tailrec
 import dotc.reporting.MessageRendering
 import dotc.reporting.diagnostic.MessageContainer
 import dotc.ast.untpd
+import dotc.ast.tpd
 import dotc.core.Contexts.Context
+import dotc.core.Flags._
+import dotc.core.Denotations.Denotation
+import dotc.core.NameKinds.SimpleNameKind
+import dotc.core.Types.{ ExprType, ConstantType }
 import dotc.config.CompilerCommand
 import dotc.{ Compiler, Driver }
+import dotc.printing.SyntaxHighlighting
 
 import AmmoniteReader._
 import results._
@@ -61,12 +67,64 @@ class Repl(settings: Array[String]) extends Driver {
           displayErrors(errors)
           state
         },
-        (unit, newState) => {
+        (unit, newState, ctx) => {
+          displayDefinitions(unit.tpdTree)(ctx)
           newState
         }
       )
   }
 
+  def displayDefinitions(tree: tpd.Tree)(implicit ctx: Context): Unit = {
+    def display(tree: tpd.Tree) = if (tree.symbol.info.exists) {
+      val info = tree.symbol.info
+      val defn = ctx.definitions
+      val defs =
+        info.bounds.hi.finalResultType
+        .membersBasedOnFlags(Method, Synthetic | Private)
+        .filterNot { denot =>
+          denot.symbol.owner == defn.AnyClass ||
+          denot.symbol.owner == defn.ObjectClass ||
+          denot.symbol.isConstructor
+        }
+
+      val vals =
+        info.fields
+        .filterNot(_.symbol.is(ParamAccessor | Private | Synthetic | Module))
+        .filter(_.symbol.name.is(SimpleNameKind))
+
+      (
+        defs.map(Rendering.renderMethod) ++
+        vals.map(Rendering.renderVal)
+      ).foreach(println)
+    }
+
+    def displayTypeDef(tree: tpd.TypeDef) = {
+      val sym = tree.symbol
+      val name = tree.name.show.dropRight(if (sym.is(Module)) 1 else 0)
+
+      val kind =
+        if (sym.is(CaseClass)) "case class"
+        else if (sym.is(Trait)) "trait"
+        else if (sym.is(Module)) "object"
+        else "class"
+
+
+      println(SyntaxHighlighting(s"defined $kind $name"))
+    }
+
+
+    tree match {
+      case tpd.PackageDef(_, xs) =>
+        val allTypeDefs = xs.collect { case td: tpd.TypeDef => td }
+        val (objs, tds) = allTypeDefs.partition(_.name.show.startsWith("ReplSession"))
+        objs
+          .foreach(display)
+        tds
+          .filterNot(t => t.symbol.is(Synthetic) || !t.name.is(SimpleNameKind))
+          .foreach(displayTypeDef)
+    }
+  }
+
   def interpretCommand(cmd: Command, state: State): Unit = cmd match {
     case UnknownCommand(cmd) => {
       println(s"""Unknown command: "$cmd", run ":help" for a list of commands""")

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

@@ -110,26 +110,26 @@ class ReplCompiler(ictx: Context) extends Compiler {
     unit.result
   }
 
-  def runCompilation(unit: CompilationUnit, state: State): Result[State] = {
+  def runCompilation(unit: CompilationUnit, state: State): Result[(State, Context)] = {
     implicit val ctx = ictx
     val reporter = new StoreReporter(null) with UniqueMessagePositions with HideNonSensicalMessages
     val run = newRun(ctx.fresh.setReporter(reporter))
     run.compileUnits(unit :: Nil)
 
     val errs = reporter.removeBufferedMessages
-    if (errs.isEmpty) state.copy(
-      objectIndex = state.objectIndex + 1,
-      valIndex    = state.valIndex
-    ).result
+    if (errs.isEmpty) {
+      val newState = State(state.objectIndex + 1, state.valIndex, state.history)
+      (newState, run.runContext).result
+    }
     else errs.errors
   }
 
-  def compile(parsed: Parsed, state: State): Result[(CompilationUnit, State)] = {
+  def compile(parsed: Parsed, state: State): Result[(CompilationUnit, State, Context)] = {
     implicit val ctx = ictx
     for {
-      defs  <- definitions(parsed.trees, state)
-      unit  <- createUnit(defs.trees, state.objectIndex, parsed.sourceCode)
-      state <- runCompilation(unit, defs.state)
-    } yield (unit, state)
+      defs         <- definitions(parsed.trees, state)
+      unit         <- createUnit(defs.trees, state.objectIndex, parsed.sourceCode)
+      (state, ctx) <- runCompilation(unit, defs.state)
+    } yield (unit, state, ctx)
   }
 }

repl/src/dotty/tools/repl/render.scala

@@ -0,0 +1,43 @@
+package dotty.tools
+package repl
+
+import dotc.core.Types._
+import dotc.core.Contexts.Context
+import dotc.core.Denotations.Denotation
+import dotc.core.Flags
+
+object Rendering {
+
+  def renderMethod(d: Denotation)(implicit ctx: Context): String = {
+    def params(tpe: Type): String = tpe match {
+      case ConstantType(c) => ": " + c.value
+      case tpe: ParamRef => ": " + tpe.paramName + ".type"
+      case tpe: TypeRef => ": " + tpe.show
+      case mt: MethodType =>
+        val ps = mt.paramNames.zip(mt.paramInfos).map { (name, tpe) =>
+          val tp = tpe match {
+            case ConstantType(c) => c.value.toString
+            case tpe => tpe.show
+          }
+          s"${name.show}: $tp"
+        }
+        val plist =
+          if (mt.resultType.isInstanceOf[ExprType]) ""
+          else "(" + ps.mkString(", ") + ")"
+
+        plist + params(mt.resultType)
+    }
+
+    s"def ${d.symbol.name.show}${params(d.info)}"
+  }
+
+  def renderVal(d: Denotation)(implicit ctx: Context): String = {
+    val prefix = if (d.symbol.is(Flags.Mutable)) "var" else "val"
+    val tpe = d.info match {
+      case ConstantType(c) => c.value.toString
+      case tpe => tpe.show
+    }
+    s"$prefix ${d.symbol.name.show}: $tpe"
+  }
+
+}

repl/src/dotty/tools/repl/results.scala

@@ -7,7 +7,7 @@ object results {
   type Errors = Seq[MessageContainer]
 
   /** A result of a computation is either a list of errors or the result `A` */
-  class Result[A] private[results] (result: Errors | A) {
+  class Result[A] private[results] (result: Errors | A) { self =>
     def flatMap[B](f: A => Result[B]): Result[B] =
       result match {
         case errs: Errors => new Result(errs)
@@ -25,6 +25,13 @@ object results {
         case errs: Errors => onErrors(errs)
         case a: A @unchecked => onResult(a)
       }
+
+    class WithFilter(p: A => Boolean) {
+      def flatMap[B](f: A => Result[B]) = self.flatMap(f)
+      def map[B](f: A => B) = self.map(f)
+    }
+
+    def withFilter(p: A => Boolean) = new WithFilter(p)
   }
 
   implicit class ResultConversionA[A](val a: A) extends AnyVal {

repl/test/dotty/tools/repl/CompilerTests.scala

@@ -27,13 +27,13 @@ class ReplCompilerTests extends ReplTest {
 
     compiler
       .compile(parsed, State(0, 0, Nil))
-      .flatMap { (unit, state) =>
-        val parsed @ Parsed(_,_) = ParseResult("def foo(i: Int): i.type = i")
+      .flatMap { (unit, state, ctx) =>
+        val parsed @ Parsed(_,_) = ParseResult("def foo(i: Int): i.type = i")(ctx)
         compiler.compile(parsed, state)
       }
       .fold(
         onErrors(_),
-        (unit, state) => {
+        (unit, state, ctx) => {
           assert(state.objectIndex == 2,
             s"Wrong object offset: expected 2 got ${state.objectIndex}")
         }