refine block and applied/typeapplied splicing/matching semantics

1. blocks now match single term-level expressions to account for
   automatic block elimination. E.g.

   val q"{ ..$stats }" = q"foo"

   will match into stats = List(q"foo"). This is useful to uniformly
   deal with blocks on term level.

2. blocks in quasiquotes collapse into single expressions

3. Applied and TypeApplied now have constructors too which helps
   to unify matching and extraction in quasiquote reifier

4. TypeApplied now matches AppliedTypeTree too

5. Add Syntactic prefix to Applied and TypeApplied

Author: densh

src/continuations/plugin/scala/tools/selectivecps/SelectiveCPSTransform.scala

@@ -330,8 +330,6 @@ abstract class SelectiveCPSTransform extends PluginComponent with
                 }
               }
 
-              def mkBlock(stms: List[Tree], expr: Tree) = if (stms.nonEmpty) Block(stms, expr) else expr
-
               try {
                 if (specialCaseTrivial) {
                   debuglog("will optimize possible tail call: " + bodyExpr)
@@ -350,17 +348,17 @@ abstract class SelectiveCPSTransform extends PluginComponent with
                   val argSym = currentOwner.newValue(vd.symbol.name.toTermName).setInfo(tpe)
                   val argDef = localTyper.typed(ValDef(argSym, Select(ctxRef, ctxRef.tpe.member(cpsNames.getTrivialValue))))
                   val switchExpr = localTyper.typedPos(vd.symbol.pos) {
-                    val body2 = mkBlock(bodyStms, bodyExpr).duplicate // dup before typing!
+                    val body2 = gen.mkBlock(bodyStms :+ bodyExpr).duplicate // dup before typing!
                     If(Select(ctxRef, ctxSym.tpe.member(cpsNames.isTrivial)),
-                      applyTrivial(argSym, mkBlock(argDef::bodyStms, bodyExpr)),
+                      applyTrivial(argSym, gen.mkBlock((argDef :: bodyStms) :+ bodyExpr)),
                       applyCombinatorFun(ctxRef, body2))
                   }
                   (List(ctxDef), switchExpr)
                 } else {
                   // ctx.flatMap { <lhs> => ... }
                   //     or
                   // ctx.map { <lhs> => ... }
-                  (Nil, applyCombinatorFun(rhs1, mkBlock(bodyStms, bodyExpr)))
+                  (Nil, applyCombinatorFun(rhs1, gen.mkBlock(bodyStms :+ bodyExpr)))
                 }
               } catch {
                 case ex:TypeError =>