Addressed some reviewer comments.

Author: gsps

compiler/src/dotty/tools/dotc/core/TypeComparer.scala

@@ -567,8 +567,8 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
             // Need to be more permissive when checking later phases, applications may have been rewritten
             isSubType(tp1, tp2.resType)
           case tp1: AppliedTermRef =>
-            tp1.args.size == tp2.args.size && isSubType(tp1.fn, tp2.fn) &&
-              (tp1.args zip tp2.args).forall(t => isSubType(t._1, t._2))
+            sameLength(tp1.args, tp2.args) && isSubType(tp1.fn, tp2.fn) &&
+              (tp1.args, tp2.args).zipped.forall(isSubType)
           case _ => fourthTry
         }
         compareAppliedTerm

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -2177,7 +2177,7 @@ object Types {
   abstract case class AppliedTermRef(fn: /*TermRef | AppliedTermRef*/ SingletonType, args: List[Type])
     extends CachedProxyType with SingletonType
   {
-    protected[this] var myResType: Type = _
+    private[this] var myResType: Type = _
     def resType(implicit ctx: Context): Type = {
       if (myResType == null)
         fn.widen match {
@@ -2188,7 +2188,7 @@ object Types {
 
     def underlying(implicit ctx: Context): Type = resType
 
-    def derivedAppliedTerm(fn: Type, args: List[Type])(implicit ctx: Context): Type =
+    def derivedAppliedTermRef(fn: Type, args: List[Type])(implicit ctx: Context): Type =
       if ((this.fn eq fn) && (this.args eq args)) this
       else AppliedTermRef(fn, args)
 
@@ -3961,8 +3961,8 @@ object Types {
       tp.derivedSuperType(thistp, supertp)
     protected def derivedAppliedType(tp: AppliedType, tycon: Type, args: List[Type]): Type =
       tp.derivedAppliedType(tycon, args)
-    protected def derivedAppliedTerm(tp: AppliedTermRef, fn: Type, args: List[Type]): Type =
-      tp.derivedAppliedTerm(fn, args)
+    protected def derivedAppliedTermRef(tp: AppliedTermRef, fn: Type, args: List[Type]): Type =
+      tp.derivedAppliedTermRef(fn, args)
     protected def derivedAndType(tp: AndType, tp1: Type, tp2: Type): Type =
       tp.derivedAndType(tp1, tp2)
     protected def derivedOrType(tp: OrType, tp1: Type, tp2: Type): Type =
@@ -4019,7 +4019,7 @@ object Types {
           derivedAppliedType(tp, this(tp.tycon), mapArgs(tp.args, tp.typeParams))
 
         case tp: AppliedTermRef =>
-          derivedAppliedTerm(tp, this(tp.fn), tp.args.mapConserve(this))
+          derivedAppliedTermRef(tp, this(tp.fn), tp.args.mapConserve(this))
 
         case tp: RefinedType =>
           derivedRefinedType(tp, this(tp.parent), this(tp.refinedInfo))
@@ -4317,10 +4317,10 @@ object Types {
           else tp.derivedAppliedType(tycon, args)
       }
 
-    override protected def derivedAppliedTerm(tp: AppliedTermRef, fn: Type, args: List[Type]): Type =
+    override protected def derivedAppliedTermRef(tp: AppliedTermRef, fn: Type, args: List[Type]): Type =
       fn match {
         case Range(fnLo, fnHi) =>
-          range(derivedAppliedTerm(tp, fnLo, args), derivedAppliedTerm(tp, fnHi, args))
+          range(derivedAppliedTermRef(tp, fnLo, args), derivedAppliedTermRef(tp, fnHi, args))
         case _ =>
           if (fn.isBottomType) {
             fn
@@ -4330,9 +4330,9 @@ object Types {
               case Range(lo, hi) => loBuf += lo; hiBuf += hi
               case arg => loBuf += arg; hiBuf += arg
             }
-            range(tp.derivedAppliedTerm(fn, loBuf.toList), tp.derivedAppliedTerm(fn, hiBuf.toList))
+            range(tp.derivedAppliedTermRef(fn, loBuf.toList), tp.derivedAppliedTermRef(fn, hiBuf.toList))
           } else {
-            tp.derivedAppliedTerm(fn, args)
+            tp.derivedAppliedTermRef(fn, args)
           }
       }
 

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

@@ -163,6 +163,7 @@ Standard-Section: "ASTs" TopLevelStat*
                   methodType(_, _) Length result_Type NamesTypes    // needed for refinements
                   TYPELAMBDAtype Length result_Type NamesTypes      // variance encoded in front of name: +/-/(nothing)
                   SHAREDtype            type_ASTRef
+                  APPLIEDTERMREF Length fn_Type arg_Type*
   NamesTypes    = NameType*
   NameType      = paramName_NameRef typeOrBounds_ASTRef
 
@@ -401,6 +402,7 @@ object TastyFormat {
   final val ANNOTATION = 172
   final val TERMREFin = 173
   final val TYPEREFin = 174
+  final val APPLIEDTERMREF = 175
 
   // In binary: 101100EI
   // I = implicit method type
@@ -416,7 +418,6 @@ object TastyFormat {
     METHODtype + implicitOffset + erasedOffset
   }
 
-  final val APPLIEDTERMREF = 180
   final val HOLE = 255
 
   final val firstNatTreeTag = SHAREDterm
@@ -430,7 +431,7 @@ object TastyFormat {
     firstNatTreeTag <= tag && tag <= SYMBOLconst ||
     firstASTTreeTag <= tag && tag <= SINGLETONtpt ||
     firstNatASTTreeTag <= tag && tag <= NAMEDARG ||
-    firstLengthTreeTag <= tag && tag <= TYPEREFin ||
+    firstLengthTreeTag <= tag && tag <= ERASEDIMPLICITMETHODtype ||
     tag == HOLE
 
   def isParamTag(tag: Int) = tag == PARAM || tag == TYPEPARAM
@@ -617,6 +618,7 @@ object TastyFormat {
     case ANNOTATION => "ANNOTATION"
     case PRIVATEqualified => "PRIVATEqualified"
     case PROTECTEDqualified => "PROTECTEDqualified"
+    case APPLIEDTERMREF => "APPLIEDTERMREF"
     case HOLE => "HOLE"
   }
 

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

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

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

@@ -855,6 +855,7 @@ object Parsers {
      *                     |  `(' ArgTypes `)'
      *                     |  `_' TypeBounds
      *                     |  Refinement
+     *                     |  `{` PostfixExpr `}`
      *                     |  Literal
      */
     def simpleType(): Tree = simpleTypeRest {

docs/docs/internals/syntax.md

@@ -137,6 +137,7 @@ SimpleType        ::=  SimpleType TypeArgs
                     |  ‘(’ ArgTypes ‘)’                                         Tuple(ts)
                     |  ‘_’ TypeBounds
                     |  Refinement                                               RefinedTypeTree(EmptyTree, refinement)
+                    |  ‘{’ PostfixExpr ‘}’                                      SingletonTypeTree(expr)
                     |  SimpleLiteral                                            SingletonTypeTree(l)
 ArgTypes          ::=  Type {‘,’ Type}
                     |  NamedTypeArg {‘,’ NamedTypeArg}

tests/pos/appliedTerm.scala

@@ -1,7 +1,11 @@
 object SimpleEqs {
   val x = 1
   val y: {x} = x
+
+  type YPlusOne = {y + 1}
+
   implicitly[{x + 1} =:= {y + 1}]
+  implicitly[{x + 1} =:= YPlusOne]
 }