SI-7304 improve deprecation warnings for tree factory methods

4 files changed, 68 insertions, 13 deletions

diff --git a/src/compiler/scala/tools/reflect/quasiquotes/Reifiers.scala b/src/compiler/scala/tools/reflect/quasiquotes/Reifiers.scala
index af4e34536c..c2d8bcdcd6 100644
--- a/src/compiler/scala/tools/reflect/quasiquotes/Reifiers.scala
+++ b/src/compiler/scala/tools/reflect/quasiquotes/Reifiers.scala
@@ -228,6 +228,8 @@ trait Reifiers { self: Quasiquotes =>
     override def reifyTreeSyntactically(tree: Tree): Tree = tree match {
       case RefTree(qual, SymbolPlaceholder(tree)) =>
         mirrorBuildCall(nme.RefTree, reify(qual), tree)
+      case This(SymbolPlaceholder(tree)) =>
+        mirrorCall(nme.This, tree)
       case _ =>
         super.reifyTreeSyntactically(tree)
     }
diff --git a/src/reflect/scala/reflect/api/Trees.scala b/src/reflect/scala/reflect/api/Trees.scala
index 443f34ccae..7a627bc875 100644
--- a/src/reflect/scala/reflect/api/Trees.scala
+++ b/src/reflect/scala/reflect/api/Trees.scala
@@ -2210,13 +2210,13 @@ trait Trees { self: Universe =>
    *  Flattens directly nested blocks.
    *  @group Factories
    */
-  @deprecated("Use the canonical Block constructor, explicitly specifying its expression if necessary. Flatten directly nested blocks manually if needed", "2.10.1")
+  @deprecated("Use q\"{..$stats}\" instead. Flatten directly nested blocks manually if needed", "2.10.1")
   def Block(stats: Tree*): Block
 
   /** A factory method for `CaseDef` nodes.
    *  @group Factories
    */
-  @deprecated("Use the canonical CaseDef constructor passing EmptyTree for guard", "2.10.1")
+  @deprecated("Use cq\"$pat => $body\" instead", "2.10.1")
   def CaseDef(pat: Tree, body: Tree): CaseDef
 
   /** A factory method for `Bind` nodes.
@@ -2228,50 +2228,50 @@ trait Trees { self: Universe =>
   /** A factory method for `Try` nodes.
    *  @group Factories
    */
-  @deprecated("Use canonical CaseDef constructors to to create exception catching expressions and then wrap them in Try", "2.10.1")
+  @deprecated("Convert cases into casedefs and use q\"try $body catch { case ..$newcases }\" instead", "2.10.1")
   def Try(body: Tree, cases: (Tree, Tree)*): Try
 
   /** A factory method for `Throw` nodes.
    *  @group Factories
    */
-  @deprecated("Use the canonical New constructor to create an object instantiation expression and then wrap it in Throw", "2.10.1")
+  @deprecated("Use q\"throw new $tpe(..$args)\" instead", "2.10.1")
   def Throw(tpe: Type, args: Tree*): Throw
 
   /** Factory method for object creation `new tpt(args_1)...(args_n)`
    *  A `New(t, as)` is expanded to: `(new t).<init>(as)`
    *  @group Factories
    */
-  @deprecated("Use Apply(...Apply(Select(New(tpt), nme.CONSTRUCTOR), args1)...argsN) instead", "2.10.1")
+  @deprecated("Use q\"new $tpt(...$argss)\" instead", "2.10.1")
   def New(tpt: Tree, argss: List[List[Tree]]): Tree
 
   /** 0-1 argument list new, based on a type.
    *  @group Factories
    */
-  @deprecated("Use New(TypeTree(tpe), args.toList) instead", "2.10.1")
+  @deprecated("Use q\"new $tpe(..$args)\" instead", "2.10.1")
   def New(tpe: Type, args: Tree*): Tree
 
   /** 0-1 argument list new, based on a symbol.
    *  @group Factories
    */
-  @deprecated("Use New(sym.toType, args) instead", "2.10.1")
+  @deprecated("Use q\"new ${sym.toType}(..$args)\" instead", "2.10.1")
   def New(sym: Symbol, args: Tree*): Tree
 
   /** A factory method for `Apply` nodes.
    *  @group Factories
    */
-  @deprecated("Use Apply(Ident(sym), args.toList) instead", "2.10.1")
+  @deprecated("Use q\"$sym(..$args)\" instead", "2.10.1")
   def Apply(sym: Symbol, args: Tree*): Tree
 
   /** 0-1 argument list new, based on a type tree.
    *  @group Factories
    */
-  @deprecated("Use Apply(Select(New(tpt), nme.CONSTRUCTOR), args) instead", "2.10.1")
+  @deprecated("Use q\"new $tpt(..$args)\" instead", "2.10.1")
   def ApplyConstructor(tpt: Tree, args: List[Tree]): Tree
 
   /** A factory method for `Super` nodes.
    *  @group Factories
    */
-  @deprecated("Use Super(This(sym), mix) instead", "2.10.1")
+  @deprecated("Use q\"$sym.super[$mix].x\".qualifier instead", "2.10.1")
   def Super(sym: Symbol, mix: TypeName): Tree
 
   /** A factory method for `This` nodes.
@@ -2283,7 +2283,7 @@ trait Trees { self: Universe =>
    *  The string `name` argument is assumed to represent a [[scala.reflect.api.Names#TermName `TermName`]].
    *  @group Factories
    */
-  @deprecated("Use Select(tree, newTermName(name)) instead", "2.10.1")
+  @deprecated("Use Select(tree, TermName(name)) instead", "2.10.1")
   def Select(qualifier: Tree, name: String): Select
 
   /** A factory method for `Select` nodes.
@@ -2294,7 +2294,7 @@ trait Trees { self: Universe =>
   /** A factory method for `Ident` nodes.
    *  @group Factories
    */
-  @deprecated("Use Ident(newTermName(name)) instead", "2.10.1")
+  @deprecated("Use Ident(TermName(name)) instead", "2.10.1")
   def Ident(name: String): Ident
 
   /** A factory method for `Ident` nodes.
diff --git a/test/files/scalacheck/quasiquotes/DeprecationProps.scala b/test/files/scalacheck/quasiquotes/DeprecationProps.scala
new file mode 100644
index 0000000000..8e1601cf9d
--- /dev/null
+++ b/test/files/scalacheck/quasiquotes/DeprecationProps.scala
@@ -0,0 +1,52 @@
+import org.scalacheck._, Prop._, Gen._, Arbitrary._
+import scala.reflect.runtime.universe._
+
+object DeprecationProps extends QuasiquoteProperties("deprecation") {
+  val tname = TypeName("Foo")
+  val tpt = tq"Foo"
+  val tpe = typeOf[Int]
+  val sym = tpe.typeSymbol.asType
+  val argss = List(q"x") :: List(q"y") :: Nil
+  val args = q"x" :: q"y" :: Nil
+
+  property("new tpt argss") = test {
+    assert(q"new $tpt(...$argss)" ≈ New(tpt, argss))
+  }
+
+  property("new tpe args") = test {
+    assert(q"new $tpe(..$args)" ≈ New(tpe, args: _*))
+  }
+
+  property("new tpe args") = test {
+    assert(q"new ${sym.toType}(..$args)" ≈ New(sym, args: _*))
+  }
+
+  property("apply sym args") = test {
+    assert(q"$sym(..$args)" ≈ Apply(sym, args: _*))
+  }
+
+  property("applyconstructor") = test {
+    assert(q"new $tpt(..$args)" ≈ ApplyConstructor(tpt, args))
+  }
+
+  property("super sym name") = test {
+    assert(q"$sym.super[$tname].x".qualifier ≈ Super(sym, tname))
+  }
+
+  property("throw tpe args") = test {
+    assert(q"throw new $tpe(..$args)" ≈ Throw(tpe, args: _*))
+  }
+
+  property("casedef pat body") = test {
+    val pat = pq"foo"
+    val body = q"bar"
+    assert(cq"$pat => $body" ≈ CaseDef(pat, body))
+  }
+
+  property("try body cases") = test {
+    val cases = (pq"a", q"b") :: (pq"c", q"d") :: Nil
+    val newcases = cases.map { case (pat, body) => cq"$pat => $body" }
+    val body = q"foo"
+    assert(q"try $body catch { case ..$newcases }" ≈ Try(body, cases: _*))
+  }
+}
\ No newline at end of file
diff --git a/test/files/scalacheck/quasiquotes/Test.scala b/test/files/scalacheck/quasiquotes/Test.scala
index 05097711ef..f41d961888 100644
--- a/test/files/scalacheck/quasiquotes/Test.scala
+++ b/test/files/scalacheck/quasiquotes/Test.scala
@@ -11,4 +11,5 @@ object Test extends Properties("quasiquotes") {
   include(ErrorProps)
   include(DefinitionConstructionProps)
   include(DefinitionDeconstructionProps)
-}
\ No newline at end of file
+  include(DeprecationProps)
+}