block wrapping for trees modified

2 files changed, 50 insertions, 5 deletions

diff --git a/src/reflect/scala/reflect/internal/Trees.scala b/src/reflect/scala/reflect/internal/Trees.scala
index cefab8ffa2..78a40707e5 100644
--- a/src/reflect/scala/reflect/internal/Trees.scala
+++ b/src/reflect/scala/reflect/internal/Trees.scala
@@ -1685,11 +1685,13 @@ trait Trees extends api.Trees {
 
   // this is necessary to avoid crashes like https://github.com/scalamacros/paradise/issues/1
   // when someone tries to c.typecheck a naked MemberDef
-  def wrappingIntoTerm(tree: Tree)(op: Tree => Tree): Tree = {
-    op(build.SyntacticBlock(tree :: Nil)) match {
-      case Block(tree :: Nil, build.SyntheticUnit()) => tree
-      case Block(Nil, tree) => tree
-      case tree => tree
+  def wrappingIntoTerm(tree0: Tree)(op: Tree => Tree): Tree = {
+    val neededWrapping = !tree0.isTerm
+    val tree1 = build.SyntacticBlock(tree0 :: Nil)
+    op(tree1) match {
+      case Block(tree2 :: Nil, Literal(Constant(()))) if neededWrapping => tree2
+      case Block(Nil, tree2) => tree2
+      case tree2 => tree2
     }
   }
 
diff --git a/test/files/scalacheck/quasiquotes/TypecheckedProps.scala b/test/files/scalacheck/quasiquotes/TypecheckedProps.scala
index b4b909e9be..432c0959c9 100644
--- a/test/files/scalacheck/quasiquotes/TypecheckedProps.scala
+++ b/test/files/scalacheck/quasiquotes/TypecheckedProps.scala
@@ -109,4 +109,47 @@ object TypecheckedProps extends QuasiquoteProperties("typechecked") {
     assert(p2.name == pName2)
     assert(params2.size == 2)
   }
+
+  property("implicit class") = test {
+    val clName = TypeName("Test")
+    val paramName = TermName("x")
+    val q"{implicit class $name($param)}" = typecheck(q"implicit class $clName(val $paramName: String)")
+
+    assert(name == clName)
+    assert(param.name == paramName)
+  }
+
+  property("block with lazy") = test {
+    val lazyName = TermName("x")
+    val lazyRhsVal = 42
+    val lazyRhs = Literal(Constant(lazyRhsVal))
+    val q"{lazy val $pname = $rhs}" = typecheck(q"{lazy val $lazyName = $lazyRhsVal}")
+
+    assert(pname == lazyName)
+    assert(rhs ≈ lazyRhs)
+  }
+
+  property("class with lazy") = test {
+    val clName = TypeName("Test")
+    val paramName = TermName("x")
+    val q"class $name{lazy val $pname = $_}" = typecheck(q"class $clName {lazy val $paramName = 42}")
+
+    assert(name == clName)
+    assert(pname == paramName)
+  }
+
+  property("case class with object") = test {
+    val defName = TermName("z")
+    val defRhsVal = 42
+    val defRhs = Literal(Constant(defRhsVal))
+    val q"object $_{ $_; object $_ extends ..$_ {def $name = $rhs} }" =
+      typecheck(q"""
+        object Test{
+          case class C(x: Int) { def y = x };
+          object C { def $defName = $defRhsVal }
+        }""")
+
+    assert(name == defName)
+    assert(rhs ≈ defRhs)
+  }
 }