9 files changed, 230 insertions, 20 deletions
diff --git a/test/files/neg/quasiquotes-syntax-error-position.check b/test/files/neg/quasiquotes-syntax-error-position.check
index 25e5b8d75a..14fef16e01 100644
--- a/test/files/neg/quasiquotes-syntax-error-position.check
+++ b/test/files/neg/quasiquotes-syntax-error-position.check
@@ -29,4 +29,7 @@ quasiquotes-syntax-error-position.scala:13: error: end of quote expected but 'ca
 quasiquotes-syntax-error-position.scala:14: error: ')' expected but end of quote found.
   pq"$a(bar"
            ^
-10 errors found
+quasiquotes-syntax-error-position.scala:15: error: ':' expected but ')' found.
+  q"def foo(x)"
+             ^
+11 errors found
diff --git a/test/files/neg/quasiquotes-syntax-error-position.scala b/test/files/neg/quasiquotes-syntax-error-position.scala
index b97af52cfc..7b1d66ba00 100644
--- a/test/files/neg/quasiquotes-syntax-error-position.scala
+++ b/test/files/neg/quasiquotes-syntax-error-position.scala
@@ -12,4 +12,5 @@ object test extends App {
   tq"$t => $t $t]"
   cq"pattern => body ; case pattern2 =>"
   pq"$a(bar"
-}
-\ No newline at end of file
+  q"def foo(x)"
+}
diff --git a/test/files/neg/t6844.check b/test/files/neg/t6844.check
new file mode 100644
index 0000000000..1fc2485520
--- /dev/null
+++ b/test/files/neg/t6844.check
@@ -0,0 +1,6 @@
+t6844.scala:4: error: type mismatch;
+ found   : reflect.runtime.universe.TermName
+ required: reflect.runtime.universe.Tree
+  q"def foo($x)"
+             ^
+one error found
diff --git a/test/files/neg/t6844.scala b/test/files/neg/t6844.scala
new file mode 100644
index 0000000000..809d9d0f98
--- /dev/null
+++ b/test/files/neg/t6844.scala
@@ -0,0 +1,5 @@
+import scala.reflect.runtime.universe._
+object Test extends App {
+  val x = TermName("x")
+  q"def foo($x)"
+}
diff --git a/test/files/run/t8199.scala b/test/files/run/t8199.scala
new file mode 100644
index 0000000000..50994159ed
--- /dev/null
+++ b/test/files/run/t8199.scala
@@ -0,0 +1,105 @@
+class reallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongname {
+object obj0
+object obj01
+object obj012
+object obj0123
+object obj01234
+object obj012345
+object obj0123456
+object obj01234567
+object obj012345678
+object obj0123456789
+object obj01234567890
+class cls0
+class cls01
+class cls012
+class cls0123
+class cls01234
+class cls012345
+class cls0123456
+class cls01234567
+class cls012345678
+class cls0123456789
+class cls01234567890
+trait trt0 { def x = Test.checkCallerImplClassName() }
+trait trt01 { def x = Test.checkCallerImplClassName() }
+trait trt012 { def x = Test.checkCallerImplClassName() }
+trait trt0123 { def x = Test.checkCallerImplClassName() }
+trait trt01234 { def x = Test.checkCallerImplClassName() }
+trait trt012345 { def x = Test.checkCallerImplClassName() }
+trait trt0123456 { def x = Test.checkCallerImplClassName() }
+trait trt01234567 { def x = Test.checkCallerImplClassName() }
+trait trt012345678 { def x = Test.checkCallerImplClassName() }
+trait trt0123456789 { def x = Test.checkCallerImplClassName() }
+trait trt01234567890 { def x = Test.checkCallerImplClassName() }
+}
+
+object Test extends App {
+  def check(c: Class[_]) {
+    checkClassName(c.getName)
+  }
+  def checkClassName(name: String) {
+    val defaultMaxClassFileLength = 255
+    assert((name + ".class").length <= defaultMaxClassFileLength, name)
+  }
+  def checkCallerImplClassName() {
+    val name = Thread.currentThread.getStackTrace.apply(2).getClassName
+    assert(name.contains("$class"))
+    Test.checkClassName(name)
+  }
+
+  val c = new reallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongname
+  import c._
+
+  check(obj0.getClass)
+  check(obj01.getClass)
+  check(obj012.getClass)
+  check(obj0123.getClass)
+  check(obj01234.getClass)
+  check(obj012345.getClass)
+  check(obj0123456.getClass)
+  check(obj01234567.getClass)
+  check(obj012345678.getClass)
+  check(obj0123456789.getClass)
+  check(obj01234567890.getClass)
+
+  check(classOf[cls0])
+  check(classOf[cls01])
+  check(classOf[cls012])
+  check(classOf[cls0123])
+  check(classOf[cls01234])
+  check(classOf[cls012345])
+  check(classOf[cls0123456])
+  check(classOf[cls01234567])
+  check(classOf[cls012345678])
+  check(classOf[cls0123456789])
+  check(classOf[cls01234567890])
+
+  // interface facets
+  check(classOf[trt0])
+  check(classOf[trt01])
+  check(classOf[trt012])
+  check(classOf[trt0123])
+  check(classOf[trt01234])
+  check(classOf[trt012345])
+  check(classOf[trt0123456])
+  check(classOf[trt01234567])
+  check(classOf[trt012345678])
+  check(classOf[trt0123456789])
+  check(classOf[trt01234567890])
+
+  // impl classes are harder to find the names of to test!
+  (new trt0 {}).x
+  (new trt01 {}).x
+  (new trt012 {}).x
+  (new trt0123 {}).x
+  (new trt01234 {}).x
+  (new trt012345 {}).x
+  (new trt0123456 {}).x
+  (new trt01234567 {}).x
+  (new trt012345678 {}).x
+  (new trt0123456789 {}).x
+  (new trt01234567890 {}).x
+}
+
+// filename too long: reallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongnamereallylongname$obj012345$.class
diff --git a/test/files/scalacheck/quasiquotes/DefinitionConstructionProps.scala b/test/files/scalacheck/quasiquotes/DefinitionConstructionProps.scala
index 2af656c7c9..3166eb7a99 100644
--- a/test/files/scalacheck/quasiquotes/DefinitionConstructionProps.scala
+++ b/test/files/scalacheck/quasiquotes/DefinitionConstructionProps.scala
@@ -7,6 +7,7 @@ object DefinitionConstructionProps
     with TraitConstruction
     with TypeDefConstruction
     with ValDefConstruction
+    with DefConstruction
     with PackageConstruction {
   property("SI-6842") = test {
     val x: Tree = q"val x: Int"
@@ -349,4 +350,16 @@ 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")
+  }
+}
diff --git a/test/files/scalacheck/quasiquotes/DefinitionDeconstructionProps.scala b/test/files/scalacheck/quasiquotes/DefinitionDeconstructionProps.scala
index 94465930ed..209fe9bbeb 100644
--- a/test/files/scalacheck/quasiquotes/DefinitionDeconstructionProps.scala
+++ b/test/files/scalacheck/quasiquotes/DefinitionDeconstructionProps.scala
@@ -8,6 +8,7 @@ object DefinitionDeconstructionProps
   with ObjectDeconstruction
   with ModsDeconstruction
   with ValVarDeconstruction
+  with DefDeconstruction
   with PackageDeconstruction
 
 trait TraitDeconstruction { self: QuasiquoteProperties =>
@@ -179,4 +180,32 @@ trait PackageDeconstruction { self: QuasiquoteProperties =>
     matches("package object foo extends { val early = 1 } with daddy")
     assertThrows[MatchError] { matches("object foo") }
   }
-}
-\ No newline at end of file
+}
+
+trait DefDeconstruction { self: QuasiquoteProperties =>
+  property("exhaustive def matcher") = test {
+    def matches(line: String) = {
+      val t = parse(line)
+      val q"$mods0 def $name0[..$targs0](...$argss0): $restpe0 = $body0" = t
+      val q"$mods1 def $name1[..$targs1](...$argss1)(implicit ..$impl1): $restpe1 = $body1" = t
+    }
+    matches("def foo = foo")
+    matches("implicit def foo: Int = 2")
+    matches("def foo[T](x: T): T = x")
+    matches("def foo[A: B] = implicitly[B[A]]")
+    matches("private def foo = 0")
+    matches("def foo[A <% B] = null")
+    matches("def foo(one: One)(two: Two) = (one, two)")
+    matches("def foo[T](args: T*) = args.toList")
+  }
+
+  property("extract implicit arg list (1)") = test {
+    val q"def foo(...$argss)(implicit ..$impl)" = q"def foo(x: Int)(implicit y: Int)"
+    assert(impl ≈ List(q"${Modifiers(IMPLICIT | PARAM)} val y: Int"))
+  }
+
+  property("extract implicit arg list (2)") = test {
+    val q"def foo(...$argss)(implicit ..$impl)" = q"def foo(x: Int)"
+    assert(impl.isEmpty)
+  }
+}
diff --git a/test/files/scalacheck/quasiquotes/ErrorProps.scala b/test/files/scalacheck/quasiquotes/ErrorProps.scala
index 92d299bede..3a66574c7d 100644
--- a/test/files/scalacheck/quasiquotes/ErrorProps.scala
+++ b/test/files/scalacheck/quasiquotes/ErrorProps.scala
@@ -52,13 +52,6 @@ object ErrorProps extends QuasiquoteProperties("errors") {
       StringContext("\"", "\"").q(x)
     """)
 
-  property("expected different cardinality") = fails(
-    "Can't splice List[reflect.runtime.universe.Tree] with ..., consider using ..",
-    """
-      val args: List[Tree] = Nil
-      q"f(...$args)"
-    """)
-
   property("non-liftable type ..") = fails(
     "Can't splice List[StringBuilder] with .., consider omitting the dots or providing an implicit instance of Liftable[StringBuilder]",
     """
@@ -90,13 +83,6 @@ object ErrorProps extends QuasiquoteProperties("errors") {
       q"$xs"
     """)
 
-  property("use zero card") = fails(
-    "Can't splice reflect.runtime.universe.Tree with .., consider omitting the dots",
-    """
-      val t = EmptyTree
-      q"f(..$t)"
-    """)
-
   property("not liftable or natively supported") = fails(
     "Can't splice StringBuilder, consider providing an implicit instance of Liftable[StringBuilder]",
     """
@@ -188,4 +174,4 @@ object ErrorProps extends QuasiquoteProperties("errors") {
 
   // // Make sure a nice error is reported in this case
   // { import Flag._; val mods = NoMods; q"lazy $mods val x: Int" }
-}
-\ No newline at end of file
+}
diff --git a/test/files/scalacheck/quasiquotes/TermConstructionProps.scala b/test/files/scalacheck/quasiquotes/TermConstructionProps.scala
index 38fbfa9f7f..54187d68c2 100644
--- a/test/files/scalacheck/quasiquotes/TermConstructionProps.scala
+++ b/test/files/scalacheck/quasiquotes/TermConstructionProps.scala
@@ -116,7 +116,7 @@ object TermConstructionProps extends QuasiquoteProperties("term construction") {
 
   def blockInvariant(quote: Tree, trees: List[Tree]) =
     quote ≈ (trees match {
-      case Nil => q"()"
+      case Nil => q""
       case _ :+ last if !last.isTerm => Block(trees, q"()")
       case head :: Nil => head
       case init :+ last => Block(init, last)
@@ -229,4 +229,66 @@ object TermConstructionProps extends QuasiquoteProperties("term construction") {
     val q"($a, $b) => $_" = q"_ + _"
     assert(a.name != b.name)
   }
+
+  property("SI-7275 a") = test {
+    val t = q"stat1; stat2"
+    assertEqAst(q"..$t", "{stat1; stat2}")
+  }
+
+  property("SI-7275 b") = test {
+    def f(t: Tree) = q"..$t"
+    assertEqAst(f(q"stat1; stat2"), "{stat1; stat2}")
+  }
+
+  property("SI-7275 c1") = test {
+    object O
+    implicit val liftO = Liftable[O.type] { _ => q"foo; bar" }
+    assertEqAst(q"f(..$O)", "f(foo, bar)")
+  }
+
+  property("SI-7275 c2") = test {
+    object O
+    implicit val liftO = Liftable[O.type] { _ => q"{ foo; bar }; { baz; bax }" }
+    assertEqAst(q"f(...$O)", "f(foo, bar)(baz, bax)")
+  }
+
+  property("SI-7275 d") = test {
+    val l = q"a; b" :: q"c; d" :: Nil
+    assertEqAst(q"f(...$l)", "f(a, b)(c, d)")
+    val l2: Iterable[Tree] = l
+    assertEqAst(q"f(...$l2)", "f(a, b)(c, d)")
+  }
+
+  property("SI-7275 e") = test {
+    val t = q"{ a; b }; { c; d }"
+    assertEqAst(q"f(...$t)", "f(a, b)(c, d)")
+  }
+
+  property("SI-7275 e2") = test {
+    val t = q"{ a; b }; c; d"
+    assertEqAst(q"f(...$t)", "f(a, b)(c)(d)")
+  }
+
+  property("remove synthetic unit") = test {
+    val q"{ ..$stats1 }" = q"{ def x = 2 }"
+    assert(stats1 ≈ List(q"def x = 2"))
+    val q"{ ..$stats2 }" = q"{ class X }"
+    assert(stats2 ≈ List(q"class X"))
+    val q"{ ..$stats3 }" = q"{ type X = Int }"
+    assert(stats3 ≈ List(q"type X = Int"))
+    val q"{ ..$stats4 }" = q"{ val x = 2 }"
+    assert(stats4 ≈ List(q"val x = 2"))
+  }
+
+  property("don't remove user-defined unit") = test {
+    val q"{ ..$stats }" = q"{ def x = 2; () }"
+    assert(stats ≈ List(q"def x = 2", q"()"))
+  }
+
+  property("empty-tree as block") = test {
+    val q"{ ..$stats1 }" = q" "
+    assert(stats1.isEmpty)
+    val stats2 = List.empty[Tree]
+    assert(q"{ ..$stats2 }" ≈ q"")
+  }
 }