Only elide this in self type annotation

Author: liufengyun

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

@@ -673,7 +673,7 @@ trait Printers
                 indented {
                   val name1 = if (name == "_") "this" else name
                   this += " " += highlightValDef(name1, color) += ": "
-                  printTypeTree(tpt)
+                  printTypeTree(tpt, Some(cdef.symbol))
                   this += " =>"
                 }
               }
@@ -1037,7 +1037,7 @@ trait Printers
         printList(trees, sep, printTree)
 
       def printTypeTrees(trees: List[TypeTree], sep: String): Buffer =
-        printList(trees, sep, printTypeTree)
+        printList(trees, sep, (t: TypeTree) => printTypeTree(t))
 
       def printTypes(trees: List[Type], sep: String): Buffer = {
         def printSeparated(list: List[Type]): Unit = list match {
@@ -1118,12 +1118,12 @@ trait Printers
         this
       }
 
-      def printTypesOrBounds(types: List[TypeOrBounds], sep: String): Buffer = {
+      def printTypesOrBounds(types: List[TypeOrBounds], sep: String, selfIn: Option[Symbol] = None): Buffer = {
         def printSeparated(list: List[TypeOrBounds]): Unit = list match {
           case Nil =>
-          case x :: Nil => printTypeOrBound(x)
+          case x :: Nil => printTypeOrBound(x, selfIn)
           case x :: xs =>
-            printTypeOrBound(x)
+            printTypeOrBound(x, selfIn)
             this += sep
             printSeparated(xs)
         }
@@ -1341,19 +1341,26 @@ trait Printers
           this += highlightLiteral("'" + v.name, color)
       }
 
-      def printTypeOrBoundsTree(tpt: TypeOrBoundsTree): Buffer = tpt match {
+      def printTypeOrBoundsTree(tpt: TypeOrBoundsTree, selfIn: Option[Symbol] = None): Buffer = tpt match {
         case TypeBoundsTree(lo, hi) =>
           this += "_ >: "
-          printTypeTree(lo)
+          printTypeTree(lo, selfIn)
           this += " <: "
-          printTypeTree(hi)
+          printTypeTree(hi, selfIn)
         case tpt @ WildcardTypeTree() =>
-          printTypeOrBound(tpt.tpe)
+          printTypeOrBound(tpt.tpe, selfIn)
         case IsTypeTree(tpt) =>
-          printTypeTree(tpt)
+          printTypeTree(tpt, selfIn)
       }
 
-      def printTypeTree(tree: TypeTree): Buffer = tree match {
+      /** Print type tree
+       *
+       *  @param selfIn The current type is a self type in the indicated class.
+       *                NoSymbol means the current type is not a self type annotation.
+       *                Self type annotation should elide current class prefix to avoid
+       *                cyclic type checking error.
+       */
+      def printTypeTree(tree: TypeTree, selfIn: Option[Symbol] = None): Buffer = tree match {
         case TypeTree.Inferred() =>
           // TODO try to move this logic into `printType`
           def printTypeAndAnnots(tpe: Type): Buffer = tpe match {
@@ -1363,25 +1370,25 @@ trait Printers
               printAnnotation(annot)
             case Type.SymRef(IsClassSymbol(sym), _) if sym.fullName == "scala.runtime.Null$" || sym.fullName == "scala.runtime.Nothing$" =>
               // scala.runtime.Null$ and scala.runtime.Nothing$ are not modules, those are their actual names
-              printType(tpe)
+              printType(tpe, selfIn)
             case tpe @ Type.SymRef(IsClassSymbol(sym), _) if sym.name.endsWith("$") =>
-              printType(tpe)
+              printType(tpe, selfIn)
               this += ".type"
             case tpe @ Type.SymRef(sym, _) if sym.isTerm =>
-              printType(tpe)
+              printType(tpe, selfIn)
               this += ".type"
-            case tpe => printType(tpe)
+            case tpe => printType(tpe, selfIn)
           }
           printTypeAndAnnots(tree.tpe)
 
         case TypeTree.Ident(name) =>
-          printType(tree.tpe)
+          printType(tree.tpe, selfIn)
 
         case TypeTree.Select(qual, name) =>
           printTree(qual) += "." += highlightTypeDef(name, color)
 
         case TypeTree.Projection(qual, name) =>
-          printTypeTree(qual) += "#" += highlightTypeDef(name, color)
+          printTypeTree(qual, selfIn) += "#" += highlightTypeDef(name, color)
 
         case TypeTree.Singleton(ref) =>
           printTree(ref)
@@ -1391,35 +1398,35 @@ trait Printers
           }
 
         case TypeTree.Refined(tpt, refinements) =>
-          printTypeTree(tpt)
+          printTypeTree(tpt, selfIn)
           inBlock(printTrees(refinements, "; "))
 
         case TypeTree.Applied(tpt, args) =>
-          printTypeTree(tpt)
+          printTypeTree(tpt, selfIn)
           inSquare(printTypeOrBoundsTrees(args, ", "))
 
         case TypeTree.Annotated(tpt, annot) =>
           val Annotation(ref, args) = annot
           ref.tpe match {
             case Types.RepeatedAnnotation() =>
               val Types.Sequence(tp) = tpt.tpe
-              printType(tp)
+              printType(tp, selfIn)
               this += highlightTypeDef("*", color)
             case _ =>
-              printTypeTree(tpt)
+              printTypeTree(tpt, selfIn)
               this += " "
               printAnnotation(annot)
           }
 
         case TypeTree.And(left, right) =>
-          printTypeTree(left)
+          printTypeTree(left, selfIn)
           this += highlightTypeDef(" & ", color)
-          printTypeTree(right)
+          printTypeTree(right, selfIn)
 
         case TypeTree.Or(left, right) =>
-          printTypeTree(left)
+          printTypeTree(left, selfIn)
           this += highlightTypeDef(" | ", color)
-          printTypeTree(right)
+          printTypeTree(right, selfIn)
 
         case TypeTree.MatchType(bound, selector, cases) =>
           printTypeTree(selector)
@@ -1428,48 +1435,56 @@ trait Printers
 
         case TypeTree.ByName(result) =>
           this += highlightTypeDef("=> ", color)
-          printTypeTree(result)
+          printTypeTree(result, selfIn)
 
         case TypeTree.LambdaTypeTree(tparams, body) =>
           printTargsDefs(tparams.zip(tparams), isDef = false)
           this += highlightTypeDef(" => ", color)
-          printTypeOrBoundsTree(body)
+          printTypeOrBoundsTree(body, selfIn)
 
         case TypeTree.TypeBind(name, _) =>
           this += highlightTypeDef(name, color)
 
         case TypeTree.TypeBlock(aliases, tpt) =>
           inBlock {
             printTrees(aliases, lineBreak())
-            printTypeTree(tpt)
+            printTypeTree(tpt, selfIn)
           }
 
         case _ =>
           throw new MatchError(tree.show)
 
       }
 
-      def printTypeOrBound(tpe: TypeOrBounds): Buffer = tpe match {
+      def printTypeOrBound(tpe: TypeOrBounds, selfIn: Option[Symbol] = None): Buffer = tpe match {
         case tpe@TypeBounds(lo, hi) =>
           this += "_ >: "
-          printType(lo)
+          printType(lo, selfIn)
           this += " <: "
-          printType(hi)
-        case IsType(tpe) => printType(tpe)
+          printType(hi, selfIn)
+        case IsType(tpe) => printType(tpe, selfIn)
       }
 
-      def printType(tpe: Type): Buffer = tpe match {
+      /** Print type
+       *
+       *  @param selfIn The current type is a self type in the indicated class.
+       *                Self type annotation should elide current class prefix to avoid
+       *                cyclic type checking error.
+       */
+      def printType(tpe: Type, selfIn: Option[Symbol] = None): Buffer = tpe match {
         case Type.ConstantType(const) =>
           printConstant(const)
 
         case Type.SymRef(sym, prefix) if sym.isType =>
           prefix match {
             case Types.EmptyPrefix() =>
             case IsType(prefix @ Type.SymRef(IsClassSymbol(_), _)) =>
-              printType(prefix)
+              printType(prefix, selfIn)
               this += "#"
+            case IsType(Type.ThisType(Type.SymRef(cdef, _)))
+            if selfIn.nonEmpty && cdef == selfIn.get =>
             case IsType(prefix) =>
-              printType(prefix)
+              printType(prefix, selfIn)
               this += "."
           }
           this += highlightTypeDef(sym.name.stripSuffix("$"), color)
@@ -1479,7 +1494,7 @@ trait Printers
             case Types.EmptyPrefix() =>
                 this += highlightTypeDef(sym.name, color)
             case _ =>
-              printTypeOrBound(prefix)
+              printTypeOrBound(prefix, selfIn)
               if (sym.name != "package")
                 this += "." += highlightTypeDef(sym.name, color)
               this
@@ -1490,7 +1505,7 @@ trait Printers
             case Type.ThisType(Types.EmptyPackage()) =>
               this += highlightTypeDef(name, color)
             case IsType(prefix) =>
-              printType(prefix)
+              printType(prefix, selfIn)
               if (name != "package")
                 this += "." += highlightTypeDef(name, color)
               this
@@ -1501,7 +1516,7 @@ trait Printers
         case Type.TypeRef(name, prefix) =>
           prefix match {
             case NoPrefix() | Type.ThisType(Types.EmptyPackage()) =>
-            case IsType(prefix) => printType(prefix) += "."
+            case IsType(prefix) => printType(prefix, selfIn) += "."
           }
           if (name.endsWith("$")) this += highlightTypeDef(name.stripSuffix("$"), color) += ".type"
           else this += highlightTypeDef(name, color)
@@ -1514,25 +1529,25 @@ trait Printers
             case Type.TypeRef("<repeated>", Types.ScalaPackage()) =>
               this += "_*"
             case _ =>
-              printType(tp)
+              printType(tp, selfIn)
               inSquare(printTypesOrBounds(args, ", "))
           }
 
         case Type.AnnotatedType(tp, annot) =>
           val Annotation(ref, args) = annot
-          printType(tp)
+          printType(tp, selfIn)
           this += " "
           printAnnotation(annot)
 
         case Type.AndType(left, right) =>
-          printType(left)
+          printType(left, selfIn)
           this += highlightTypeDef(" & ", color)
-          printType(right)
+          printType(right, selfIn)
 
         case Type.OrType(left, right) =>
-          printType(left)
+          printType(left, selfIn)
           this += highlightTypeDef(" | ", color)
-          printType(right)
+          printType(right, selfIn)
 
         case Type.MatchType(bound, scrutinee, cases) =>
           printType(scrutinee)
@@ -1561,13 +1576,13 @@ trait Printers
           }
 
         case Type.SuperType(thistpe, supertpe) =>
-          printType(supertpe)
+          printType(supertpe, selfIn)
           this += highlightTypeDef(".super", color)
 
         case Type.TypeLambda(paramNames, tparams, body) =>
           inSquare(printMethodicTypeParams(paramNames, tparams))
           this += highlightTypeDef(" => ", color)
-          printTypeOrBound(body)
+          printTypeOrBound(body, selfIn)
 
         case Type.ParamRef(lambda, idx) =>
           lambda match {
@@ -1577,7 +1592,7 @@ trait Printers
           }
 
         case Type.RecursiveType(tpe) =>
-          printType(tpe)
+          printType(tpe, selfIn)
 
         case Type.RecursiveThis(_) =>
           this += highlightTypeDef("this", color)