TypeTree printing modified (SI-8447)

2 files changed, 78 insertions, 40 deletions

diff --git a/src/reflect/scala/reflect/internal/Printers.scala b/src/reflect/scala/reflect/internal/Printers.scala
index fcc377ba32..2ce861898f 100644
--- a/src/reflect/scala/reflect/internal/Printers.scala
+++ b/src/reflect/scala/reflect/internal/Printers.scala
@@ -596,18 +596,26 @@ trait Printers extends api.Printers { self: SymbolTable =>
       }
     }
 
-    protected def emptyTree(tree: Tree) = tree match {
-      case EmptyTree | build.SyntacticEmptyTypeTree() => true
-      case _ => false
+    object EmptyTypeTree {
+      def unapply(tt: TypeTree): Boolean = tt match {
+        case build.SyntacticEmptyTypeTree() if tt.wasEmpty || tt.isEmpty => true
+        case _ => false
+      }
     }
 
+    protected def isEmptyTree(tree: Tree) =
+      tree match {
+        case EmptyTree | EmptyTypeTree() => true
+        case _ => false
+      }
+
     protected def originalTypeTrees(trees: List[Tree]) =
-      trees.filter(!emptyTree(_)) map {
-        case tt: TypeTree => tt.original
-  	    case tree => tree
+      trees.filter(!isEmptyTree(_)) map {
+        case tt: TypeTree if tt.original != null => tt.original
+        case tree => tree
       }
 
-    val defaultClasses = List(tpnme.AnyRef)
+    val defaultClasses = List(tpnme.AnyRef, tpnme.Object)
     val defaultTraitsForCase = List(tpnme.Product, tpnme.Serializable)
     protected def removeDefaultTypesFromList(trees: List[Tree])(classesToRemove: List[Name] = defaultClasses)(traitsToRemove: List[Name]) = {
       def removeDefaultTraitsFromList(trees: List[Tree], traitsToRemove: List[Name]): List[Tree] =
@@ -623,9 +631,10 @@ trait Printers extends api.Printers { self: SymbolTable =>
       removeDefaultTraitsFromList(removeDefaultClassesFromList(trees, classesToRemove), traitsToRemove)
     }
 
-    protected def removeDefaultClassesFromList(trees: List[Tree], classesToRemove: List[Name] = defaultClasses) = 
+    protected def removeDefaultClassesFromList(trees: List[Tree], classesToRemove: List[Name] = defaultClasses) =
       originalTypeTrees(trees) filter {
         case Select(Ident(sc), name) => !(classesToRemove.contains(name) && sc == nme.scala_)
+        case tt: TypeTree if tt.tpe != null => !(classesToRemove contains(newTypeName(tt.tpe.toString())))
         case _ => true
       }
 
@@ -637,7 +646,7 @@ trait Printers extends api.Printers { self: SymbolTable =>
       }
 
     override def printOpt(prefix: String, tree: Tree) = 
-      if (!emptyTree(tree)) super.printOpt(prefix, tree)
+      if (!isEmptyTree(tree)) super.printOpt(prefix, tree)
 
     override def printColumn(ts: List[Tree], start: String, sep: String, end: String) = {
       super.printColumn(ts.filter(!syntheticToRemove(_)), start, sep, end)
@@ -952,7 +961,7 @@ trait Printers extends api.Printers { self: SymbolTable =>
           def printTp = print("(", tp, ")")
 
           tp match {
-            case EmptyTree | build.SyntacticEmptyTypeTree() => printTp
+            case EmptyTree | EmptyTypeTree() => printTp
             // case for untypechecked trees
             case Annotated(annot, arg) if (expr ne null) && (arg ne null) && expr.equalsStructure(arg) => printTp // remove double arg - 5: 5: @unchecked
             case tt: TypeTree if tt.original.isInstanceOf[Annotated] => printTp
@@ -963,7 +972,7 @@ trait Printers extends api.Printers { self: SymbolTable =>
 
         // print only fun when targs are TypeTrees with empty original
         case TypeApply(fun, targs) =>
-          if (targs.exists(emptyTree(_))) {
+          if (targs.exists(isEmptyTree(_))) {
             print(fun)
           } else super.printTree(tree)
 
@@ -984,8 +993,8 @@ trait Printers extends api.Printers { self: SymbolTable =>
             case treeInfo.Unapplied(body) =>
               body match {
                 case Select(qual, name) if name == nme.unapply  => print(qual)
-                case TypeApply(Select(qual, name), args) if name == nme.unapply || name == nme.unapplySeq =>
-                  print(TypeApply(qual, args))
+                case TypeApply(Select(qual, name), _) if name == nme.unapply || name == nme.unapplySeq =>
+                  print(qual)
                 case _ => print(body)
               }
             case _ => print(fun)
@@ -1061,7 +1070,11 @@ trait Printers extends api.Printers { self: SymbolTable =>
           print("(", qualifier, ")#", blankForOperatorName(selector), printedName(selector))
 
         case tt: TypeTree =>
-          if (!emptyTree(tt)) print(tt.original)   
+          if (!isEmptyTree(tt)) {
+            val original = tt.original
+            if (original != null) print(original)
+            else super.printTree(tree)
+          }
 
         case AppliedTypeTree(tp, args) =>
           // it's possible to have (=> String) => String type but Function1[=> String, String] is not correct
diff --git a/test/junit/scala/reflect/internal/PrintersTest.scala b/test/junit/scala/reflect/internal/PrintersTest.scala
index 4587417a99..1458b942dc 100644
--- a/test/junit/scala/reflect/internal/PrintersTest.scala
+++ b/test/junit/scala/reflect/internal/PrintersTest.scala
@@ -33,10 +33,10 @@ object PrinterHelper {
     def wrapCode(source: String) = {
       val context = sm"""
       |trait PrintersContext {
-      |  class baz extends scala.annotation.StaticAnnotation;
-      |  class foo1[A, B] extends scala.annotation.StaticAnnotation;
-      |  class foo2[A, B](a: scala.Int)(b: scala.Int) extends scala.annotation.StaticAnnotation;
-      |  class foo3[Af, Bf](a: scala.Int)(b: scala.Float, c: PrintersContext.this.foo1[Af, Bf]) extends scala.annotation.StaticAnnotation;
+      |  class baz extends scala.annotation.Annotation with scala.annotation.StaticAnnotation;
+      |  class foo1[A, B] extends scala.annotation.Annotation with scala.annotation.StaticAnnotation;
+      |  class foo2[A, B](a: scala.Int)(b: scala.Int) extends scala.annotation.Annotation with scala.annotation.StaticAnnotation;
+      |  class foo3[Af, Bf](a: scala.Int)(b: scala.Float, c: PrintersContext.this.foo1[Af, Bf]) extends scala.annotation.Annotation with scala.annotation.StaticAnnotation;
       |  trait A1;
       |  trait B1;
       |${source.trim.lines map {"  " + _} mkString s"$LF"}
@@ -54,8 +54,12 @@ object PrinterHelper {
     }
   }
 
-  def assertTreeCode(tree: Tree)(code: String) = {
-    assertEquals("using quasiquote or given tree"+LF, code.trim, normalizeEOL(showCode(tree)))
+  def assertTreeCode(tree: Tree, typecheck: Boolean = false)(code: String) = {
+    if (typecheck) {
+      assertEquals("using quasiquote or given tree (typechecked)"+LF, code.trim, normalizeEOL(showCode(toolbox.typecheck(tree))))
+    } else {
+      assertEquals("using quasiquote or given tree"+LF, code.trim, normalizeEOL(showCode(tree)))
+    }
   }
 
   def assertPrintedCode(source: String, checkTypedTree: Boolean = true, wrapCode: Boolean = false) = {
@@ -312,17 +316,17 @@ trait BasePrintTests {
   @Test def testFunc1 = assertResultCode(
     code = "List(1, 2, 3).map((i: Int) => i - 1)")(
     parsedCode = "List(1, 2, 3).map(((i: Int) => i.-(1)))",
-    typedCode = sm"scala.collection.immutable.List.apply(1, 2, 3).map(((i: scala.Int) => i.-(1)))(scala.collection.immutable.List.canBuildFrom)")
+    typedCode = sm"scala.collection.immutable.List.apply[Int](1, 2, 3).map[Int, List[Int]](((i: scala.Int) => i.-(1)))(scala.collection.immutable.List.canBuildFrom[Int])")
 
   @Test def testFunc2 = assertResultCode(
     code = "val sum: Seq[Int] => Int = _ reduceLeft (_+_)")(
     parsedCode = "val sum: _root_.scala.Function1[Seq[Int], Int] = ((x$1) => x$1.reduceLeft(((x$2, x$3) => x$2.+(x$3))))",
-    typedCode = "val sum: _root_.scala.Function1[scala.`package`.Seq[scala.Int], scala.Int] = ((x$1) => x$1.reduceLeft(((x$2, x$3) => x$2.+(x$3))))")
+    typedCode = "val sum: _root_.scala.Function1[scala.`package`.Seq[scala.Int], scala.Int] = ((x$1: Seq[Int]) => x$1.reduceLeft[Int](((x$2: Int, x$3: Int) => x$2.+(x$3))))")
 
   @Test def testFunc3 = assertResultCode(
     code = "List(1, 2, 3) map (_ - 1)")(
     parsedCode = "List(1, 2, 3).map(((x$1) => x$1.-(1))) ",
-    typedCode = "scala.collection.immutable.List.apply(1, 2, 3).map(((x$1) => x$1.-(1)))(scala.collection.immutable.List.canBuildFrom)")
+    typedCode = "scala.collection.immutable.List.apply[Int](1, 2, 3).map[Int, List[Int]](((x$1: Int) => x$1.-(1)))(scala.collection.immutable.List.canBuildFrom[Int])")
 
   @Test def testFunc4 = assertResultCode(
     code = "val x: String => Int = ((str: String) => 1)")(
@@ -401,7 +405,8 @@ trait ClassPrintTests {
 
   @Test def testClassWithImplicitParams = assertPrintedCode("class X(var i: scala.Int)(implicit val d: scala.Double, var f: scala.Float)")
 
-  @Test def testClassWithEarly = assertPrintedCode(sm"""
+  @Test def testClassWithEarly =
+    assertPrintedCode(sm"""
     |class X(var i: scala.Int) extends {
     |  val a = i;
     |  type B
@@ -419,15 +424,22 @@ trait ClassPrintTests {
     |  throw Throw2.this.e
     |}""")
 
-  /*
-    class Test {
-      val (a, b) = (1, 2)
-    }
-  */
-  @Test def testClassWithAssignmentWithTuple1 = assertPrintedCode(sm"""
+  @Test def testClassWithAssignmentWithTuple1 = assertResultCode(sm"""
     |class Test {
-    |  private[this] val x$$1 = (scala.Tuple2.apply(1, 2): @scala.unchecked) match {
-    |    case scala.Tuple2((a @ _), (b @ _)) => scala.Tuple2.apply(a, b)
+    |  val (a, b) = (1, 2)
+    |}""")(
+    parsedCode = sm"""
+    |class Test {
+    |  private[this] val x$$1 = (scala.Tuple2(1, 2): @scala.unchecked) match {
+    |    case scala.Tuple2((a @ _), (b @ _)) => scala.Tuple2(a, b)
+    |  };
+    |  val a = x$$1._1;
+    |  val b = x$$1._2
+    |}""",
+    typedCode = sm"""
+    |class Test {
+    |  private[this] val x$$1 = (scala.Tuple2.apply[Int, Int](1, 2): @scala.unchecked) match {
+    |    case scala.Tuple2((a @ _), (b @ _)) => scala.Tuple2.apply[Int, Int](a, b)
     |  };
     |  val a = Test.this.x$$1._1;
     |  val b = Test.this.x$$1._2
@@ -448,8 +460,8 @@ trait ClassPrintTests {
     |}""",
     typedCode = sm"""
     |class Test {
-    |  private[this] val x$$1 = (scala.Predef.ArrowAssoc(1).->(2): @scala.unchecked) match {
-    |    case scala.Tuple2((a @ _), (b @ _)) => scala.Tuple2.apply(a, b)
+    |  private[this] val x$$1 = (scala.Predef.ArrowAssoc[Int](1).->[Int](2): @scala.unchecked) match {
+    |    case scala.Tuple2((a @ _), (b @ _)) => scala.Tuple2.apply[Int, Int](a, b)
     |  };
     |  val a = Test.this.x$$1._1;
     |  val b = Test.this.x$$1._2
@@ -462,8 +474,8 @@ trait ClassPrintTests {
   */
   @Test def testClassWithPatternMatchInAssignment = assertPrintedCode(sm"""
     |class Test {
-    |  private[this] val x$$1 = (scala.collection.immutable.List.apply(1, 3, 5): @scala.unchecked) match {
-    |    case scala.collection.immutable.List((one @ _), (three @ _), (five @ _)) => scala.Tuple3.apply(one, three, five)
+    |  private[this] val x$$1 = (scala.collection.immutable.List.apply[scala.Int](1, 3, 5): @scala.unchecked) match {
+    |    case scala.collection.immutable.List((one @ _), (three @ _), (five @ _)) => scala.Tuple3.apply[scala.Int, scala.Int, scala.Int](one, three, five)
     |  };
     |  val one = Test.this.x$$1._1;
     |  val three = Test.this.x$$1._2;
@@ -626,7 +638,7 @@ trait ClassPrintTests {
 
   @Test def testObjectWithPatternMatch1 = assertPrintedCode(sm"""
     |object PM1 {
-    |  scala.collection.immutable.List.apply(1, 2) match {
+    |  scala.collection.immutable.List.apply[scala.Int](1, 2) match {
     |    case (i @ _) => i
     |  }
     |}""")
@@ -715,7 +727,7 @@ trait ClassPrintTests {
     |}""",
     typedCode = sm"""
     |object PM5 {
-    |  scala.collection.immutable.List.apply(1, 2) match {
+    |  scala.collection.immutable.List.apply[Int](1, 2) match {
     |    case scala.`package`.::((x @ _), (xs @ _)) => x
     |  }
     |}""")
@@ -756,7 +768,7 @@ trait ClassPrintTests {
   @Test def testObjectWithPatternMatch8 = assertPrintedCode(sm"""
     |{
     |  object Extractor {
-    |    def unapply(i: scala.Int) = scala.Some.apply(i)
+    |    def unapply(i: scala.Int) = scala.Some.apply[scala.Int](i)
     |  };
     |  object PM9 {
     |    42 match {
@@ -991,7 +1003,7 @@ trait ValAndDefPrintTests {
 
   @Test def testDefWithLazyVal2 = assertPrintedCode(sm"""
     |def a = {
-    |  lazy val test = {
+    |  lazy val test: Unit = {
     |    scala.Predef.println();
     |    scala.Predef.println()
     |  };
@@ -1161,4 +1173,17 @@ trait QuasiTreesPrintTests {
     |case class X(x: Int, s: String) {
     |  def y = "test"
     |}""")
+
+  @Test def testQuasiCaseClassWithTypes1 = assertTreeCode(q"""case class X(x: ${typeOf[Int]}, s: ${typeOf[String]}){ def y = "test" }""")(sm"""
+    |case class X(x: Int, s: String) {
+    |  def y = "test"
+    |}""")
+
+  @Test def testQuasiCaseClassWithTypes2 = assertTreeCode(q"""case class X(x: ${typeOf[Int]}, s: ${typeOf[String]}){ def y = "test" }""", typecheck = true)(sm"""
+    |{
+    |  case class X(x: Int, s: String) {
+    |    def y = "test"
+    |  };
+    |  ()
+    |}""")
 }
\ No newline at end of file