Print annotation in decompiler

nicolasstucki · nicolasstucki · commit 66fea8b4b164 · 2018-06-18T10:44:24.000+02:00
diff --git a/library/src/scala/tasty/util/ShowSourceCode.scala b/library/src/scala/tasty/util/ShowSourceCode.scala
@@ -65,6 +65,8 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
         printImportSelectors(selectors)
 
       case cdef @ ClassDef(name, DefDef(_, targs, argss, _, _), parents, self, stats) =>
+        printDefAnnotations(cdef)
+
         val flags = cdef.flags
         if (flags.isFinal && !flags.isObject) this += "final "
         if (flags.isCase) this += "case "
@@ -146,11 +148,14 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
         }
         this
 
-      case tdef@TypeDef(name, rhs) =>
+      case tdef @ TypeDef(name, rhs) =>
+        printDefAnnotations(tdef)
         this += "type "
         printTargDef(tdef)
 
-      case vdef@ValDef(name, tpt, rhs) =>
+      case vdef @ ValDef(name, tpt, rhs) =>
+        printDefAnnotations(vdef)
+
         val flags = vdef.flags
         if (flags.isOverride) this += "override "
 
@@ -201,7 +206,9 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
         printTree(cond)
         this += ")"
 
-      case ddef@DefDef(name, targs, argss, tpt, rhs) =>
+      case ddef @ DefDef(name, targs, argss, tpt, rhs) =>
+        printDefAnnotations(ddef)
+
         val flags = ddef.flags
         if (flags.isOverride) sb.append("override ")
 
@@ -220,8 +227,16 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
         }
         this
 
-      case tree@Term.Ident(name) =>
-        printType(tree.tpe)
+      case tree @ Term.Ident(name) =>
+        tree.tpe match {
+          case Type.SymRef(_, Types.EmptyPrefix()) | Type.TermRef(_, Types.EmptyPrefix()) => this += name
+          case Type.SymRef(_, prefix) =>
+            printTypeOrBound(prefix)
+            this += "." += name
+          case Type.TermRef(_, prefix) =>
+            printTypeOrBound(prefix)
+            this += "." += name
+        }
 
       case Term.Select(qual, name, sig) =>
         printTree(qual)
@@ -516,6 +531,19 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
       this += ")"
     }
 
+    def printAnnotations(trees: List[Term]): Buffer = {
+      def printSeparated(list: List[Term]): Unit = list match {
+        case Nil =>
+        case x :: Nil => printAnnotation(x)
+        case x :: xs =>
+          printAnnotation(x)
+          this += " "
+          printSeparated(xs)
+      }
+      printSeparated(trees)
+      this
+    }
+
     def printArgDef(arg: ValDef): Unit = {
       val ValDef(name, tpt, rhs) = arg
       this += name += ": "
@@ -654,9 +682,11 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
         printTypeTrees(args, ", ")
         this += "]"
 
-      case TypeTree.Annotated(tpt, annots) =>
+      case TypeTree.Annotated(tpt, annot) =>
+        val Annotation(ref, args) = annot
         printTypeTree(tpt)
-        // TODO print annots
+        this += " "
+        printAnnotation(annot)
 
       case TypeTree.And(left, right) =>
         printTypeTree(left)
@@ -692,14 +722,13 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
 
       case Type.SymRef(sym, prefix) =>
         prefix match {
-          case Type.ThisType(Types.EmptyPackage() | Types.RootPackage()) =>
+          case Types.EmptyPrefix() =>
           case prefix@Type.SymRef(ClassDef(_, _, _, _, _), _) =>
             printType(prefix)
             this += "#"
           case prefix@Type() =>
             printType(prefix)
             this += "."
-          case prefix@NoPrefix() =>
         }
         printDefinitionName(sym)
 
@@ -734,7 +763,10 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
         this += "]"
 
       case Type.AnnotatedType(tp, annot) =>
+        val Annotation(ref, args) = annot
         printType(tp)
+        this += " "
+        printAnnotation(annot)
 
       case Type.AndType(left, right) =>
         printType(left)
@@ -768,13 +800,35 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
     }
 
     def printDefinitionName(sym: Definition): Buffer = sym match {
-      case ValDef(name, _, _) => this += name
+      case ValDef(name, _, _) => this += name += ".type"
       case DefDef(name, _, _, _, _) => this += name
       case ClassDef(name, _, _, _, _) => this += name.stripSuffix("$")
       case TypeDef(name, _) => this += name
       case PackageDef(name, _) => this += name
     }
 
+    def printAnnotation(annot: Term): Buffer = {
+      val Annotation(ref, args) = annot
+      this += "@"
+      printTypeTree(ref)
+      this += "("
+      printTrees(args, ", ")
+      this += ")"
+    }
+
+    def printDefAnnotations(definition: Definition): Buffer = {
+      val annots = definition.annots.filter {
+        case Annotation(annot, _) =>
+          annot.tpe match {
+            case Type.TypeRef(_, Type.SymRef(PackageDef("internal", _), Type.ThisType(Type.SymRef(PackageDef("annotation", _), NoPrefix())))) => false
+            case _ => true
+          }
+      }
+      printAnnotations(annots)
+      if (annots.nonEmpty) this += " "
+      else this
+    }
+
     def +=(x: Boolean): this.type = { sb.append(x); this }
     def +=(x: Byte): this.type = { sb.append(x); this }
     def +=(x: Short): this.type = { sb.append(x); this }
@@ -829,6 +883,13 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
     }
   }
 
+  private object Annotation {
+    def unapply(arg: Tree)(implicit ctx: Context): Option[(TypeTree, List[Term])] = arg match {
+      case Term.Apply(Term.Select(Term.New(annot), "<init>", _), args) => Some((annot, args))
+      case _ => None
+    }
+  }
+
   // TODO Provide some of these in scala.tasty.Tasty.scala and implement them using checks on symbols for performance
   private object Types {
 
@@ -866,6 +927,13 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
         case _ => false
       }
     }
+
+    object EmptyPrefix {
+      def unapply(tpe: TypeOrBounds)(implicit ctx: Context): Boolean = tpe match {
+        case NoPrefix() | Type.ThisType(Types.EmptyPackage() | Types.RootPackage()) => true
+        case _ => false
+      }
+    }
   }
 
 
diff --git a/tests/pos/i2104b.decompiled b/tests/pos/i2104b.decompiled
@@ -13,13 +13,13 @@ case class Pair[A, B](_1: A, _2: B) {
     scala.runtime.Statics.finalizeHash(acc, 2)
   }
   override def equals(x$0: scala.Any): scala.Boolean = this.eq(x$0.asInstanceOf[java.lang.Object]).||(x$0 match {
-    case x$0: Pair[Pair.this.A, Pair.this.B] =>
+    case x$0: Pair[Pair.this.A, Pair.this.B] @scala.unchecked() =>
       this._1.==(x$0._1).&&(this._2.==(x$0._2))
     case _ =>
       false
   })
   override def toString(): java.lang.String = scala.runtime.ScalaRunTime._toString(this)
-  override def canEqual(that: scala.Any): scala.Boolean = that.isInstanceOf[Pair[Pair.this.A, Pair.this.B]]
+  override def canEqual(that: scala.Any): scala.Boolean = that.isInstanceOf[Pair[Pair.this.A, Pair.this.B] @scala.unchecked()]
   override def productArity: scala.Int = 2
   override def productPrefix: java.lang.String = "Pair"
   override def productElement(n: scala.Int): scala.Any = n match {
diff --git a/tests/pos/simpleAnnot.decompiled b/tests/pos/simpleAnnot.decompiled
@@ -0,0 +1,9 @@
+/** Decompiled from out/posTestFromTasty/pos/simpleAnnot/Foo.class */
+class Foo() {
+  @annot() type A = scala.Int
+  @annot() val a: scala.Int = scala.Predef.???
+  val b: scala.Int @annot() = scala.Predef.???
+  def c(x: scala.Int): scala.Int = (x: x.type @annot())
+}
+/** Decompiled from out/posTestFromTasty/pos/simpleAnnot/annot.class */
+class annot() extends scala.annotation.Annotation
diff --git a/tests/pos/simpleAnnot.scala b/tests/pos/simpleAnnot.scala
@@ -0,0 +1,9 @@
+
+class Foo {
+  @annot type A = Int
+  @annot val a: Int = ???
+  val b: Int @annot = ???
+  def c(x: Int) = (x : @annot)
+}
+
+class annot extends scala.annotation.Annotation
diff --git a/tests/pos/simpleCaseClass-1.decompiled b/tests/pos/simpleCaseClass-1.decompiled
@@ -2,13 +2,13 @@
 case class A() {
   override def hashCode(): scala.Int = 1914112431
   override def equals(x$0: scala.Any): scala.Boolean = this.eq(x$0.asInstanceOf[java.lang.Object]).||(x$0 match {
-    case x$0: A =>
+    case x$0: A @scala.unchecked() =>
       true
     case _ =>
       false
   })
   override def toString(): java.lang.String = scala.runtime.ScalaRunTime._toString(this)
-  override def canEqual(that: scala.Any): scala.Boolean = that.isInstanceOf[A]
+  override def canEqual(that: scala.Any): scala.Boolean = that.isInstanceOf[A @scala.unchecked()]
   override def productArity: scala.Int = 0
   override def productPrefix: java.lang.String = "A"
   override def productElement(n: scala.Int): scala.Any = n match {
diff --git a/tests/pos/simpleCaseClass-2.decompiled b/tests/pos/simpleCaseClass-2.decompiled
@@ -6,13 +6,13 @@ case class A(x: scala.Int) {
     scala.runtime.Statics.finalizeHash(acc, 1)
   }
   override def equals(x$0: scala.Any): scala.Boolean = this.eq(x$0.asInstanceOf[java.lang.Object]).||(x$0 match {
-    case x$0: A =>
+    case x$0: A @scala.unchecked() =>
       this.x.==(x$0.x)
     case _ =>
       false
   })
   override def toString(): java.lang.String = scala.runtime.ScalaRunTime._toString(this)
-  override def canEqual(that: scala.Any): scala.Boolean = that.isInstanceOf[A]
+  override def canEqual(that: scala.Any): scala.Boolean = that.isInstanceOf[A @scala.unchecked()]
   override def productArity: scala.Int = 1
   override def productPrefix: java.lang.String = "A"
   override def productElement(n: scala.Int): scala.Any = n match {
diff --git a/tests/pos/simpleCaseClass-3.decompiled b/tests/pos/simpleCaseClass-3.decompiled
@@ -6,13 +6,13 @@ case class A[T](x: T) {
     scala.runtime.Statics.finalizeHash(acc, 1)
   }
   override def equals(x$0: scala.Any): scala.Boolean = this.eq(x$0.asInstanceOf[java.lang.Object]).||(x$0 match {
-    case x$0: A[A.this.T] =>
+    case x$0: A[A.this.T] @scala.unchecked() =>
       this.x.==(x$0.x)
     case _ =>
       false
   })
   override def toString(): java.lang.String = scala.runtime.ScalaRunTime._toString(this)
-  override def canEqual(that: scala.Any): scala.Boolean = that.isInstanceOf[A[A.this.T]]
+  override def canEqual(that: scala.Any): scala.Boolean = that.isInstanceOf[A[A.this.T] @scala.unchecked()]
   override def productArity: scala.Int = 1
   override def productPrefix: java.lang.String = "A"
   override def productElement(n: scala.Int): scala.Any = n match {
diff --git a/tests/pos/simpleCaseObject.decompiled b/tests/pos/simpleCaseObject.decompiled
@@ -3,7 +3,7 @@ package foo {
   case object Foo {
     override def hashCode(): scala.Int = 1045991777
     override def toString(): java.lang.String = "Foo"
-    override def canEqual(that: scala.Any): scala.Boolean = that.isInstanceOf[foo.Foo]
+    override def canEqual(that: scala.Any): scala.Boolean = that.isInstanceOf[foo.Foo @scala.unchecked()]
     override def productArity: scala.Int = 0
     override def productPrefix: java.lang.String = "Foo"
     override def productElement(n: scala.Int): scala.Any = n match {
