Support show on Type[T]

Author: liufengyun

compiler/src/dotty/tools/dotc/quoted/QuoteDriver.scala

@@ -41,17 +41,25 @@ class QuoteDriver extends Driver {
     method.invoke(inst).asInstanceOf[T]
   }
 
-  def show(expr: Expr[_], settings: Toolbox.Settings): String = {
-    def show(tree: Tree, ctx: Context): String = {
-      implicit val c: Context = ctx
-      val tree1 =
-        if (ctx.settings.YshowRawQuoteTrees.value) tree
-        else (new TreeCleaner).transform(tree)
-      new ReflectionImpl(ctx).showSourceCode.showTree(tree1)
-    }
-    withTree(expr, show, settings)
+  private def doShow(tree: Tree, ctx: Context): String = {
+    implicit val c: Context = ctx
+    val tree1 =
+      if (ctx.settings.YshowRawQuoteTrees.value) tree
+      else (new TreeCleaner).transform(tree)
+    val printer = new ReflectionImpl(ctx).showSourceCode
+    if (tree.isType)
+      printer.showTypeOrBoundsTree(tree1)
+    else
+      printer.showTree(tree1)
   }
 
+  def show(expr: Expr[_], settings: Toolbox.Settings): String =
+    withTree(expr, doShow, settings)
+
+  def show(tpe: Type[_], settings: Toolbox.Settings): String =
+    withTypeTree(tpe, doShow, settings)
+
+
   def withTree[T](expr: Expr[_], f: (Tree, Context) => T, settings: Toolbox.Settings): T = {
     val ctx = setToolboxSettings(setup(settings.compilerArgs.toArray :+ "dummy.scala", initCtx.fresh)._2.fresh, settings)
 
@@ -65,7 +73,7 @@ class QuoteDriver extends Driver {
   }
 
   def withTypeTree[T](tpe: Type[_], f: (TypTree, Context) => T, settings: Toolbox.Settings): T = {
-    val (_, ctx: Context) = setup(settings.compilerArgs.toArray :+ "dummy.scala", initCtx.fresh)
+    val ctx = setToolboxSettings(setup(settings.compilerArgs.toArray :+ "dummy.scala", initCtx.fresh)._2.fresh, settings)
 
     var output: Option[T] = None
     def registerTree(tree: tpd.Tree)(ctx: Context): Unit = {

compiler/src/dotty/tools/dotc/quoted/ToolboxImpl.scala

@@ -2,7 +2,7 @@ package dotty.tools.dotc.quoted
 
 import dotty.tools.dotc.ast.tpd
 
-import scala.quoted.Expr
+import scala.quoted._
 import scala.quoted.Exprs.{LiftedExpr, TastyTreeExpr}
 
 /** Default runners for quoted expressions */
@@ -24,5 +24,6 @@ object ToolboxImpl {
 
     def show[T](expr: Expr[T]): String = synchronized(driver.show(expr, settings))
 
+    def show[T](tpe: Type[T]): String = synchronized(driver.show(tpe, settings))
   }
 }

library/src/scala/quoted/Toolbox.scala

@@ -6,6 +6,7 @@ import scala.annotation.implicitNotFound
 trait Toolbox {
   def run[T](expr: Expr[T]): T
   def show[T](expr: Expr[T]): String
+  def show[T](tpe: Type[T]): String
 }
 
 object Toolbox {
@@ -32,7 +33,7 @@ object Toolbox {
   }
 
   /** Setting of the Toolbox instance. */
-  class Settings private (val outDir: Option[String], val showRawTree: Boolean, val compilerArgs: List[String], val color: Boolean)
+  case class Settings private (val outDir: Option[String], val showRawTree: Boolean, val compilerArgs: List[String], val color: Boolean)
 
   object Settings {
 

library/src/scala/quoted/Type.scala

@@ -6,6 +6,9 @@ import scala.runtime.quoted.Unpickler.Pickled
 
 sealed abstract class Type[T] {
   type unary_~ = T
+
+  /** Show a source code like representation of this type */
+  final def show(implicit toolbox: Toolbox): String = toolbox.show(this)
 }
 
 /** Some basic type tags, currently incomplete */

library/src/scala/tasty/reflect/Printers.scala

@@ -1367,6 +1367,9 @@ trait Printers
             case tpe @ Type.SymRef(IsClassSymbol(sym), _) if sym.name.endsWith("$") =>
               printType(tpe)
               this += ".type"
+            case tpe @ Type.SymRef(sym, _) if !IsTypeSymbol.unapply(sym).nonEmpty =>
+              printType(tpe)
+              this += ".type"
             case tpe => printType(tpe)
           }
           printTypeAndAnnots(tree.tpe)
@@ -1459,20 +1462,29 @@ trait Printers
         case Type.ConstantType(const) =>
           printConstant(const)
 
-        case Type.SymRef(sym, prefix) =>
+        case Type.SymRef(sym, prefix) if IsTypeSymbol.unapply(sym).nonEmpty =>
           prefix match {
             case Types.EmptyPrefix() =>
             case IsType(prefix @ Type.SymRef(IsClassSymbol(_), _)) =>
               printType(prefix)
               this += "#"
             case IsType(prefix) =>
-              if (!sym.flags.is(Flags.Local)) {
-                printType(prefix)
-                this += "."
-              }
+              printType(prefix)
+              this += "."
           }
           this += highlightTypeDef(sym.name.stripSuffix("$"), color)
 
+        case Type.SymRef(sym, prefix) if !IsTypeSymbol.unapply(sym).nonEmpty =>
+          prefix match {
+            case Types.EmptyPrefix() =>
+                this += highlightTypeDef(sym.name, color)
+            case _ =>
+              printTypeOrBound(prefix)
+              if (sym.name != "package")
+                this += "." += highlightTypeDef(sym.name, color)
+              this
+          }
+
         case Type.TermRef(name, prefix) =>
           prefix match {
             case Type.ThisType(Types.EmptyPackage()) =>