Move placeholder construction logic into Placeholders

Previously construction logic used to be in Parsers and deconstruction in
Placeholders making it easy to forget one if you change the other.

3 files changed, 44 insertions, 30 deletions

diff --git a/src/compiler/scala/tools/reflect/quasiquotes/Parsers.scala b/src/compiler/scala/tools/reflect/quasiquotes/Parsers.scala
index 4bb37d8487..2410af49e5 100644
--- a/src/compiler/scala/tools/reflect/quasiquotes/Parsers.scala
+++ b/src/compiler/scala/tools/reflect/quasiquotes/Parsers.scala
@@ -61,12 +61,10 @@ trait Parsers { self: Quasiquotes =>
         override implicit def fresh: FreshNameCreator = parser.fresh
 
         // q"(..$xs)"
-        override def makeTupleTerm(trees: List[Tree]): Tree =
-          Apply(Ident(nme.QUASIQUOTE_TUPLE), trees)
+        override def makeTupleTerm(trees: List[Tree]): Tree = TuplePlaceholder(trees)
 
         // tq"(..$xs)"
-        override def makeTupleType(trees: List[Tree]): Tree =
-          AppliedTypeTree(Ident(tpnme.QUASIQUOTE_TUPLE), trees)
+        override def makeTupleType(trees: List[Tree]): Tree = TupleTypePlaceholder(trees)
 
         // q"{ $x }"
         override def makeBlock(stats: List[Tree]): Tree = stats match {
@@ -75,36 +73,32 @@ trait Parsers { self: Quasiquotes =>
         }
 
         // tq"$a => $b"
-        override def makeFunctionTypeTree(argtpes: List[Tree], restpe: Tree): Tree =
-          AppliedTypeTree(Ident(tpnme.QUASIQUOTE_FUNCTION), argtpes :+ restpe)
+        override def makeFunctionTypeTree(argtpes: List[Tree], restpe: Tree): Tree = FunctionTypePlaceholder(argtpes, restpe)
 
         // make q"val (x: T) = rhs" be equivalent to q"val x: T = rhs" for sake of bug compatibility (SI-8211)
         override def makePatDef(mods: Modifiers, pat: Tree, rhs: Tree) = pat match {
-          case Apply(Ident(nme.QUASIQUOTE_TUPLE), inParensPat :: Nil) => super.makePatDef(mods, inParensPat, rhs)
+          case TuplePlaceholder(inParensPat :: Nil) => super.makePatDef(mods, inParensPat, rhs)
           case _ => super.makePatDef(mods, pat, rhs)
         }
       }
       import treeBuilder.{global => _, unit => _, _}
 
-      def quasiquoteParam(name: Name, flags: FlagSet = NoFlags) =
-        ValDef(Modifiers(flags), name.toTermName, Ident(tpnme.QUASIQUOTE_PARAM), EmptyTree)
-
       // q"def foo($x)"
       override def param(owner: Name, implicitmod: Int, caseParam: Boolean): ValDef =
         if (isHole && lookingAhead { in.token == COMMA || in.token == RPAREN }) {
-          quasiquoteParam(ident(), implicitmod)
+          ParamPlaceholder(implicitmod, ident())
         } else super.param(owner, implicitmod, caseParam)
 
       // q"($x) => ..." && q"class X { selfie => }
       override def convertToParam(tree: Tree): ValDef = tree match {
-        case Ident(name) if isHole(name) => quasiquoteParam(name)
+        case Ident(name) if isHole(name) => ParamPlaceholder(NoFlags, name)
         case _ => super.convertToParam(tree)
       }
 
       // q"foo match { case $x }"
       override def caseClause(): CaseDef =
         if (isHole && lookingAhead { in.token == CASE || in.token == RBRACE || in.token == SEMI }) {
-          val c = makeCaseDef(Apply(Ident(nme.QUASIQUOTE_CASE), List(Ident(ident()))), EmptyTree, EmptyTree)
+          val c = CasePlaceholder(ident())
           while (in.token == SEMI) in.nextToken()
           c
         } else
@@ -138,7 +132,7 @@ trait Parsers { self: Quasiquotes =>
           in.nextToken()
           annot :: readAnnots(annot)
         case _ if isHole && lookingAhead { isAnnotation || isModifier || isDefIntro || isIdent || isStatSep || in.token == LPAREN } =>
-          val ann = Apply(Select(New(Ident(tpnme.QUASIQUOTE_MODS)), nme.CONSTRUCTOR), List(Literal(Constant(in.name.toString))))
+          val ann = ModsPlaceholder(in.name)
           in.nextToken()
           ann :: readAnnots(annot)
         case _ =>
@@ -147,13 +141,13 @@ trait Parsers { self: Quasiquotes =>
 
       override def refineStat(): List[Tree] =
         if (isHole && !isDclIntro) {
-          val result = ValDef(NoMods, in.name, Ident(tpnme.QUASIQUOTE_REFINE_STAT), EmptyTree) :: Nil
+          val result = RefineStatPlaceholder(in.name) :: Nil
           in.nextToken()
           result
         } else super.refineStat()
 
       override def ensureEarlyDef(tree: Tree) = tree match {
-        case Ident(name: TermName) if isHole(name) => ValDef(NoMods | Flag.PRESUPER, name, Ident(tpnme.QUASIQUOTE_EARLY_DEF), EmptyTree)
+        case Ident(name: TermName) if isHole(name) => EarlyDefPlaceholder(name)
         case _ => super.ensureEarlyDef(tree)
       }
 
@@ -164,14 +158,14 @@ trait Parsers { self: Quasiquotes =>
 
       override def topStat = super.topStat.orElse {
         case _ if isHole =>
-          val stats = ValDef(NoMods, in.name, Ident(tpnme.QUASIQUOTE_PACKAGE_STAT), EmptyTree) :: Nil
+          val stats = PackageStatPlaceholder(in.name) :: Nil
           in.nextToken()
           stats
       }
 
       override def enumerator(isFirst: Boolean, allowNestedIf: Boolean = true) =
         if (isHole && lookingAhead { in.token == EOF || in.token == RPAREN || isStatSep }) {
-          val res = build.SyntacticValFrom(Bind(in.name, Ident(nme.WILDCARD)), Ident(nme.QUASIQUOTE_FOR_ENUM)) :: Nil
+          val res = ForEnumPlaceholder(in.name) :: Nil
           in.nextToken()
           res
         } else super.enumerator(isFirst, allowNestedIf)
diff --git a/src/compiler/scala/tools/reflect/quasiquotes/Placeholders.scala b/src/compiler/scala/tools/reflect/quasiquotes/Placeholders.scala
index 825d0c04f3..130a01332b 100644
--- a/src/compiler/scala/tools/reflect/quasiquotes/Placeholders.scala
+++ b/src/compiler/scala/tools/reflect/quasiquotes/Placeholders.scala
@@ -100,6 +100,8 @@ trait Placeholders { self: Quasiquotes =>
   }
 
   object ModsPlaceholder extends HolePlaceholder {
+    def apply(name: Name) =
+      Apply(Select(New(Ident(tpnme.QUASIQUOTE_MODS)), nme.CONSTRUCTOR), List(Literal(Constant(name.toString))))
     def matching = {
       case Apply(Select(New(Ident(tpnme.QUASIQUOTE_MODS)), nme.CONSTRUCTOR), List(Literal(Constant(s: String)))) => TermName(s)
     }
@@ -112,12 +114,16 @@ trait Placeholders { self: Quasiquotes =>
   }
 
   object ParamPlaceholder extends HolePlaceholder {
+    def apply(flags: FlagSet, name: Name) =
+      ValDef(Modifiers(flags), nme.QUASIQUOTE_PARAM, Ident(name), EmptyTree)
     def matching = {
-      case ValDef(_, name, Ident(tpnme.QUASIQUOTE_PARAM), EmptyTree) => name
+      case ValDef(_, nme.QUASIQUOTE_PARAM, Ident(name), EmptyTree) => name
     }
   }
 
   object TuplePlaceholder {
+    def apply(args: List[Tree]) =
+      Apply(Ident(nme.QUASIQUOTE_TUPLE), args)
     def unapply(tree: Tree): Option[List[Tree]] = tree match {
       case Apply(Ident(nme.QUASIQUOTE_TUPLE), args) => Some(args)
       case _ => None
@@ -125,6 +131,8 @@ trait Placeholders { self: Quasiquotes =>
   }
 
   object TupleTypePlaceholder {
+    def apply(args: List[Tree]) =
+      AppliedTypeTree(Ident(tpnme.QUASIQUOTE_TUPLE), args)
     def unapply(tree: Tree): Option[List[Tree]] = tree match {
       case AppliedTypeTree(Ident(tpnme.QUASIQUOTE_TUPLE), args) => Some(args)
       case _ => None
@@ -132,6 +140,8 @@ trait Placeholders { self: Quasiquotes =>
   }
 
   object FunctionTypePlaceholder {
+    def apply(args: List[Tree], res: Tree) =
+      AppliedTypeTree(Ident(tpnme.QUASIQUOTE_FUNCTION), args :+ res)
     def unapply(tree: Tree): Option[(List[Tree], Tree)] = tree match {
       case AppliedTypeTree(Ident(tpnme.QUASIQUOTE_FUNCTION), args :+ res) => Some((args, res))
       case _ => None
@@ -146,6 +156,8 @@ trait Placeholders { self: Quasiquotes =>
   }
 
   object CasePlaceholder {
+    def apply(name: Name) =
+      CaseDef(Apply(Ident(nme.QUASIQUOTE_CASE), Ident(name) :: Nil), EmptyTree, EmptyTree)
     def unapply(tree: Tree): Option[Hole] = tree match {
       case CaseDef(Apply(Ident(nme.QUASIQUOTE_CASE), List(Placeholder(hole))), EmptyTree, EmptyTree) => Some(hole)
       case _ => None
@@ -153,27 +165,35 @@ trait Placeholders { self: Quasiquotes =>
   }
 
   object RefineStatPlaceholder {
+    def apply(name: Name) =
+      ValDef(NoMods, nme.QUASIQUOTE_REFINE_STAT, Ident(name), EmptyTree)
     def unapply(tree: Tree): Option[Hole] = tree match {
-      case ValDef(_, Placeholder(hole), Ident(tpnme.QUASIQUOTE_REFINE_STAT), _) => Some(hole)
+      case ValDef(_, nme.QUASIQUOTE_REFINE_STAT, Ident(Placeholder(hole)), _) => Some(hole)
       case _ => None
     }
   }
 
   object EarlyDefPlaceholder {
+    def apply(name: Name) =
+      ValDef(Modifiers(Flag.PRESUPER), nme.QUASIQUOTE_EARLY_DEF, Ident(name), EmptyTree)
     def unapply(tree: Tree): Option[Hole] = tree match {
-      case ValDef(_, Placeholder(hole), Ident(tpnme.QUASIQUOTE_EARLY_DEF), _) => Some(hole)
+      case ValDef(_, nme.QUASIQUOTE_EARLY_DEF, Ident(Placeholder(hole)), _) => Some(hole)
       case _ => None
     }
   }
 
   object PackageStatPlaceholder {
+    def apply(name: Name) =
+      ValDef(NoMods, nme.QUASIQUOTE_PACKAGE_STAT, Ident(name), EmptyTree)
     def unapply(tree: Tree): Option[Hole] = tree match {
-      case ValDef(NoMods, Placeholder(hole), Ident(tpnme.QUASIQUOTE_PACKAGE_STAT), EmptyTree) => Some(hole)
+      case ValDef(NoMods, nme.QUASIQUOTE_PACKAGE_STAT, Ident(Placeholder(hole)), EmptyTree) => Some(hole)
       case _ => None
     }
   }
 
   object ForEnumPlaceholder {
+    def apply(name: Name) =
+      build.SyntacticValFrom(Bind(name, Ident(nme.WILDCARD)), Ident(nme.QUASIQUOTE_FOR_ENUM))
     def unapply(tree: Tree): Option[Hole] = tree match {
       case build.SyntacticValFrom(Bind(Placeholder(hole), Ident(nme.WILDCARD)), Ident(nme.QUASIQUOTE_FOR_ENUM)) =>
         Some(hole)
diff --git a/src/reflect/scala/reflect/internal/StdNames.scala b/src/reflect/scala/reflect/internal/StdNames.scala
index 679186f938..0ac067a399 100644
--- a/src/reflect/scala/reflect/internal/StdNames.scala
+++ b/src/reflect/scala/reflect/internal/StdNames.scala
@@ -253,12 +253,8 @@ trait StdNames {
     final val Quasiquote: NameType          = "Quasiquote"
 
     // quasiquote-specific names
-    final val QUASIQUOTE_EARLY_DEF: NameType    = "$quasiquote$early$def$"
     final val QUASIQUOTE_FUNCTION: NameType     = "$quasiquote$function$"
     final val QUASIQUOTE_MODS: NameType         = "$quasiquote$mods$"
-    final val QUASIQUOTE_PACKAGE_STAT: NameType = "$quasiquote$package$stat$"
-    final val QUASIQUOTE_PARAM: NameType        = "$quasiquote$param$"
-    final val QUASIQUOTE_REFINE_STAT: NameType  = "$quasiquote$refine$stat$"
     final val QUASIQUOTE_TUPLE: NameType        = "$quasiquote$tuple$"
 
     // Annotation simple names, used in Namer
@@ -331,12 +327,16 @@ trait StdNames {
     val REIFY_FREE_THIS_SUFFIX: NameType   = "$this"
     val REIFY_FREE_VALUE_SUFFIX: NameType  = "$value"
     val REIFY_SYMDEF_PREFIX: NameType      = "symdef$"
-    val QUASIQUOTE_PREFIX: String          = "qq$"
-    val QUASIQUOTE_NAME_PREFIX: String     = "nn$"
-    val QUASIQUOTE_FILE: String            = "<quasiquote>"
-    val QUASIQUOTE_TUPLE: NameType         = "$quasiquote$tuple$"
     val QUASIQUOTE_CASE: NameType          = "$quasiquote$case$"
+    val QUASIQUOTE_EARLY_DEF: NameType     = "$quasiquote$early$def$"
+    val QUASIQUOTE_FILE: String            = "<quasiquote>"
     val QUASIQUOTE_FOR_ENUM: NameType      = "$quasiquote$for$enum$"
+    val QUASIQUOTE_NAME_PREFIX: String     = "nn$"
+    val QUASIQUOTE_PACKAGE_STAT: NameType  = "$quasiquote$package$stat$"
+    val QUASIQUOTE_PARAM: NameType         = "$quasiquote$param$"
+    val QUASIQUOTE_PREFIX: String          = "qq$"
+    val QUASIQUOTE_REFINE_STAT: NameType   = "$quasiquote$refine$stat$"
+    val QUASIQUOTE_TUPLE: NameType         = "$quasiquote$tuple$"
     val QUASIQUOTE_UNLIFT_HELPER: String   = "$quasiquote$unlift$helper$"
     val MIXIN_CONSTRUCTOR: NameType        = "$init$"
     val MODULE_INSTANCE_FIELD: NameType    = NameTransformer.MODULE_INSTANCE_NAME  // "MODULE$"