Drop Pair

Drop tree node class 'Pair'. It was used only in imports, where
it can easily be replaced by Thicket.

The envisaged use for generic pairs is almost sure better modelled
by a "Pair" class in Dotty's standard library.

16 files changed, 34 insertions, 131 deletions

diff --git a/src/dotty/tools/dotc/ast/Desugar.scala b/src/dotty/tools/dotc/ast/Desugar.scala
index 1bfbcdbeb..edd6da5c9 100644
--- a/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/src/dotty/tools/dotc/ast/Desugar.scala
@@ -11,10 +11,6 @@ import collection.mutable.ListBuffer
 import util.Attachment
 
 object desugar {
-
-  /** Are we using the new unboxed pair scheme? */
-  private final val unboxedPairs = false
-
   import untpd._
 
   /** Tags a .withFilter call generated by desugaring a for expression.
@@ -923,25 +919,15 @@ object desugar {
       case Parens(t) =>
         t
       case Tuple(ts) =>
-        if (unboxedPairs) {
-          def PairTypeTree(l: Tree, r: Tree) =
-            AppliedTypeTree(ref(defn.PairType), l :: r :: Nil)
-          if (ctx.mode is Mode.Type) ts.reduceRight(PairTypeTree)
-          else if (ts.isEmpty) unitLiteral
-          else ts.reduceRight(Pair(_, _))
-        }
-        else {
-          val arity = ts.length
-          def tupleTypeRef = defn.TupleType(arity)
-          if (arity > Definitions.MaxTupleArity) {
-            ctx.error(s"tuple too long (max allowed: ${Definitions.MaxTupleArity})", tree.pos)
-            unitLiteral
-          }
-          else if (arity == 1) ts.head
-          else if (ctx.mode is Mode.Type) AppliedTypeTree(ref(tupleTypeRef), ts)
-          else if (arity == 0) unitLiteral
-          else Apply(ref(tupleTypeRef.classSymbol.companionModule.valRef), ts)
-        }
+        val arity = ts.length
+        def tupleTypeRef = defn.TupleType(arity)
+        if (arity > Definitions.MaxTupleArity) {
+          ctx.error(s"tuple too long (max allowed: ${Definitions.MaxTupleArity})", tree.pos)
+          unitLiteral
+        } else if (arity == 1) ts.head
+        else if (ctx.mode is Mode.Type) AppliedTypeTree(ref(tupleTypeRef), ts)
+        else if (arity == 0) unitLiteral
+        else Apply(ref(tupleTypeRef.classSymbol.companionModule.valRef), ts)
       case WhileDo(cond, body) =>
         // { <label> def while$(): Unit = if (cond) { body; while$() } ; while$() }
         val call = Apply(Ident(nme.WHILE_PREFIX), Nil)
@@ -1048,9 +1034,6 @@ object desugar {
         add(id, TypeTree())
       case Apply(_, args) =>
         args foreach collect
-      case Pair(left, right) =>
-        collect(left)
-        collect(right)
       case Typed(expr, _) =>
         collect(expr)
       case NamedArg(_, arg) =>
diff --git a/src/dotty/tools/dotc/ast/Trees.scala b/src/dotty/tools/dotc/ast/Trees.scala
index 5744742b8..0f8a63c12 100644
--- a/src/dotty/tools/dotc/ast/Trees.scala
+++ b/src/dotty/tools/dotc/ast/Trees.scala
@@ -428,15 +428,6 @@ object Trees {
     type ThisTree[-T >: Untyped] = New[T]
   }
 
-  /** (left, right) */
-  case class Pair[-T >: Untyped] private[ast] (left: Tree[T], right: Tree[T])
-    extends TermTree[T] {
-    type ThisTree[-T >: Untyped] = Pair[T]
-    override def isTerm = left.isTerm && right.isTerm
-    override def isType = left.isType && right.isType
-    override def isPattern = !isTerm && (left.isPattern || left.isTerm) && (right.isPattern || right.isTerm)
-  }
-
   /** expr : tpt */
   case class Typed[-T >: Untyped] private[ast] (expr: Tree[T], tpt: Tree[T])
     extends ProxyTree[T] with TermTree[T] {
@@ -694,7 +685,7 @@ object Trees {
 
   /** import expr.selectors
    *  where a selector is either an untyped `Ident`, `name` or
-   *  an untyped `Pair` `name => rename`
+   *  an untyped thicket consisting of `name` and `rename`.
    */
   case class Import[-T >: Untyped] private[ast] (expr: Tree[T], selectors: List[Tree[Untyped]])
     extends DenotingTree[T] {
@@ -836,7 +827,6 @@ object Trees {
     type TypeApply = Trees.TypeApply[T]
     type Literal = Trees.Literal[T]
     type New = Trees.New[T]
-    type Pair = Trees.Pair[T]
     type Typed = Trees.Typed[T]
     type NamedArg = Trees.NamedArg[T]
     type Assign = Trees.Assign[T]
@@ -955,10 +945,6 @@ object Trees {
         case tree: New if tpt eq tree.tpt => tree
         case _ => finalize(tree, untpd.New(tpt))
       }
-      def Pair(tree: Tree)(left: Tree, right: Tree)(implicit ctx: Context): Pair = tree match {
-        case tree: Pair if (left eq tree.left) && (right eq tree.right) => tree
-        case _ => finalize(tree, untpd.Pair(left, right))
-      }
       def Typed(tree: Tree)(expr: Tree, tpt: Tree)(implicit ctx: Context): Typed = tree match {
         case tree: Typed if (expr eq tree.expr) && (tpt eq tree.tpt) => tree
         case _ => finalize(tree, untpd.Typed(expr, tpt))
@@ -1132,8 +1118,6 @@ object Trees {
           tree
         case New(tpt) =>
           cpy.New(tree)(transform(tpt))
-        case Pair(left, right) =>
-          cpy.Pair(tree)(transform(left), transform(right))
         case Typed(expr, tpt) =>
           cpy.Typed(tree)(transform(expr), transform(tpt))
         case NamedArg(name, arg) =>
@@ -1238,8 +1222,6 @@ object Trees {
             x
           case New(tpt) =>
             this(x, tpt)
-          case Pair(left, right) =>
-            this(this(x, left), right)
           case Typed(expr, tpt) =>
             this(this(x, expr), tpt)
           case NamedArg(name, arg) =>
diff --git a/src/dotty/tools/dotc/ast/tpd.scala b/src/dotty/tools/dotc/ast/tpd.scala
index 022671540..1d23bdfd9 100644
--- a/src/dotty/tools/dotc/ast/tpd.scala
+++ b/src/dotty/tools/dotc/ast/tpd.scala
@@ -59,9 +59,6 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
   def New(tp: Type)(implicit ctx: Context): New = New(TypeTree(tp))
 
-  def Pair(left: Tree, right: Tree)(implicit ctx: Context): Pair =
-    ta.assignType(untpd.Pair(left, right), left, right)
-
   def Typed(expr: Tree, tpt: Tree)(implicit ctx: Context): Typed =
     ta.assignType(untpd.Typed(expr, tpt), tpt)
 
@@ -493,14 +490,6 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     override def New(tree: Tree)(tpt: Tree)(implicit ctx: Context): New =
       ta.assignType(untpd.cpy.New(tree)(tpt), tpt)
 
-    override def Pair(tree: Tree)(left: Tree, right: Tree)(implicit ctx: Context): Pair = {
-      val tree1 = untpd.cpy.Pair(tree)(left, right)
-      tree match {
-        case tree: Pair if (left.tpe eq tree.left.tpe) && (right.tpe eq tree.right.tpe) => tree1.withTypeUnchecked(tree.tpe)
-        case _ => ta.assignType(tree1, left, right)
-      }
-    }
-
     override def Typed(tree: Tree)(expr: Tree, tpt: Tree)(implicit ctx: Context): Typed =
       ta.assignType(untpd.cpy.Typed(tree)(expr, tpt), tpt)
 
diff --git a/src/dotty/tools/dotc/ast/untpd.scala b/src/dotty/tools/dotc/ast/untpd.scala
index 092cb95c0..ae444d123 100644
--- a/src/dotty/tools/dotc/ast/untpd.scala
+++ b/src/dotty/tools/dotc/ast/untpd.scala
@@ -139,7 +139,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def TypeApply(fun: Tree, args: List[Tree]): TypeApply = new TypeApply(fun, args)
   def Literal(const: Constant): Literal = new Literal(const)
   def New(tpt: Tree): New = new New(tpt)
-  def Pair(left: Tree, right: Tree): Pair = new Pair(left, right)
   def Typed(expr: Tree, tpt: Tree): Typed = new Typed(expr, tpt)
   def NamedArg(name: Name, arg: Tree): NamedArg = new NamedArg(name, arg)
   def Assign(lhs: Tree, rhs: Tree): Assign = new Assign(lhs, rhs)
diff --git a/src/dotty/tools/dotc/core/tasty/TastyFormat.scala b/src/dotty/tools/dotc/core/tasty/TastyFormat.scala
index 394d8f11a..e9de68e7f 100644
--- a/src/dotty/tools/dotc/core/tasty/TastyFormat.scala
+++ b/src/dotty/tools/dotc/core/tasty/TastyFormat.scala
@@ -74,7 +74,6 @@ Standard-Section: "ASTs" TopLevelStat*
                   SELECT                possiblySigned_NameRef qual_Term
                   NEW                   cls_Type
                   SUPER          Length this_Term mixinTrait_Type?
-                  PAIR           Length left_Term right_Term
                   TYPED          Length expr_Term ascription_Type
                   NAMEDARG       Length paramName_NameRef arg_Term
                   ASSIGN         Length lhs_Term rhs_Term
@@ -300,7 +299,8 @@ object TastyFormat {
   final val RENAMED = 138
   final val APPLY = 139
   final val TYPEAPPLY = 140
-  final val PAIR = 142
+
+
   final val TYPED = 143
   final val NAMEDARG = 144
   final val ASSIGN = 145
@@ -452,7 +452,6 @@ object TastyFormat {
     case APPLY => "APPLY"
     case TYPEAPPLY => "TYPEAPPLY"
     case NEW => "NEW"
-    case PAIR => "PAIR"
     case TYPED => "TYPED"
     case NAMEDARG => "NAMEDARG"
     case ASSIGN => "ASSIGN"
diff --git a/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/src/dotty/tools/dotc/core/tasty/TreePickler.scala
index be3999533..e5cacfc00 100644
--- a/src/dotty/tools/dotc/core/tasty/TreePickler.scala
+++ b/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -392,9 +392,6 @@ class TreePickler(pickler: TastyPickler) {
       case New(tpt) =>
         writeByte(NEW)
         pickleTpt(tpt)
-      case Pair(left, right) =>
-        writeByte(PAIR)
-        withLength { pickleTree(left); pickleTree(right) }
       case Typed(expr, tpt) =>
         writeByte(TYPED)
         withLength { pickleTree(expr); pickleTpt(tpt) }
@@ -496,7 +493,7 @@ class TreePickler(pickler: TastyPickler) {
         withLength {
           pickleTree(expr)
           selectors foreach {
-            case Pair(Ident(from), Ident(to)) =>
+            case Thicket(Ident(from) :: Ident(to) :: Nil) =>
               writeByte(RENAMED)
               withLength { pickleName(from); pickleName(to) }
             case Ident(name) =>
diff --git a/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
index 31247c005..f7363e72b 100644
--- a/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
+++ b/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
@@ -831,7 +831,7 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
         case RENAMED =>
           readByte()
           readEnd()
-          untpd.Pair(untpd.Ident(readName()), untpd.Ident(readName())) :: readSelectors()
+          untpd.Thicket(untpd.Ident(readName()), untpd.Ident(readName())) :: readSelectors()
         case IMPORTED =>
           readByte()
           untpd.Ident(readName()) :: readSelectors()
@@ -915,8 +915,6 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) {
               tpd.Apply(fn, until(end)(readArg()))
             case TYPEAPPLY =>
               tpd.TypeApply(readTerm(), until(end)(readTpt()))
-            case PAIR =>
-              Pair(readTerm(), readTerm())
             case TYPED =>
               val expr = readTerm()
               val tpt = readTpt()
diff --git a/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala b/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala
index 371d20e60..a667438be 100644
--- a/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala
+++ b/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala
@@ -1044,7 +1044,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
           val toName = readNameRef()
           val from = untpd.Ident(fromName)
           val to = untpd.Ident(toName)
-          if (toName.isEmpty) from else untpd.Pair(from, untpd.Ident(toName))
+          if (toName.isEmpty) from else untpd.Thicket(from, untpd.Ident(toName))
         })
 
         Import(expr, selectors)
diff --git a/src/dotty/tools/dotc/parsing/Parsers.scala b/src/dotty/tools/dotc/parsing/Parsers.scala
index c41515814..21a6a232f 100644
--- a/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -1786,7 +1786,7 @@ object Parsers {
       val from = termIdentOrWildcard()
       if (from.name != nme.WILDCARD && in.token == ARROW)
         atPos(from.pos.start, in.skipToken()) {
-          Pair(from, termIdentOrWildcard())
+          Thicket(from, termIdentOrWildcard())
         }
       else from
     }
diff --git a/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index 32d152c2e..cbe48409c 100644
--- a/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -311,8 +311,6 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
                 toTextLocal(tpt)
           }
         }
-      case Pair(l, r) =>
-        "(" ~ toTextGlobal(l) ~ ", " ~ toTextGlobal(r) ~ ")"
       case Typed(expr, tpt) =>
         changePrec(InfixPrec) { toText(expr) ~ ": " ~ toText(tpt) }
       case NamedArg(name, arg) =>
@@ -416,7 +414,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         }
       case Import(expr, selectors) =>
         def selectorText(sel: Tree): Text = sel match {
-          case Pair(l, r) => toTextGlobal(l) ~ " => " ~ toTextGlobal(r)
+          case Thicket(l :: r :: Nil) => toTextGlobal(l) ~ " => " ~ toTextGlobal(r)
           case _ => toTextGlobal(sel)
         }
         val selectorsText: Text = selectors match {
diff --git a/src/dotty/tools/dotc/sbt/ExtractDependencies.scala b/src/dotty/tools/dotc/sbt/ExtractDependencies.scala
index 026a518ce..a36b47aa8 100644
--- a/src/dotty/tools/dotc/sbt/ExtractDependencies.scala
+++ b/src/dotty/tools/dotc/sbt/ExtractDependencies.scala
@@ -184,7 +184,7 @@ private class ExtractDependenciesCollector(implicit val ctx: Context) extends tp
         selectors foreach {
           case Ident(name) =>
             addImported(name)
-           case Pair(Ident(name), Ident(rename)) =>
+          case Thicket(Ident(name) :: Ident(rename) :: Nil) =>
             addImported(name)
             if (rename ne nme.WILDCARD)
               addUsedName(rename)
diff --git a/src/dotty/tools/dotc/transform/TreeChecker.scala b/src/dotty/tools/dotc/transform/TreeChecker.scala
index 9d6445dc9..47d2395a0 100644
--- a/src/dotty/tools/dotc/transform/TreeChecker.scala
+++ b/src/dotty/tools/dotc/transform/TreeChecker.scala
@@ -213,9 +213,6 @@ class TreeChecker extends Phase with SymTransformer {
       // case tree: untpd.This =>
       // case tree: untpd.Literal =>
       // case tree: untpd.New =>
-      case Pair(left, right) =>
-        assertIdentNotJavaClass(left)
-        assertIdentNotJavaClass(right)
       case Typed(expr, _) =>
         assertIdentNotJavaClass(expr)
       case NamedArg(_, arg) =>
diff --git a/src/dotty/tools/dotc/transform/TreeTransform.scala b/src/dotty/tools/dotc/transform/TreeTransform.scala
index 89ae927b7..f31116629 100644
--- a/src/dotty/tools/dotc/transform/TreeTransform.scala
+++ b/src/dotty/tools/dotc/transform/TreeTransform.scala
@@ -70,7 +70,6 @@ object TreeTransforms {
     def prepareForApply(tree: Apply)(implicit ctx: Context) = this
     def prepareForTypeApply(tree: TypeApply)(implicit ctx: Context) = this
     def prepareForLiteral(tree: Literal)(implicit ctx: Context) = this
-    def prepareForPair(tree: Pair)(implicit ctx: Context) = this
     def prepareForNew(tree: New)(implicit ctx: Context) = this
     def prepareForTyped(tree: Typed)(implicit ctx: Context) = this
     def prepareForAssign(tree: Assign)(implicit ctx: Context) = this
@@ -104,7 +103,6 @@ object TreeTransforms {
     def transformTypeApply(tree: TypeApply)(implicit ctx: Context, info: TransformerInfo): Tree = tree
     def transformLiteral(tree: Literal)(implicit ctx: Context, info: TransformerInfo): Tree = tree
     def transformNew(tree: New)(implicit ctx: Context, info: TransformerInfo): Tree = tree
-    def transformPair(tree: Pair)(implicit ctx: Context, info: TransformerInfo): Tree = tree
     def transformTyped(tree: Typed)(implicit ctx: Context, info: TransformerInfo): Tree = tree
     def transformAssign(tree: Assign)(implicit ctx: Context, info: TransformerInfo): Tree = tree
     def transformBlock(tree: Block)(implicit ctx: Context, info: TransformerInfo): Tree = tree
@@ -267,7 +265,6 @@ object TreeTransforms {
       nxPrepTypeApply = index(transformations, "prepareForTypeApply")
       nxPrepLiteral = index(transformations, "prepareForLiteral")
       nxPrepNew = index(transformations, "prepareForNew")
-      nxPrepPair = index(transformations, "prepareForPair")
       nxPrepTyped = index(transformations, "prepareForTyped")
       nxPrepAssign = index(transformations, "prepareForAssign")
       nxPrepBlock = index(transformations, "prepareForBlock")
@@ -299,7 +296,6 @@ object TreeTransforms {
       nxTransTypeApply = index(transformations, "transformTypeApply")
       nxTransLiteral = index(transformations, "transformLiteral")
       nxTransNew = index(transformations, "transformNew")
-      nxTransPair = index(transformations, "transformPair")
       nxTransTyped = index(transformations, "transformTyped")
       nxTransAssign = index(transformations, "transformAssign")
       nxTransBlock = index(transformations, "transformBlock")
@@ -341,7 +337,6 @@ object TreeTransforms {
       nxPrepTypeApply = indexUpdate(prev.nxPrepTypeApply, changedTransformationClass, transformationIndex, "prepareForTypeApply", copy)
       nxPrepLiteral = indexUpdate(prev.nxPrepLiteral, changedTransformationClass, transformationIndex, "prepareForLiteral", copy)
       nxPrepNew = indexUpdate(prev.nxPrepNew, changedTransformationClass, transformationIndex, "prepareForNew", copy)
-      nxPrepPair = indexUpdate(prev.nxPrepPair, changedTransformationClass, transformationIndex, "prepareForPair", copy)
       nxPrepTyped = indexUpdate(prev.nxPrepTyped, changedTransformationClass, transformationIndex, "prepareForTyped", copy)
       nxPrepAssign = indexUpdate(prev.nxPrepAssign, changedTransformationClass, transformationIndex, "prepareForAssign", copy)
       nxPrepBlock = indexUpdate(prev.nxPrepBlock, changedTransformationClass, transformationIndex, "prepareForBlock", copy)
@@ -372,7 +367,6 @@ object TreeTransforms {
       nxTransTypeApply = indexUpdate(prev.nxTransTypeApply, changedTransformationClass, transformationIndex, "transformTypeApply", copy)
       nxTransLiteral = indexUpdate(prev.nxTransLiteral, changedTransformationClass, transformationIndex, "transformLiteral", copy)
       nxTransNew = indexUpdate(prev.nxTransNew, changedTransformationClass, transformationIndex, "transformNew", copy)
-      nxTransPair = indexUpdate(prev.nxTransPair, changedTransformationClass, transformationIndex, "transformPair", copy)
       nxTransTyped = indexUpdate(prev.nxTransTyped, changedTransformationClass, transformationIndex, "transformTyped", copy)
       nxTransAssign = indexUpdate(prev.nxTransAssign, changedTransformationClass, transformationIndex, "transformAssign", copy)
       nxTransBlock = indexUpdate(prev.nxTransBlock, changedTransformationClass, transformationIndex, "transformBlock", copy)
@@ -409,7 +403,6 @@ object TreeTransforms {
     var nxPrepTypeApply: Array[Int] = _
     var nxPrepLiteral: Array[Int] = _
     var nxPrepNew: Array[Int] = _
-    var nxPrepPair: Array[Int] = _
     var nxPrepTyped: Array[Int] = _
     var nxPrepAssign: Array[Int] = _
     var nxPrepBlock: Array[Int] = _
@@ -441,7 +434,6 @@ object TreeTransforms {
     var nxTransTypeApply: Array[Int] = _
     var nxTransLiteral: Array[Int] = _
     var nxTransNew: Array[Int] = _
-    var nxTransPair: Array[Int] = _
     var nxTransTyped: Array[Int] = _
     var nxTransAssign: Array[Int] = _
     var nxTransBlock: Array[Int] = _
@@ -520,7 +512,6 @@ object TreeTransforms {
     val prepForApply: Mutator[Apply] = (trans, tree, ctx) => trans.prepareForApply(tree)(ctx)
     val prepForTypeApply: Mutator[TypeApply] = (trans, tree, ctx) => trans.prepareForTypeApply(tree)(ctx)
     val prepForNew: Mutator[New] = (trans, tree, ctx) => trans.prepareForNew(tree)(ctx)
-    val prepForPair: Mutator[Pair] = (trans, tree, ctx) => trans.prepareForPair(tree)(ctx)
     val prepForTyped: Mutator[Typed] = (trans, tree, ctx) => trans.prepareForTyped(tree)(ctx)
     val prepForAssign: Mutator[Assign] = (trans, tree, ctx) => trans.prepareForAssign(tree)(ctx)
     val prepForLiteral: Mutator[Literal] = (trans, tree, ctx) => trans.prepareForLiteral(tree)(ctx)
@@ -638,17 +629,6 @@ object TreeTransforms {
     }
 
     @tailrec
-    final private[TreeTransforms] def goPair(tree: Pair, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = {
-      if (cur < info.transformers.length) {
-        val trans = info.transformers(cur)
-        trans.transformPair(tree)(ctx.withPhase(trans.treeTransformPhase), info) match {
-          case t: Pair => goPair(t, info.nx.nxTransPair(cur + 1))
-          case t => transformSingle(t, cur + 1)
-        }
-      } else tree
-    }
-
-    @tailrec
     final private[TreeTransforms] def goTyped(tree: Typed, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = {
       if (cur < info.transformers.length) {
         val trans = info.transformers(cur)
@@ -917,7 +897,6 @@ object TreeTransforms {
         case tree: TypeApply => goTypeApply(tree, info.nx.nxTransTypeApply(cur))
         case tree: Literal => goLiteral(tree, info.nx.nxTransLiteral(cur))
         case tree: New => goNew(tree, info.nx.nxTransNew(cur))
-        case tree: Pair => goPair(tree, info.nx.nxTransPair(cur))
         case tree: Typed => goTyped(tree, info.nx.nxTransTyped(cur))
         case tree: Assign => goAssign(tree, info.nx.nxTransAssign(cur))
         case tree: Block => goBlock(tree, info.nx.nxTransBlock(cur))
@@ -1052,14 +1031,6 @@ object TreeTransforms {
             val tpt = transform(tree.tpt, mutatedInfo, cur)
             goNew(cpy.New(tree)(tpt), mutatedInfo.nx.nxTransNew(cur))
           }
-        case tree: Pair =>
-          implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForPair, info.nx.nxPrepPair, tree, cur)
-          if (mutatedInfo eq null) tree
-          else {
-            val left = transform(tree.left, mutatedInfo, cur)
-            val right = transform(tree.right, mutatedInfo, cur)
-            goPair(cpy.Pair(tree)(left, right), mutatedInfo.nx.nxTransPair(cur))
-          }
         case tree: Typed =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForTyped, info.nx.nxPrepTyped, tree, cur)
           if (mutatedInfo eq null) tree
diff --git a/src/dotty/tools/dotc/typer/ImportInfo.scala b/src/dotty/tools/dotc/typer/ImportInfo.scala
index 2105d9ccc..3aa289181 100644
--- a/src/dotty/tools/dotc/typer/ImportInfo.scala
+++ b/src/dotty/tools/dotc/typer/ImportInfo.scala
@@ -60,9 +60,9 @@ class ImportInfo(symf: => Symbol, val selectors: List[untpd.Tree], val isRootImp
     def recur(sels: List[untpd.Tree]): Unit = sels match {
       case sel :: sels1 =>
         sel match {
-          case Pair(Ident(name: TermName), Ident(nme.WILDCARD)) =>
+          case Thicket(Ident(name: TermName) :: Ident(nme.WILDCARD) :: Nil) =>
             myExcluded += name
-          case Pair(Ident(from: TermName), Ident(to: TermName)) =>
+          case Thicket(Ident(from: TermName) :: Ident(to: TermName) :: Nil) =>
             myMapped = myMapped.updated(to, from)
             myExcluded += from
             myOriginals += from
@@ -99,7 +99,7 @@ class ImportInfo(symf: => Symbol, val selectors: List[untpd.Tree], val isRootImp
   lazy val hiddenRoot: Symbol = {
     val sym = site.termSymbol
     def hasMaskingSelector = selectors exists {
-      case Pair(_, Ident(nme.WILDCARD)) => true
+      case Thicket(_ :: Ident(nme.WILDCARD) :: Nil) => true
       case _ => false
     }
     if ((defn.RootImportTypes exists (_.symbol == sym)) && hasMaskingSelector) sym else NoSymbol
diff --git a/src/dotty/tools/dotc/typer/TypeAssigner.scala b/src/dotty/tools/dotc/typer/TypeAssigner.scala
index 740fa2658..42302e5ff 100644
--- a/src/dotty/tools/dotc/typer/TypeAssigner.scala
+++ b/src/dotty/tools/dotc/typer/TypeAssigner.scala
@@ -376,9 +376,6 @@ trait TypeAssigner {
     tree.withType(ownType)
   }
 
-  def assignType(tree: untpd.Pair, left: Tree, right: Tree)(implicit ctx: Context) =
-    tree.withType(defn.PairType.appliedTo(left.tpe :: right.tpe :: Nil))
-
   def assignType(tree: untpd.Typed, tpt: Tree)(implicit ctx: Context) =
     tree.withType(tpt.tpe)
 
diff --git a/src/dotty/tools/dotc/typer/Typer.scala b/src/dotty/tools/dotc/typer/Typer.scala
index af09a8283..072240248 100644
--- a/src/dotty/tools/dotc/typer/Typer.scala
+++ b/src/dotty/tools/dotc/typer/Typer.scala
@@ -186,15 +186,19 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
         }
         val Name = name.toTermName.decode
         selectors match {
-          case Pair(Ident(from), Ident(Name)) :: rest =>
-            val selName = if (name.isTypeName) from.toTypeName else from
-            // Pass refctx so that any errors are reported in the context of the
-            // reference instead of the context of the import.
-            checkUnambiguous(selectionType(site, selName, tree.pos)(refctx))
-          case Ident(Name) :: rest =>
-            checkUnambiguous(selectionType(site, name, tree.pos)(refctx))
-          case _ :: rest =>
-            namedImportRef(site, rest)
+          case selector :: rest =>
+            selector match {
+              case Thicket(fromId :: Ident(Name) :: _) =>
+                val Ident(from) = fromId
+                val selName = if (name.isTypeName) from.toTypeName else from
+                // Pass refctx so that any errors are reported in the context of the
+                // reference instead of the context of the import.
+                checkUnambiguous(selectionType(site, selName, tree.pos)(refctx))
+              case Ident(Name) =>
+                checkUnambiguous(selectionType(site, name, tree.pos)(refctx))
+              case _ =>
+                namedImportRef(site, rest)
+            }
           case nil =>
             NoType
         }
@@ -448,16 +452,6 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     }
   }
 
-  def typedPair(tree: untpd.Pair, pt: Type)(implicit ctx: Context) = track("typedPair") {
-    val (leftProto, rightProto) = pt.argTypesLo match {
-      case l :: r :: Nil if pt isRef defn.PairClass => (l, r)
-      case _ => (WildcardType, WildcardType)
-    }
-    val left1 = typed(tree.left, leftProto)
-    val right1 = typed(tree.right, rightProto)
-    assignType(cpy.Pair(tree)(left1, right1), left1, right1)
-  }
-
   def typedTyped(tree: untpd.Typed, pt: Type)(implicit ctx: Context): Tree = track("typedTyped") {
     /*  Handles three cases:
      *  @param  ifPat    how to handle a pattern (_: T)
@@ -1422,7 +1416,6 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
           case tree: untpd.This => typedThis(tree)
           case tree: untpd.Literal => typedLiteral(tree)
           case tree: untpd.New => typedNew(tree, pt)
-          case tree: untpd.Pair => typedPair(tree, pt)
           case tree: untpd.Typed => typedTyped(tree, pt)
           case tree: untpd.NamedArg => typedNamedArg(tree, pt)
           case tree: untpd.Assign => typedAssign(tree, pt)