Represent tq"" as SyntacticEmptyTypeTree rather than TypeTree()

Such representation codifies the fact that type tree that doesn't have
embedded syntactic equivalent must have been inferred or otherwise
provided by the compiler rather than specified by the end user.

Additionally it also ensures that we can still match trees without
explicit types (e.g. vals without type) after typechecking. Otherwise
the same quote couldn't be used in situations like:

    val q"val x = 42" = typecheck(q"val x = 42")

src/compiler/scala/tools/reflect/quasiquotes/Reifiers.scala

@@ -190,6 +190,8 @@ trait Reifiers { self: Quasiquotes =>
         reifyBuildCall(nme.SyntacticFunction, args, body)
       case SyntacticIdent(name, isBackquoted) =>
         reifyBuildCall(nme.SyntacticIdent, name, isBackquoted)
+      case SyntacticEmptyTypeTree() =>
+        reifyBuildCall(nme.SyntacticEmptyTypeTree)
       case Q(Placeholder(Hole(tree, DotDot))) =>
         mirrorBuildCall(nme.SyntacticBlock, tree)
       case Q(other) =>

src/reflect/scala/reflect/api/BuildUtils.scala

@@ -248,6 +248,13 @@ private[reflect] trait BuildUtils { self: Universe =>
       def unapply(tree: Tree): Option[(Tree)]
     }
 
+    val SyntacticEmptyTypeTree: SyntacticEmptyTypeTreeExtractor
+
+    trait SyntacticEmptyTypeTreeExtractor {
+      def apply(): TypeTree
+      def unapply(tt: TypeTree): Boolean
+    }
+
     val SyntacticFor: SyntacticForExtractor
     val SyntacticForYield: SyntacticForExtractor
 

src/reflect/scala/reflect/internal/BuildUtils.scala

@@ -537,8 +537,11 @@ trait BuildUtils { self: SymbolTable =>
       def unapply(tree: Tree): Option[Tree] = gen.Filter.unapply(tree)
     }
 
-    // a type tree which wasn't specified by the user but might have been inferred by compiler
-    object SyntacticEmptyTypeTree {
+    // TypeTree without original is used to signal that no type was provided
+    // by the user and compiler should infer it instead. (Note: EmptyTree is
+    // not appropriate in such role, it's only used for terms, not types.)
+    object SyntacticEmptyTypeTree extends SyntacticEmptyTypeTreeExtractor {
+      def apply(): TypeTree = self.TypeTree()
       def unapply(tt: TypeTree): Boolean = tt.original == null || tt.original.isEmpty
     }
 

src/reflect/scala/reflect/internal/StdNames.scala

@@ -602,6 +602,7 @@ trait StdNames {
     val SyntacticBlock: NameType       = "SyntacticBlock"
     val SyntacticClassDef: NameType    = "SyntacticClassDef"
     val SyntacticDefDef: NameType      = "SyntacticDefDef"
+    val SyntacticEmptyTypeTree: NameType = "SyntacticEmptyTypeTree"
     val SyntacticFilter: NameType      = "SyntacticFilter"
     val SyntacticFor: NameType         = "SyntacticFor"
     val SyntacticForYield: NameType    = "SyntacticForYield"

test/files/scalacheck/quasiquotes/TypeConstructionProps.scala

@@ -30,7 +30,7 @@ object TypeConstructionProps extends QuasiquoteProperties("type construction")
   }
 
   property("empty tq") = test {
-    val tt: TypeTree = tq" "
+    val tt: TypeTree = tq""
     assert(tt.tpe == null)
     assert(tt.original == null)
   }

test/files/scalacheck/quasiquotes/TypeDeconstructionProps.scala

@@ -52,4 +52,10 @@ object TypeDeconstructionProps extends QuasiquoteProperties("type deconstruction
     assert(arglast ≈ tq"C")
     assert(restpe ≈ tq"D")
   }
+
+  property("match empty type tree") = test {
+    val tq"" = TypeTree()
+    // matches because type tree isn't syntactic without original
+    val tq"" = tq"${typeOf[Int]}"
+  }
 }

test/files/scalacheck/quasiquotes/TypecheckedProps.scala

@@ -75,4 +75,11 @@ object TypecheckedProps extends QuasiquoteProperties("typechecked") {
     assert(f.original ≈ pq"Test.this.Cell")
     assert(args ≈ List(pq"v"))
   }
-}
+
+  property("extract inferred val type") = test {
+    val typechecked = typecheck(q"val x = 42")
+    val q"val x = 42" = typechecked
+    val q"val x: ${tq""} = 42" = typechecked
+    val q"val x: ${t: Type} = 42" = typechecked
+  }
+}