refactor definition tests into separate subsuite

5 files changed, 326 insertions, 249 deletions

diff --git a/test/files/scalacheck/quasiquotes/DefinitionConstructionProps.scala b/test/files/scalacheck/quasiquotes/DefinitionConstructionProps.scala
new file mode 100644
index 0000000000..5d657b931b
--- /dev/null
+++ b/test/files/scalacheck/quasiquotes/DefinitionConstructionProps.scala
@@ -0,0 +1,218 @@
+import org.scalacheck._
+import Prop._
+import Gen._
+import Arbitrary._
+
+import scala.reflect.runtime.universe._
+import Flag._
+
+object DefinitionConstructionProps
+  extends QuasiquoteProperties("definition construction")
+  with ClassConstruction
+  with TraitConstruction
+  with TypeDefConstruction
+  with ValDefConstruction
+
+trait ClassConstruction { self: QuasiquoteProperties =>
+  val anyRef = Select(Ident(TermName("scala")), TypeName("AnyRef"))
+  val emtpyConstructor =
+    DefDef(Modifiers(), nme.CONSTRUCTOR, List(),
+      List(List()), TypeTree(), Block(List(pendingSuperCall), Literal(Constant(()))))
+  def classWith(name: TypeName, parents: List[Tree] = List(anyRef), body: List[DefDef] = Nil) =
+    ClassDef(
+      Modifiers(), name, List(),
+      Template(parents, emptyValDef, emtpyConstructor :: body))
+
+  property("splice term name into class") = forAll { (name: TypeName) =>
+    eqAst(q"class $name", "class " + name.toString)
+  }
+
+  property("splice method into class") = forAll { (name: TypeName, method: DefDef) =>
+    q"class $name { $method }" ≈ classWith(name, body = List(method))
+  }
+
+  property("splice members into class") = forAll { (name: TypeName, defs: List[DefDef], extra: DefDef) =>
+    q"""class $name {
+      ..$defs
+      $extra
+    }""" ≈ classWith(name, body = defs :+ extra)
+  }
+
+  property("splice type name into class parents") = forAll { (name: TypeName, parent: TypeName) =>
+    q"class $name extends $parent" ≈ classWith(name, parents = List(Ident(parent)))
+  }
+}
+
+trait TraitConstruction { self: QuasiquoteProperties =>
+
+}
+
+trait TypeDefConstruction { self: QuasiquoteProperties =>
+  property("splice type name into typedef") = forAll { (name1: TypeName, name2: TypeName) =>
+    q"type $name1 = $name2" ≈ TypeDef(Modifiers(), name1, List(), Ident(name2))
+  }
+
+  property("splice type names into type bounds") = forAll { (T1: TypeName, T2: TypeName, T3: TypeName) =>
+    q"type $T1 >: $T2 <: $T3" ≈
+      TypeDef(
+        Modifiers(DEFERRED), T1, List(),
+        TypeBoundsTree(Ident(T2), Ident(T3)))
+  }
+
+  property("splice trees names into type bounds") = forAll { (T: TypeName, t1: Tree, t2: Tree) =>
+    q"type $T >: $t1 <: $t2" ≈
+      TypeDef(
+        Modifiers(DEFERRED), T, List(),
+        TypeBoundsTree(t1, t2))
+  }
+
+  property("splice tparams into typedef (1)") = forAll { (T: TypeName, targs: List[TypeDef], t: Tree) =>
+    q"type $T[..$targs] = $t" ≈ TypeDef(Modifiers(), T, targs, t)
+  }
+
+  property("splice tparams into typedef (2)") = forAll { (T: TypeName, targs1: List[TypeDef], targs2: List[TypeDef], t: Tree) =>
+    q"type $T[..$targs1, ..$targs2] = $t" ≈ TypeDef(Modifiers(), T, targs1 ++ targs2, t)
+  }
+
+  property("splice tparams into typedef (3)") = forAll { (T: TypeName, targ: TypeDef, targs: List[TypeDef], t: Tree) =>
+    q"type $T[$targ, ..$targs] = $t" ≈ TypeDef(Modifiers(), T, targ :: targs, t)
+  }
+
+  property("splice typename into typedef with default bounds") = forAll { (T1: TypeName, T2: TypeName, t: Tree) =>
+    q"type $T1[$T2 >: Any <: Nothing] = $t" ≈
+      TypeDef(
+        Modifiers(), T1,
+        List(TypeDef(
+          Modifiers(PARAM), T2,
+          List(),
+          TypeBoundsTree(
+            Ident(TypeName("Any")),
+            Ident(TypeName("Nothing"))))),
+        t)
+  }
+
+  property("splice type names into compound type tree") = forAll { (T: TypeName, A: TypeName, B: TypeName) =>
+    q"type $T = $A with $B" ≈
+      TypeDef(
+        Modifiers(), T, List(),
+        CompoundTypeTree(
+          Template(List(Ident(A), Ident(B)), ValDef(Modifiers(PRIVATE), nme.WILDCARD, TypeTree(), EmptyTree), List())))
+  }
+
+  property("splice trees into existential type tree") = forAll {
+    (T1: TypeName, T2: TypeName, X: TypeName, Lo: TypeName, Hi: TypeName) =>
+
+    q"type $T1 = $T2[$X] forSome { type $X >: $Lo <: $Hi }" ≈
+      TypeDef(
+        Modifiers(), T1, List(),
+        ExistentialTypeTree(
+          AppliedTypeTree(Ident(T2), List(Ident(X))),
+          List(
+            TypeDef(Modifiers(DEFERRED), X, List(), TypeBoundsTree(Ident(Lo), Ident(Hi))))))
+  }
+
+  property("splice tree into singleton type tree") = forAll { (name: TypeName, t: Tree) =>
+    q"type $name = $t.type" ≈ q"type $name = ${SingletonTypeTree(t)}"
+  }
+
+  property("splice into applied type tree") = forAll { (T1: TypeName, T2: TypeName, args: List[Tree]) =>
+    q"type $T1 = $T2[..$args]" ≈
+      TypeDef(Modifiers(), T1, List(),
+        AppliedTypeTree(Ident(T2), args))
+  }
+}
+
+trait ValDefConstruction { self: QuasiquoteProperties =>
+  property("splice term name into val") = forAll { (name: TermName, tpt: Tree, rhs: Tree) =>
+    q"val $name: $tpt = $rhs" ≈ ValDef(Modifiers(), name, tpt, rhs)
+  }
+
+  property("splice term name into var") = forAll { (name: TermName, tpt: Tree, rhs: Tree) =>
+    q"var $name: $tpt = $rhs" ≈ ValDef(Modifiers(MUTABLE), name, tpt, rhs)
+  }
+}
+
+trait MethodConstruction { self: QuasiquoteProperties =>
+  property("splice paramss into defdef") = test {
+    val paramss = List(q"val x: Int") :: List(q"val y: Int = 1") :: Nil
+    assert(q"def foo(...$paramss)" ≈ parse("def foo(x: Int)(y: Int = 1)"))
+  }
+
+  property("splice tparams into defdef") = test {
+    val tparams = q"type A" :: q"type B <: Bippy" :: Nil
+    assert(q"def foo[..$tparams]" ≈ parse("def foo[A, B <: Bippy]"))
+  }
+
+  def assertSameAnnots(tree: {def mods: Modifiers}, annots: List[Tree]) =
+    assert(tree.mods.annotations ≈ annots,
+           s"${tree.mods.annotations} =/= ${annots}")
+
+  def assertSameAnnots(tree1: {def mods: Modifiers}, tree2: {def mods: Modifiers}) =
+    assert(tree1.mods.annotations ≈ tree2.mods.annotations,
+           s"${tree1.mods.annotations} =/= ${tree2.mods.annotations}")
+
+  property("splice type name into annotation") = test {
+    val name = TypeName("annot")
+    assertSameAnnots(q"@$name def foo", List(annot(name)))
+  }
+
+  property("splice ident into annotation") = test {
+    val name = TypeName("annot")
+    val ident = Ident(name)
+    assertSameAnnots(q"@$ident def foo", List(annot(name)))
+  }
+
+  property("splice idents into annotation") = test {
+    val idents = List(Ident(TypeName("annot1")), Ident(TypeName("annot2")))
+    assertSameAnnots(q"@..$idents def foo",
+      idents.map { ident => Apply(Select(New(ident), nme.CONSTRUCTOR), List()) })
+  }
+
+  property("splice constructor calls into annotation") = test {
+    val ctorcalls = List(annot("a1"), annot("a2"))
+    assertSameAnnots(q"@..$ctorcalls def foo", ctorcalls)
+  }
+
+  property("splice multiple annotations (1)") = test {
+    val annot1 = annot("a1")
+    val annot2 = annot("a2")
+    val res = q"@$annot1 @$annot2 def foo"
+    assertSameAnnots(res, List(annot1, annot2))
+  }
+
+  property("splice multiple annotations (2)") = test {
+    val annot1 = annot("a1")
+    val annots = List(annot("a2"), annot("a3"))
+    val res = q"@$annot1 @..$annots def foo"
+    assertSameAnnots(res, annot1 :: annots)
+  }
+
+  property("splice annotations with arguments (1)") = test {
+    val a = annot("a", List(q"x"))
+    assertSameAnnots(q"@$a def foo", q"@a(x) def foo")
+  }
+
+  property("splice annotations with arguments (2)") = test {
+    val a = newTypeName("a")
+    assertSameAnnots(q"@$a(x) def foo", q"@a(x) def foo")
+  }
+
+  property("splice annotations with arguments (3") = test {
+    val a = Ident(newTypeName("a"))
+    assertSameAnnots(q"@$a(x) def foo", q"@a(x) def foo")
+  }
+
+  property("splice improper tree into annot") = test {
+    val t = tq"Foo[Baz]"
+    assertThrows[IllegalArgumentException] {
+      q"@$t def foo"
+    }
+  }
+
+  property("can't splice annotations with arguments specificed twice") = test {
+    val a = annot("a", List(q"x"))
+    assertThrows[IllegalArgumentException] {
+      q"@$a(y) def foo"
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/files/scalacheck/quasiquotes/DefinitionDeconstructionProps.scala b/test/files/scalacheck/quasiquotes/DefinitionDeconstructionProps.scala
new file mode 100644
index 0000000000..31d230d6fd
--- /dev/null
+++ b/test/files/scalacheck/quasiquotes/DefinitionDeconstructionProps.scala
@@ -0,0 +1,97 @@
+import org.scalacheck._
+import Prop._
+import Gen._
+import Arbitrary._
+
+import scala.reflect.runtime.universe._
+import Flag._
+
+object DefinitionDeconstructionProps
+  extends QuasiquoteProperties("definition deconstruction")
+  with TraitDeconstruction
+  with ClassDeconstruction
+  with ObjectDeconstruction
+  with ModsDeconstruction
+  with ValVarDeconstruction
+
+trait TraitDeconstruction { self: QuasiquoteProperties =>
+
+}
+
+trait ObjectDeconstruction { self: QuasiquoteProperties =>
+
+}
+
+trait ClassDeconstruction { self: QuasiquoteProperties =>
+  property("class without params") = test {
+    val q"class $name { ..$body }" = q"class Foo { def bar = 3 }"
+    assert(body ≈ List(q"def bar = 3"))
+  }
+
+  property("class constructor") = test {
+    val q"class $name(...$argss)" = q"class Foo(x: Int)(y: Int)"
+    assert(argss.length == 2)
+  }
+
+  property("class parents") = test {
+    val q"class $name extends ..$parents" = q"class Foo extends Bar with Blah"
+    assert(parents ≈ List(tq"Bar", tq"Blah"))
+  }
+
+  property("class selfdef") = test {
+    val q"class $name { $self => }" = q"class Foo { self: T => }"
+    assert(self.name ≈ TermName("self") && self.tpt ≈ tq"T")
+  }
+
+  property("class tparams") = test {
+    val q"class $name[..$tparams]" = q"class Foo[A, B]"
+    assert(tparams.map { _.name } == List(TypeName("A"), TypeName("B")))
+  }
+
+  property("deconstruct bare case class") = test {
+    val q"$mods class $name(..$args) extends ..$parents" = q"case class Foo(x: Int)"
+  }
+}
+
+trait ModsDeconstruction { self: QuasiquoteProperties =>
+  property("deconstruct mods") = test {
+    val mods = Modifiers(IMPLICIT | PRIVATE, TermName("foobar"), Nil)
+    val q"$mods0 def foo" = q"$mods def foo"
+    assert(mods0 ≈ mods)
+  }
+
+  property("@$annot def foo") = forAll { (annotName: TypeName) =>
+    val q"@$annot def foo" = q"@$annotName def foo"
+    annot ≈ Apply(Select(New(Ident(annotName)), nme.CONSTRUCTOR), List())
+  }
+
+  property("@$annot(..$args) def foo") = forAll { (annotName: TypeName, tree: Tree) =>
+    val q"@$annot(..$args) def foo" = q"@$annotName($tree) def foo"
+    annot ≈ Ident(annotName) && args ≈ List(tree)
+  }
+
+  property("@..$annots def foo") = test {
+    val a = annot("a")
+    val b = annot("b")
+    val q"@..$annots def foo" = q"@$a @$b def foo"
+    annots ≈ List(a, b)
+  }
+
+  property("@$annot @..$annots def foo") = test {
+    val a = annot("a")
+    val b = annot("b")
+    val c = annot("c")
+    val q"@$first @..$rest def foo" = q"@$a @$b @$c def foo"
+    first ≈ a && rest ≈ List(b, c)
+  }
+}
+
+trait ValVarDeconstruction { self: QuasiquoteProperties =>
+  property("exhaustive val matcher") = test {
+    def matches(line: String) { val q"$mods val $name: $tpt = $rhs" = parse(line) }
+    matches("val x: Int")
+    matches("val x: Int = 1")
+    matches("lazy val x: Int = 1")
+    matches("implicit val x = 1")
+  }
+}
\ No newline at end of file
diff --git a/test/files/scalacheck/quasiquotes/TermConstructionProps.scala b/test/files/scalacheck/quasiquotes/TermConstructionProps.scala
index b14945f24b..5a765f7911 100644
--- a/test/files/scalacheck/quasiquotes/TermConstructionProps.scala
+++ b/test/files/scalacheck/quasiquotes/TermConstructionProps.scala
@@ -7,16 +7,6 @@ import scala.reflect.runtime.universe._
 import Flag._
 
 object TermConstructionProps extends QuasiquoteProperties("term construction") {
-  val anyRef = Select(Ident(TermName("scala")), TypeName("AnyRef"))
-  val emtpyConstructor =
-    DefDef(
-      Modifiers(), nme.CONSTRUCTOR, List(),
-      List(List()), TypeTree(), Block(List(Apply(Select(Super(This(tpnme.EMPTY), tpnme.EMPTY), nme.CONSTRUCTOR), List())), Literal(Constant(()))))
-
-  def classWithMethods(name: TypeName, methods: List[DefDef] = Nil) =
-    ClassDef(
-      Modifiers(),  name, List(),
-      Template(List(anyRef), emptyValDef, List(emtpyConstructor) ++ methods))
 
   property("splice single tree return tree itself") = forAll { (t: Tree) =>
     q"$t" ≈ t
@@ -26,22 +16,6 @@ object TermConstructionProps extends QuasiquoteProperties("term construction") {
     q"if($t1) $t2 else $t3" ≈ If(t1, t2, t3)
   }
 
-  property("splice term name into val") = forAll { (name: TermName) =>
-    q"val $name = 0" ≈ ValDef(Modifiers(), name, TypeTree(), Literal(Constant(0)))
-  }
-
-  property("splice type name into typedef") = forAll { (name1: TypeName, name2: TypeName) =>
-    q"type $name1 = $name2" ≈ TypeDef(Modifiers(), name1, List(), Ident(name2))
-  }
-
-  property("splice term name into class") = forAll { (name: TypeName) =>
-    q"class $name" ≈ classWithMethods(name)
-  }
-
-  property("splice method into class") = forAll { (name: TypeName, method: DefDef) =>
-    q"class $name { $method }" ≈ classWithMethods(name, List(method))
-  }
-
   property("splice trees into ascriptiopn") = forAll { (t1: Tree, t2: Tree) =>
     q"$t1 : $t2" ≈ Typed(t1, t2)
   }
@@ -69,19 +43,13 @@ object TermConstructionProps extends QuasiquoteProperties("term construction") {
   }
 
   property("splice trees into block") = forAll { (t1: Tree, t2: Tree, t3: Tree) =>
-    q"""{
+    blockInvariant(q"""{
       $t1
       $t2
       $t3
-    }""" ≈ Block(List(t1, t2), t3)
+    }""", List(t1, t2, t3))
   }
 
-  property("splice type name into class parents") = forAll { (name: TypeName, parent: TypeName) =>
-    q"class $name extends $parent" ≈
-      ClassDef(
-        Modifiers(),  name, List(),
-        Template(List(Ident(parent)), emptyValDef, List(emtpyConstructor)))
-  }
 
   property("splice tree into new") = forAll { (tree: Tree) =>
     q"new $tree" ≈ Apply(Select(New(tree), nme.CONSTRUCTOR), List())
@@ -101,13 +69,6 @@ object TermConstructionProps extends QuasiquoteProperties("term construction") {
     q"$fun($arg1, $arg2, ..$args)" ≈ Apply(fun, List(arg1) ++ List(arg2) ++ args)
   }
 
-  property("splice members into class") = forAll { (name: TypeName, defs: List[DefDef], extra: DefDef) =>
-    q"""class $name {
-      ..$defs
-      $extra
-    }""" ≈ classWithMethods(name, defs ++ List(extra))
-  }
-
   property("splice into new") = forAll { (name: TypeName, body: List[Tree]) =>
     q"new $name { ..$body }" ≈
       q"""{
@@ -118,11 +79,6 @@ object TermConstructionProps extends QuasiquoteProperties("term construction") {
       }"""
   }
 
-
-  property("splice tree into singleton type tree") = forAll { (name: TypeName, t: Tree) =>
-    q"type $name = $t.type" ≈ q"type $name = ${SingletonTypeTree(t)}"
-  }
-
   property("splice type name into this") = forAll { (T: TypeName) =>
     q"$T.this" ≈ This(T)
   }
@@ -135,65 +91,6 @@ object TermConstructionProps extends QuasiquoteProperties("term construction") {
     q"$fun[..$types]" ≈ TypeApply(fun, types)
   }
 
-  property("splice type names into type bounds") = forAll { (T1: TypeName, T2: TypeName, T3: TypeName) =>
-    q"type $T1 >: $T2 <: $T3" ≈
-      TypeDef(
-        Modifiers(DEFERRED), T1, List(),
-        TypeBoundsTree(Ident(T2), Ident(T3)))
-  }
-
-  property("splice trees names into type bounds") = forAll { (T: TypeName, t1: Tree, t2: Tree) =>
-    q"type $T >: $t1 <: $t2" ≈
-      TypeDef(
-        Modifiers(DEFERRED), T, List(),
-        TypeBoundsTree(t1, t2))
-  }
-
-  property("splice tparams into typedef (1)") = forAll { (T: TypeName, targs: List[TypeDef], t: Tree) =>
-    q"type $T[..$targs] = $t" ≈ TypeDef(Modifiers(), T, targs, t)
-  }
-
-  property("splice tparams into typedef (2)") = forAll { (T: TypeName, targs1: List[TypeDef], targs2: List[TypeDef], t: Tree) =>
-    q"type $T[..$targs1, ..$targs2] = $t" ≈ TypeDef(Modifiers(), T, targs1 ++ targs2, t)
-  }
-
-  property("splice tparams into typedef (3)") = forAll { (T: TypeName, targ: TypeDef, targs: List[TypeDef], t: Tree) =>
-    q"type $T[$targ, ..$targs] = $t" ≈ TypeDef(Modifiers(), T, targ :: targs, t)
-  }
-
-  property("splice typename into typedef with default bounds") = forAll { (T1: TypeName, T2: TypeName, t: Tree) =>
-    q"type $T1[$T2 >: Any <: Nothing] = $t" ≈
-      TypeDef(
-        Modifiers(), T1,
-        List(TypeDef(
-          Modifiers(PARAM), T2,
-          List(),
-          TypeBoundsTree(
-            Ident(TypeName("Any")),
-            Ident(TypeName("Nothing"))))),
-        t)
-  }
-
-  property("splice type names into compound type tree") = forAll { (T: TypeName, A: TypeName, B: TypeName) =>
-    q"type $T = $A with $B" ≈
-      TypeDef(
-        Modifiers(), T, List(),
-        CompoundTypeTree(
-          Template(List(Ident(A), Ident(B)), ValDef(Modifiers(PRIVATE), nme.WILDCARD, TypeTree(), EmptyTree), List())))
-  }
-
-  property("splice trees into existential type tree") = forAll {
-    (T1: TypeName, T2: TypeName, X: TypeName, Lo: TypeName, Hi: TypeName) =>
-
-    q"type $T1 = $T2[$X] forSome { type $X >: $Lo <: $Hi }" ≈
-      TypeDef(
-        Modifiers(), T1, List(),
-        ExistentialTypeTree(
-          AppliedTypeTree(Ident(T2), List(Ident(X))),
-          List(
-            TypeDef(Modifiers(DEFERRED), X, List(), TypeBoundsTree(Ident(Lo), Ident(Hi))))))
-  }
-
   property("splice names into import selector") = forAll {
     (expr: Tree, plain: Name, oldname: Name, newname: Name, discard: Name) =>
 
@@ -223,95 +120,22 @@ object TermConstructionProps extends QuasiquoteProperties("term construction") {
         CaseDef(Alternative(List(A, B)), EmptyTree, Literal(Constant(())))))
   }
 
-  property("splice into applied type tree") = forAll { (T1: TypeName, T2: TypeName, args: List[Tree]) =>
-    q"type $T1 = $T2[..$args]" ≈
-      TypeDef(
-        Modifiers(), T1, List(),
-        AppliedTypeTree(Ident(T2), args))
-  }
-
-  property("splice list of trees into block (1)") = forAll { (trees: List[Tree]) =>
-    q"{ ..$trees }" ≈ (trees match {
+  def blockInvariant(quote: Tree, trees: List[Tree]) =
+    quote ≈ (trees match {
       case Nil => Block(Nil, q"()")
       case _   => Block(trees.init, trees.last)
     })
+
+  property("splice list of trees into block (1)") = forAll { (trees: List[Tree]) =>
+    blockInvariant(q"{ ..$trees }", trees)
   }
 
   property("splice list of trees into block (2)") = forAll { (trees1: List[Tree], trees2: List[Tree]) =>
-    q"{ ..$trees1 ; ..$trees2 }" ≈ ((trees1 ++ trees2) match {
-      case Nil   => Block(Nil, Literal(Constant(())))
-      case trees => Block(trees.init, trees.last)
-    })
+    blockInvariant(q"{ ..$trees1 ; ..$trees2 }", trees1 ++ trees2)
   }
 
   property("splice list of trees into block (3)") = forAll { (trees: List[Tree], tree: Tree) =>
-    q"{ ..$trees; $tree }" ≈ Block(trees, tree)
-  }
-
-  def assertSameAnnots(tree: {def mods: Modifiers}, annots: List[Tree]) =
-    assert(tree.mods.annotations ≈ annots,
-           s"${tree.mods.annotations} =/= ${annots}")
-
-  def assertSameAnnots(tree1: {def mods: Modifiers}, tree2: {def mods: Modifiers}) =
-    assert(tree1.mods.annotations ≈ tree2.mods.annotations,
-           s"${tree1.mods.annotations} =/= ${tree2.mods.annotations}")
-
-  property("splice type name into annotation") = test {
-    val name = TypeName("annot")
-    assertSameAnnots(q"@$name def foo", List(annot(name)))
-  }
-
-  property("splice ident into annotation") = test {
-    val name = TypeName("annot")
-    val ident = Ident(name)
-    assertSameAnnots(q"@$ident def foo", List(annot(name)))
-  }
-
-  property("splice idents into annotation") = test {
-    val idents = List(Ident(TypeName("annot1")), Ident(TypeName("annot2")))
-    assertSameAnnots(q"@..$idents def foo",
-      idents.map { ident => Apply(Select(New(ident), nme.CONSTRUCTOR), List()) })
-  }
-
-  property("splice constructor calls into annotation") = test {
-    val ctorcalls = List(annot("a1"), annot("a2"))
-    assertSameAnnots(q"@..$ctorcalls def foo", ctorcalls)
-  }
-
-  property("splice multiple annotations (1)") = test {
-    val annot1 = annot("a1")
-    val annot2 = annot("a2")
-    val res = q"@$annot1 @$annot2 def foo"
-    assertSameAnnots(res, List(annot1, annot2))
-  }
-
-  property("splice multiple annotations (2)") = test {
-    val annot1 = annot("a1")
-    val annots = List(annot("a2"), annot("a3"))
-    val res = q"@$annot1 @..$annots def foo"
-    assertSameAnnots(res, annot1 :: annots)
-  }
-
-  property("splice annotations with arguments (1)") = test {
-    val a = annot("a", List(q"x"))
-    assertSameAnnots(q"@$a def foo", q"@a(x) def foo")
-  }
-
-  property("splice annotations with arguments (2)") = test {
-    val a = newTypeName("a")
-    assertSameAnnots(q"@$a(x) def foo", q"@a(x) def foo")
-  }
-
-  property("splice annotations with arguments (3") = test {
-    val a = Ident(newTypeName("a"))
-    assertSameAnnots(q"@$a(x) def foo", q"@a(x) def foo")
-  }
-
-  property("can't splice annotations with arguments specificed twice") = test {
-    val a = annot("a", List(q"x"))
-    assertThrows[IllegalArgumentException] {
-      q"@$a(y) def foo"
-    }
+    blockInvariant(q"{ ..$trees; $tree }", trees :+ tree)
   }
 
   property("splice term into brackets") = test {
@@ -331,11 +155,4 @@ object TermConstructionProps extends QuasiquoteProperties("term construction") {
     val empty = List[Tree]()
     assert(q"(..$empty)" ≈ q"()")
   }
-
-  property("splice improper tree into annot") = test {
-    val t = tq"Foo[Baz]"
-    assertThrows[IllegalArgumentException] {
-      q"@$t def foo"
-    }
-  }
 }
diff --git a/test/files/scalacheck/quasiquotes/TermDeconstructionProps.scala b/test/files/scalacheck/quasiquotes/TermDeconstructionProps.scala
index 114c9f112b..132baeb977 100644
--- a/test/files/scalacheck/quasiquotes/TermDeconstructionProps.scala
+++ b/test/files/scalacheck/quasiquotes/TermDeconstructionProps.scala
@@ -7,7 +7,6 @@ import scala.reflect.runtime.universe._
 import Flag._
 
 object TermDeconstructionProps extends QuasiquoteProperties("term deconstruction") {
-
   property("f(..x) = f") = test {
     assertThrows[MatchError] {
       val q"f(..$argss)" = q"f"
@@ -44,56 +43,6 @@ object TermDeconstructionProps extends QuasiquoteProperties("term deconstruction
     argss ≈ List()
   }
 
-  property("@$annot def foo") = forAll { (annotName: TypeName) =>
-    val q"@$annot def foo" = q"@$annotName def foo"
-    annot ≈ Apply(Select(New(Ident(annotName)), nme.CONSTRUCTOR), List())
-  }
-
-  property("@$annot(..$args) def foo") = forAll { (annotName: TypeName, tree: Tree) =>
-    val q"@$annot(..$args) def foo" = q"@$annotName($tree) def foo"
-    annot ≈ Ident(annotName) && args ≈ List(tree)
-  }
-
-  property("@..$annots def foo") = test {
-    val a = annot("a")
-    val b = annot("b")
-    val q"@..$annots def foo" = q"@$a @$b def foo"
-    annots ≈ List(a, b)
-  }
-
-  property("@$annot @..$annots def foo") = test {
-    val a = annot("a")
-    val b = annot("b")
-    val c = annot("c")
-    val q"@$first @..$rest def foo" = q"@$a @$b @$c def foo"
-    first ≈ a && rest ≈ List(b, c)
-  }
-
-  property("class without params") = test {
-    val q"class $name { ..$body }" = q"class Foo { def bar = 3 }"
-    assert(body ≈ List(q"def bar = 3"))
-  }
-
-  property("class constructor") = test {
-    val q"class $name(...$argss)" = q"class Foo(x: Int)(y: Int)"
-    assert(argss.length == 2)
-  }
-
-  property("class parents") = test {
-    val q"class $name extends ..$parents" = q"class Foo extends Bar with Blah"
-    assert(parents ≈ List(tq"Bar", tq"Blah"))
-  }
-
-  property("class selfdef") = test {
-    val q"class $name { $self => }" = q"class Foo { self: T => }"
-    assert(self.name ≈ TermName("self") && self.tpt ≈ tq"T")
-  }
-
-  property("class tparams") = test {
-    val q"class $name[..$tparams]" = q"class Foo[A, B]"
-    assert(tparams.map { _.name } == List(TypeName("A"), TypeName("B")))
-  }
-
   property("deconstruct unit as tuple") = test {
     val q"(..$xs)" = q"()"
     assert(xs.isEmpty)
@@ -113,10 +62,4 @@ object TermDeconstructionProps extends QuasiquoteProperties("term deconstruction
     val q"$x match { case ..$cases }" = q"x match { case 1 => case 2 => }"
     x ≈ q"x" && cases ≈ List(cq"1 =>", cq"2 =>")
   }
-
-  property("deconstruct mods") = test {
-    val mods = Modifiers(IMPLICIT | PRIVATE, TermName("foobar"), Nil)
-    val q"$mods0 def foo" = q"$mods def foo"
-    assert(mods0 ≈ mods)
-  }
 }
\ No newline at end of file
diff --git a/test/files/scalacheck/quasiquotes/Test.scala b/test/files/scalacheck/quasiquotes/Test.scala
index 2387a9b008..05097711ef 100644
--- a/test/files/scalacheck/quasiquotes/Test.scala
+++ b/test/files/scalacheck/quasiquotes/Test.scala
@@ -9,4 +9,6 @@ object Test extends Properties("quasiquotes") {
   include(PatternDeconstructionProps)
   include(LiftableProps)
   include(ErrorProps)
+  include(DefinitionConstructionProps)
+  include(DefinitionDeconstructionProps)
 }
\ No newline at end of file