Merge pull request #4676 from dotty-staging/fix-decompiler-annots

nicolasstucki · web-flow · commit 09e65998d0bf · 2018-06-18T17:18:22.000+02:00
Print annotation in decompiler
diff --git a/compiler/test/dotty/tools/dotc/FromTastyTests.scala b/compiler/test/dotty/tools/dotc/FromTastyTests.scala
@@ -38,7 +38,6 @@ class FromTastyTests extends ParallelTesting {
         "t3612.scala",
       ),
       recompilationBlacklist = Set(
-        "simpleCaseObject",
         "annot-bootstrap.scala",
       )
     ).checkCompile()
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, isMember = true)
 
-      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)
@@ -272,7 +287,17 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
             this += "("
             printTree(term)
             this += ": "
-            printTypeTree(tpt)
+            def printTypeOrAnnots(tpe: Type): Unit = tpe match {
+              case Type.AnnotatedType(tp, annot) if tp == term.tpe =>
+                printAnnotation(annot)
+              case Type.AnnotatedType(tp, annot) =>
+                printTypeOrAnnots(tp)
+                this += " "
+                printAnnotation(annot)
+              case tpe =>
+                printType(tpe)
+            }
+            printTypeOrAnnots(tpt.tpe)
             this += ")"
         }
 
@@ -538,6 +563,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 += ": "
@@ -638,11 +676,23 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
 
     def printTypeTree(tree: TypeTree): Buffer = tree match {
       case TypeTree.Synthetic() =>
-        printType(tree.tpe)
-        tree.tpe match {
-          case tpe @ Type.TypeRef(name, _) if name.endsWith("$") => this += ".type"
-          case tpe => this
-        }
+        def printTypeAndAnnots(tpe: Type): Buffer = tpe match {
+          case Type.AnnotatedType(tp, annot) =>
+            printTypeAndAnnots(tp)
+            this += " "
+            printAnnotation(annot)
+          case tpe @ Type.TypeRef(name, _) if name.endsWith("$") =>
+            printType(tpe)
+            this += ".type"
+          case Type.SymRef(ClassDef("Null$" | "Nothing$", _, _, _, _), Type.ThisType(Type.SymRef(PackageDef("runtime", _), NoPrefix()))) =>
+            // scala.runtime.Null$ and scala.runtime.Nothing$ are not modules, those are their actual names
+            printType(tpe)
+          case tpe @ Type.SymRef(ClassDef(name, _, _, _, _), _) if name.endsWith("$") =>
+            printType(tpe)
+            this += ".type"
+          case tpe => printType(tpe)
+        }
+        printTypeAndAnnots(tree.tpe)
 
       case TypeTree.TypeIdent(name) =>
         printType(tree.tpe)
@@ -676,9 +726,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)
@@ -719,14 +771,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)
 
@@ -761,7 +812,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)
@@ -826,6 +880,28 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
       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 }
@@ -880,6 +956,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 {
 
@@ -917,6 +1000,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: @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.type @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 {

Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,6 @@ class FromTastyTests extends ParallelTesting {`
`38`	`38`	`"t3612.scala",`
`39`	`39`	`),`
`40`	`40`	`recompilationBlacklist = Set(`
`41`		`- "simpleCaseObject",`
`42`	`41`	`"annot-bootstrap.scala",`
`43`	`42`	`)`
`44`	`43`	`).checkCompile()`