Start new, direct HK scheme

- Re-introduce newHK option. Label some things that will be
removed with OLD.

1 files changed, 32 insertions, 3 deletions

diff --git a/src/dotty/tools/dotc/printing/PlainPrinter.scala b/src/dotty/tools/dotc/printing/PlainPrinter.scala
index a8888fd3c..07819ef77 100644
--- a/src/dotty/tools/dotc/printing/PlainPrinter.scala
+++ b/src/dotty/tools/dotc/printing/PlainPrinter.scala
@@ -6,6 +6,7 @@ import Texts._, Types._, Flags._, Names._, Symbols._, NameOps._, Constants._, De
 import Contexts.Context, Scopes.Scope, Denotations.Denotation, Annotations.Annotation
 import StdNames.{nme, tpnme}
 import ast.Trees._, ast._
+import config.Config
 import java.lang.Integer.toOctalString
 import config.Config.summarizeDepth
 import scala.annotation.switch
@@ -50,8 +51,8 @@ class PlainPrinter(_ctx: Context) extends Printer {
           homogenize(tp1) & homogenize(tp2)
         case OrType(tp1, tp2) =>
           homogenize(tp1) | homogenize(tp2)
-        case tp: RefinedType =>
-          tp.normalizeHkApply
+        case tp: RefinedType if !Config.newHK =>
+          tp.normalizeHkApplyOLD
         case tp: SkolemType =>
           homogenize(tp.info)
         case tp: LazyRef =>
@@ -110,6 +111,30 @@ class PlainPrinter(_ctx: Context) extends Printer {
   protected def toTextRefinement(rt: RefinedType) =
     (refinementNameString(rt) ~ toTextRHS(rt.refinedInfo)).close
 
+  protected def argText(arg: Type): Text = arg match {
+    case arg: TypeBounds => "_" ~ toTextGlobal(arg)
+    case _ => toTextGlobal(arg)
+  }
+
+  /** The text for a TypeLambda
+   *
+   *     [v_1 p_1: B_1, ..., v_n p_n: B_n] -> T
+   *
+   *  where
+   *  @param  paramNames  = p_1, ..., p_n
+   *  @param  variances   = v_1, ..., v_n
+   *  @param  argBoundss  = B_1, ..., B_n
+   *  @param  body        = T
+   */
+  protected def typeLambdaText(paramNames: List[String], variances: List[Int], argBoundss: List[TypeBounds], body: Type): Text = {
+    def lambdaParamText(variance: Int, name: String, bounds: TypeBounds): Text =
+      varianceString(variance) ~ name ~ toText(bounds)
+    changePrec(GlobalPrec) {
+      "[" ~ Text((variances, paramNames, argBoundss).zipped.map(lambdaParamText), ", ") ~
+      "] -> " ~ toTextGlobal(body)
+    }
+  }
+
   /** The longest sequence of refinement types, starting at given type
    *  and following parents.
    */
@@ -174,6 +199,10 @@ class PlainPrinter(_ctx: Context) extends Printer {
         toText(polyParamName(pt.paramNames(n))) ~ polyHash(pt)
       case AnnotatedType(tpe, annot) =>
         toTextLocal(tpe) ~ " " ~ toText(annot)
+      case tp: TypeLambda =>
+        typeLambdaText(tp.paramNames.map(_.toString), tp.variances, tp.paramBounds, tp.resultType)
+      case HKApply(tycon, args) =>
+        toTextLocal(tycon) ~ "[!" ~ Text(args.map(argText), ", ") ~ "]"
       case tp: TypeVar =>
         if (tp.isInstantiated)
           toTextLocal(tp.instanceOpt) ~ "'" // debug for now, so that we can see where the TypeVars are.
@@ -186,7 +215,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
           else toText(tp.origin)
         }
       case tp: LazyRef =>
-        "LazyRef(" ~ toTextGlobal(tp.ref) ~ ")"
+        "LazyRef(" ~ toTextGlobal(tp.ref) ~ ")" // TODO: only print this during debug mode?
       case _ =>
         tp.fallbackToText(this)
     }