Add AppliedTermRef pickling and (preliminary) pretty printing

Author: gsps

compiler/src/dotty/tools/dotc/core/tasty/TastyPrinter.scala

@@ -91,6 +91,9 @@ class TastyPrinter(bytes: Array[Byte])(implicit ctx: Context) {
                  POLYtype | TYPELAMBDAtype =>
               printTree()
               until(end) { printName(); printTree() }
+            case APPLIEDTERMREF =>
+              printTree()
+              until(end) { printTree() }
             case PARAMtype =>
               printNat(); printNat()
             case _ =>

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -167,6 +167,9 @@ class TreePickler(pickler: TastyPickler) {
     case AppliedType(tycon, args) =>
       writeByte(APPLIEDtype)
       withLength { pickleType(tycon); args.foreach(pickleType(_)) }
+    case AppliedTermRef(fn, args) =>
+      writeByte(APPLIEDTERMREF)
+      withLength { pickleType(fn); args.foreach(pickleType(_)) }
     case ConstantType(value) =>
       pickleConstant(value)
     case tpe: NamedType =>

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -344,6 +344,8 @@ class TreeUnpickler(reader: TastyReader,
                 // Eta expansion of the latter puts readType() out of the expression.
             case APPLIEDtype =>
               readType().appliedTo(until(end)(readType()))
+            case APPLIEDTERMREF =>
+              AppliedTermRef(readType().asInstanceOf[SingletonType], until(end)(readType()))
             case TYPEBOUNDS =>
               val lo = readType()
               if nothingButMods(end) then

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -64,6 +64,8 @@ class PlainPrinter(_ctx: Context) extends Printer {
         case tp @ AppliedType(tycon, args) =>
           if (defn.isCompiletimeAppliedType(tycon.typeSymbol)) tp.tryCompiletimeConstantFold
           else tycon.dealias.appliedTo(args)
+        case tp @ AppliedTermRef(fn, args) =>
+          tp.derivedAppliedTermRef(homogenize(tp), args.mapConserve(homogenize))
         case _ =>
           tp
       }
@@ -288,6 +290,9 @@ class PlainPrinter(_ctx: Context) extends Printer {
     tp match {
       case tp: TermRef =>
         toTextPrefix(tp.prefix) ~ selectionString(tp)
+      case AppliedTermRef(fn, args) =>
+        // TODO(gsps): Print AppliedTermRef as in surface syntax (using curly braces)
+        (toTextRef(fn) ~ "(" ~ Text(args map argText, ", ") ~ ")").close
       case tp: ThisType =>
         nameString(tp.cls) + ".this"
       case SuperType(thistpe: SingletonType, _) =>

tasty/src/dotty/tools/tasty/TastyFormat.scala

@@ -126,6 +126,7 @@ Standard-Section: "ASTs" TopLevelStat*
                   THIS                  clsRef_Type                                -- cls.this
                   RECthis               recType_ASTRef                             -- The `this` in a recursive refined type `recType`.
                   SHAREDtype            path_ASTRef                                -- link to previously serialized path
+                  APPLIEDTERMREF Length fn_Type arg_Type*                          -- The stable result of `fn` applied to `arg`s
 
   Constant      = UNITconst                                                        -- ()
                   FALSEconst                                                       -- false
@@ -254,7 +255,7 @@ object TastyFormat {
 
   final val header: Array[Int] = Array(0x5C, 0xA1, 0xAB, 0x1F)
   val MajorVersion: Int = 20
-  val MinorVersion: Int = 0
+  val MinorVersion: Int = 1
 
   /** Tags used to serialize names, should update [[nameTagToString]] if a new constant is added */
   class NameTags {
@@ -453,6 +454,7 @@ object TastyFormat {
   final val ANNOTATION = 173
   final val TERMREFin = 174
   final val TYPEREFin = 175
+  final val APPLIEDTERMREF = 176
 
   final val METHODtype = 180
   final val ERASEDMETHODtype = 181
@@ -660,6 +662,7 @@ object TastyFormat {
     case SUPERtype => "SUPERtype"
     case TERMREFin => "TERMREFin"
     case TYPEREFin => "TYPEREFin"
+    case APPLIEDTERMREF => "APPLIEDTERMREF"
 
     case REFINEDtype => "REFINEDtype"
     case REFINEDtpt => "REFINEDtpt"