deduplicate tuple tree creation code

Previously tuple tree generation code has been implemented in
three place: tree builder, tree gen, build utils. Now it's just
defined once in tree gen.

8 files changed, 39 insertions, 44 deletions

diff --git a/src/compiler/scala/tools/nsc/ast/TreeDSL.scala b/src/compiler/scala/tools/nsc/ast/TreeDSL.scala
index 0020528c5b..6dda30b5e7 100644
--- a/src/compiler/scala/tools/nsc/ast/TreeDSL.scala
+++ b/src/compiler/scala/tools/nsc/ast/TreeDSL.scala
@@ -137,7 +137,7 @@ trait TreeDSL {
     def IF(tree: Tree)    = new IfStart(tree, EmptyTree)
     def TRY(tree: Tree)   = new TryStart(tree, Nil, EmptyTree)
     def BLOCK(xs: Tree*)  = Block(xs.init.toList, xs.last)
-    def SOME(xs: Tree*)   = Apply(SomeClass.companionSymbol, treeBuilder.makeTupleTerm(xs.toList, flattenUnary = true))
+    def SOME(xs: Tree*)   = Apply(SomeClass.companionSymbol, gen.mkTuple(xs.toList))
 
     /** Typed trees from symbols. */
     def REF(sym: Symbol)            = gen.mkAttributedRef(sym)
diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
index cfa60cabc3..0bf4d5426e 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
@@ -861,7 +861,7 @@ self =>
             atPos(start, in.skipToken()) { makeFunctionTypeTree(ts, typ()) }
           else {
             ts foreach checkNotByNameOrVarargs
-            val tuple = atPos(start) { makeTupleType(ts, flattenUnary = true) }
+            val tuple = atPos(start) { makeTupleType(ts) }
             infixTypeRest(
               compoundTypeRest(
                 annotTypeRest(
@@ -923,7 +923,7 @@ self =>
       def simpleType(): Tree = {
         val start = in.offset
         simpleTypeRest(in.token match {
-          case LPAREN   => atPos(start)(makeTupleType(inParens(types()), flattenUnary = true))
+          case LPAREN   => atPos(start)(makeTupleType(inParens(types())))
           case USCORE   => wildcardType(in.skipToken())
           case _        =>
             path(thisOK = false, typeOK = true) match {
diff --git a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala
index 28d5aefc2b..5af279a62a 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala
@@ -121,25 +121,12 @@ abstract class TreeBuilder {
   def makeImportSelector(name: Name, nameOffset: Int): ImportSelector =
     ImportSelector(name, nameOffset, name, nameOffset)
 
-  private def makeTuple(trees: List[Tree], isType: Boolean): Tree = {
-    val tupString = "Tuple" + trees.length
-    Apply(scalaDot(if (isType) newTypeName(tupString) else newTermName(tupString)), trees)
-  }
-
-  def makeTupleTerm(trees: List[Tree], flattenUnary: Boolean): Tree = trees match {
-    case Nil => Literal(Constant(()))
-    case List(tree) if flattenUnary => tree
-    case _ => makeTuple(trees, isType = false)
-  }
+  def makeTupleTerm(elems: List[Tree]) = gen.mkTuple(elems)
 
-  def makeTupleType(trees: List[Tree], flattenUnary: Boolean): Tree = trees match {
-    case Nil => scalaUnitConstr
-    case List(tree) if flattenUnary => tree
-    case _ => AppliedTypeTree(scalaDot(newTypeName("Tuple" + trees.length)), trees)
-  }
+  def makeTupleType(elems: List[Tree]) = gen.mkTupleType(elems)
 
   def stripParens(t: Tree) = t match {
-    case Parens(ts) => atPos(t.pos) { makeTupleTerm(ts, flattenUnary = true) }
+    case Parens(ts) => atPos(t.pos) { makeTupleTerm(ts) }
     case _ => t
   }
 
@@ -362,9 +349,9 @@ abstract class TreeBuilder {
         val ids = (defpat1 :: defpats) map makeValue
         val rhs1 = makeForYield(
           List(ValFrom(pos, defpat1, rhs)),
-          Block(pdefs, atPos(wrappingPos(ids)) { makeTupleTerm(ids, flattenUnary = true) }) setPos wrappingPos(pdefs))
+          Block(pdefs, atPos(wrappingPos(ids)) { makeTupleTerm(ids) }) setPos wrappingPos(pdefs))
         val allpats = (pat :: pats) map (_.duplicate)
-        val vfrom1 = ValFrom(r2p(pos.start, pos.point, rhs1.pos.end), atPos(wrappingPos(allpats)) { makeTuple(allpats, isType = false) } , rhs1)
+        val vfrom1 = ValFrom(r2p(pos.start, pos.point, rhs1.pos.end), atPos(wrappingPos(allpats)) { makeTupleTerm(allpats) } , rhs1)
         makeFor(mapName, flatMapName, vfrom1 :: rest1, body)
       case _ =>
         EmptyTree //may happen for erroneous input
@@ -473,7 +460,7 @@ abstract class TreeBuilder {
           rhs1,
           List(
             atPos(pat1.pos) {
-              CaseDef(pat1, EmptyTree, makeTupleTerm(vars map (_._1) map Ident.apply, flattenUnary = true))
+              CaseDef(pat1, EmptyTree, makeTupleTerm(vars map (_._1) map Ident.apply))
             }
           ))
       }
diff --git a/src/compiler/scala/tools/reflect/quasiquotes/Parsers.scala b/src/compiler/scala/tools/reflect/quasiquotes/Parsers.scala
index 0b5ade0b4c..4a7984a9cf 100644
--- a/src/compiler/scala/tools/reflect/quasiquotes/Parsers.scala
+++ b/src/compiler/scala/tools/reflect/quasiquotes/Parsers.scala
@@ -63,11 +63,11 @@ trait Parsers { self: Quasiquotes =>
         override implicit def fresh: FreshNameCreator = parser.fresh
 
         // q"(..$xs)"
-        override def makeTupleTerm(trees: List[Tree], flattenUnary: Boolean): Tree =
+        override def makeTupleTerm(trees: List[Tree]): Tree =
           Apply(Ident(nme.QUASIQUOTE_TUPLE), trees)
 
         // tq"(..$xs)"
-        override def makeTupleType(trees: List[Tree], flattenUnary: Boolean): Tree =
+        override def makeTupleType(trees: List[Tree]): Tree =
           AppliedTypeTree(Ident(tpnme.QUASIQUOTE_TUPLE), trees)
 
         // q"{ $x }"
diff --git a/src/reflect/scala/reflect/internal/BuildUtils.scala b/src/reflect/scala/reflect/internal/BuildUtils.scala
index fc6b26db3f..9d111e8852 100644
--- a/src/reflect/scala/reflect/internal/BuildUtils.scala
+++ b/src/reflect/scala/reflect/internal/BuildUtils.scala
@@ -325,11 +325,9 @@ trait BuildUtils { self: SymbolTable =>
     }
 
     object SyntacticTuple extends SyntacticTupleExtractor {
-      def apply(args: List[Tree]): Tree = args match {
-        case Nil      => Literal(Constant(()))
-        case _        =>
-          require(TupleClass(args.length).exists, s"Tuples with ${args.length} arity aren't supported")
-          self.Apply(TupleClass(args.length).companionModule, args: _*)
+      def apply(args: List[Tree]): Tree = {
+        require(args.isEmpty || TupleClass(args.length).exists, s"Tuples with ${args.length} arity aren't supported")
+        gen.mkTuple(args, flattenUnary = false)
       }
 
       def unapply(tree: Tree): Option[List[Tree]] = tree match {
@@ -343,11 +341,9 @@ trait BuildUtils { self: SymbolTable =>
     }
 
     object SyntacticTupleType extends SyntacticTupleExtractor {
-      def apply(args: List[Tree]): Tree = args match {
-        case Nil => self.Select(self.Ident(nme.scala_), tpnme.Unit)
-        case _   =>
-          require(TupleClass(args.length).exists, s"Tuples with ${args.length} arity aren't supported")
-          AppliedTypeTree(Ident(TupleClass(args.length)), args)
+      def apply(args: List[Tree]): Tree = {
+        require(args.isEmpty || TupleClass(args.length).exists, s"Tuples with ${args.length} arity aren't supported")
+        gen.mkTupleType(args, flattenUnary = false)
       }
 
       def unapply(tree: Tree): Option[List[Tree]] =  tree match {
diff --git a/src/reflect/scala/reflect/internal/TreeGen.scala b/src/reflect/scala/reflect/internal/TreeGen.scala
index cf7c729a6a..c87eeea8e0 100644
--- a/src/reflect/scala/reflect/internal/TreeGen.scala
+++ b/src/reflect/scala/reflect/internal/TreeGen.scala
@@ -279,11 +279,23 @@ abstract class TreeGen extends macros.TreeBuilder {
   def mkNamedArg(lhs: Tree, rhs: Tree): Tree = atPos(rhs.pos)(AssignOrNamedArg(lhs, rhs))
 
   /** Builds a tuple */
-  def mkTuple(elems: List[Tree]): Tree =
-    if (elems.isEmpty) Literal(Constant(()))
-    else Apply(
-      Select(mkAttributedRef(TupleClass(elems.length).caseModule), nme.apply),
-      elems)
+  def mkTuple(elems: List[Tree], flattenUnary: Boolean = true): Tree = elems match {
+    case Nil =>
+      Literal(Constant(()))
+    case tree :: Nil if flattenUnary =>
+      tree
+    case _ =>
+      Apply(scalaDot(TupleClass(elems.length).companionModule.name), elems)
+  }
+
+  def mkTupleType(elems: List[Tree], flattenUnary: Boolean = true): Tree = elems match {
+    case Nil =>
+      scalaDot(tpnme.Unit)
+    case List(tree) if flattenUnary =>
+      tree
+    case _ =>
+      AppliedTypeTree(scalaDot(TupleClass(elems.length).name), elems)
+  }
 
   // tree1 AND tree2
   def mkAnd(tree1: Tree, tree2: Tree): Tree =
diff --git a/test/files/scalacheck/quasiquotes/TermConstructionProps.scala b/test/files/scalacheck/quasiquotes/TermConstructionProps.scala
index f68656d0f7..e1152a58ac 100644
--- a/test/files/scalacheck/quasiquotes/TermConstructionProps.scala
+++ b/test/files/scalacheck/quasiquotes/TermConstructionProps.scala
@@ -148,8 +148,8 @@ object TermConstructionProps extends QuasiquoteProperties("term construction") {
     val a1 = q"a1"
     val a2 = q"a2"
     val as = List(a1, a2)
-    assert(q"(..$as)" ≈ q"Tuple2($a1, $a2)")
-    assert(q"(a0, ..$as)" ≈ q"Tuple3(a0, $a1, $a2)")
+    assert(q"(..$as)" ≈ q"scala.Tuple2($a1, $a2)")
+    assert(q"(a0, ..$as)" ≈ q"scala.Tuple3(a0, $a1, $a2)")
   }
 
   property("splice empty list into tuple") = test {
diff --git a/test/files/scalacheck/quasiquotes/TypeConstructionProps.scala b/test/files/scalacheck/quasiquotes/TypeConstructionProps.scala
index cac83ff8ac..40ad33e04b 100644
--- a/test/files/scalacheck/quasiquotes/TypeConstructionProps.scala
+++ b/test/files/scalacheck/quasiquotes/TypeConstructionProps.scala
@@ -18,9 +18,9 @@ object TypeConstructionProps extends QuasiquoteProperties("type construction")
   property("tuple type") = test {
     val empty = List[Tree]()
     val ts = List(tq"t1", tq"t2")
-    assert(tq"(..$empty)" ≈ tq"scala.Unit")
-    assert(tq"(..$ts)" ≈ tq"Tuple2[t1, t2]")
-    assert(tq"(t0, ..$ts)" ≈ tq"Tuple3[t0, t1, t2]")
+    assert(tq"(..$empty)" ≈ build.ScalaDot(TypeName("Unit")))
+    assert(tq"(..$ts)" ≈ tq"scala.Tuple2[t1, t2]")
+    assert(tq"(t0, ..$ts)" ≈ tq"scala.Tuple3[t0, t1, t2]")
   }
 
   property("refined type") = test {