1 files changed, 54 insertions, 13 deletions

diff --git a/test/files/scalacheck/quasiquotes/DefinitionConstructionProps.scala b/test/files/scalacheck/quasiquotes/DefinitionConstructionProps.scala
index 2af656c7c9..dcd4f63a4d 100644
--- a/test/files/scalacheck/quasiquotes/DefinitionConstructionProps.scala
+++ b/test/files/scalacheck/quasiquotes/DefinitionConstructionProps.scala
@@ -7,7 +7,9 @@ object DefinitionConstructionProps
     with TraitConstruction
     with TypeDefConstruction
     with ValDefConstruction
-    with PackageConstruction {
+    with DefConstruction
+    with PackageConstruction
+    with ImportConstruction {
   property("SI-6842") = test {
     val x: Tree = q"val x: Int"
     assertEqAst(q"def f($x) = 0", "def f(x: Int) = 0")
@@ -228,13 +230,13 @@ trait MethodConstruction { self: QuasiquoteProperties =>
 
   property("splice type name into annotation") = test {
     val name = TypeName("annot")
-    assertSameAnnots(q"@$name def foo", List(annot(name)))
+    assertSameAnnots(q"@$name def foo", List(q"new $name"))
   }
 
   property("splice ident into annotation") = test {
     val name = TypeName("annot")
     val ident = Ident(name)
-    assertSameAnnots(q"@$ident def foo", List(annot(name)))
+    assertSameAnnots(q"@$ident def foo", List(q"new $name"))
   }
 
   property("splice idents into annotation") = test {
@@ -244,36 +246,36 @@ trait MethodConstruction { self: QuasiquoteProperties =>
   }
 
   property("splice constructor calls into annotation") = test {
-    val ctorcalls = List(annot("a1"), annot("a2"))
+    val ctorcalls = List(q"new a1", q"new a2")
     assertSameAnnots(q"@..$ctorcalls def foo", ctorcalls)
   }
 
   property("splice multiple annotations (1)") = test {
-    val annot1 = annot("a1")
-    val annot2 = annot("a2")
+    val annot1 = q"new a1"
+    val annot2 = q"new 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 annot1 = q"new a1"
+    val annots = List(q"new a2", q"new 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"))
+    val a = q"new a(x)"
     assertSameAnnots(q"@$a def foo", q"@a(x) def foo")
   }
 
   property("splice annotations with arguments (2)") = test {
-    val a = newTypeName("a")
+    val a = TypeName("a")
     assertSameAnnots(q"@$a(x) def foo", q"@a(x) def foo")
   }
 
   property("splice annotations with arguments (3") = test {
-    val a = Ident(newTypeName("a"))
+    val a = Ident(TypeName("a"))
     assertSameAnnots(q"@$a(x) def foo", q"@a(x) def foo")
   }
 
@@ -285,7 +287,7 @@ trait MethodConstruction { self: QuasiquoteProperties =>
   }
 
   property("can't splice annotations with arguments specificed twice") = test {
-    val a = annot("a", List(q"x"))
+    val a = q"new a(x)"
     assertThrows[IllegalArgumentException] {
       q"@$a(y) def foo"
     }
@@ -349,4 +351,43 @@ trait PackageConstruction { self: QuasiquoteProperties =>
     assertEqAst(q"package object foo extends { ..$edefs } with Any",
                  "package object foo extends { val x = 1; type I = Int } with Any")
   }
-}
\ No newline at end of file
+}
+
+trait DefConstruction { self: QuasiquoteProperties =>
+  property("construct implicit args (1)") = test {
+    val x = q"val x: Int"
+    assertEqAst(q"def foo(implicit $x) = x", "def foo(implicit x: Int) = x")
+  }
+
+  property("construct implicit args (2)") = test {
+    val xs = q"val x1: Int" :: q"val x2: Long" :: Nil
+    assertEqAst(q"def foo(implicit ..$xs) = x1 + x2", "def foo(implicit x1: Int, x2: Long) = x1 + x2")
+  }
+}
+
+trait ImportConstruction { self: QuasiquoteProperties =>
+  property("construct wildcard import") = test {
+    val sel = pq"_"
+    assert(q"import foo.$sel" ≈ q"import foo._")
+  }
+
+  property("construct named import") = test {
+    val sel = pq"bar"
+    assert(q"import foo.$sel" ≈ q"import foo.bar")
+  }
+
+  property("construct renaming import") = test {
+    val sel = pq"bar -> baz"
+    assert(q"import foo.$sel" ≈ q"import foo.{bar => baz}")
+  }
+
+  property("construct unimport import") = test {
+    val sels = pq"poison -> _" :: pq"_" :: Nil
+    assert(q"import foo.{..$sels}" ≈ q"import foo.{poison => _, _}")
+  }
+
+  property("construct mixed import") = test {
+    val sels = pq"a -> b" :: pq"c -> _" :: pq"_" :: Nil
+    assert(q"import foo.{..$sels}" ≈ q"import foo.{a => b, c => _, _}")
+  }
+}