diff --git a/docs/SyntaxSummary.txt b/docs/SyntaxSummary.txt
index f07335d1d2a3..6c83c71abece 100644
--- a/docs/SyntaxSummary.txt
+++ b/docs/SyntaxSummary.txt
@@ -105,7 +105,7 @@ grammar.
   WithType          ::=  AnnotType {`with' AnnotType}                           (deprecated)
   AnnotType         ::=  SimpleType {Annotation}                                Annotated(t, annot)
   SimpleType        ::=  SimpleType (TypeArgs | NamedTypeArgs)                  AppliedTypeTree(t, args)
-                      |  SimpleType `#' id                                      SelectFromTypeTree(t, name)
+                      |  SimpleType `#' id                                      Select(t, name)
                       |  StableId
                       |  Path `.' `type'                                        SingletonTypeTree(p)
                       |  `(' ArgTypes ')'                                       Tuple(ts)
diff --git a/src/dotty/tools/dotc/ast/Desugar.scala b/src/dotty/tools/dotc/ast/Desugar.scala
index 1bfbcdbeb5c8..edd6da5c90b8 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/TreeInfo.scala b/src/dotty/tools/dotc/ast/TreeInfo.scala
index 0d4179218d45..d6df204c1631 100644
--- a/src/dotty/tools/dotc/ast/TreeInfo.scala
+++ b/src/dotty/tools/dotc/ast/TreeInfo.scala
@@ -182,7 +182,7 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
     case OrTypeTree(tpt1, tpt2) => mayBeTypePat(tpt1) || mayBeTypePat(tpt2)
     case RefinedTypeTree(tpt, refinements) => mayBeTypePat(tpt) || refinements.exists(_.isInstanceOf[Bind])
     case AppliedTypeTree(tpt, args) => mayBeTypePat(tpt) || args.exists(_.isInstanceOf[Bind])
-    case SelectFromTypeTree(tpt, _) => mayBeTypePat(tpt)
+    case Select(tpt, _) => mayBeTypePat(tpt)
     case Annotated(tpt, _) => mayBeTypePat(tpt)
     case _ => false
   }
diff --git a/src/dotty/tools/dotc/ast/Trees.scala b/src/dotty/tools/dotc/ast/Trees.scala
index 5744742b81e9..528e3c589bb1 100644
--- a/src/dotty/tools/dotc/ast/Trees.scala
+++ b/src/dotty/tools/dotc/ast/Trees.scala
@@ -364,7 +364,7 @@ object Trees {
     override def toString = s"BackquotedIdent($name)"
   }
 
-  /** qualifier.name */
+  /** qualifier.name, or qualifier#name, if qualifier is a type */
   case class Select[-T >: Untyped] private[ast] (qualifier: Tree[T], name: Name)
     extends RefTree[T] {
     type ThisTree[-T >: Untyped] = Select[T]
@@ -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] {
@@ -558,15 +549,6 @@ object Trees {
     type ThisTree[-T >: Untyped] = SingletonTypeTree[T]
   }
 
-  /** qualifier # name
-   *  In Scala, this always refers to a type, but in a Java
-   *  compilation unit this might refer to a term.
-   */
-  case class SelectFromTypeTree[-T >: Untyped] private[ast] (qualifier: Tree[T], name: Name)
-    extends RefTree[T] {
-    type ThisTree[-T >: Untyped] = SelectFromTypeTree[T]
-  }
-
   /** left & right */
   case class AndTypeTree[-T >: Untyped] private[ast] (left: Tree[T], right: Tree[T])
     extends TypTree[T] {
@@ -694,7 +676,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 +818,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]
@@ -851,7 +832,6 @@ object Trees {
     type JavaSeqLiteral = Trees.JavaSeqLiteral[T]
     type TypeTree = Trees.TypeTree[T]
     type SingletonTypeTree = Trees.SingletonTypeTree[T]
-    type SelectFromTypeTree = Trees.SelectFromTypeTree[T]
     type AndTypeTree = Trees.AndTypeTree[T]
     type OrTypeTree = Trees.OrTypeTree[T]
     type RefinedTypeTree = Trees.RefinedTypeTree[T]
@@ -955,10 +935,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))
@@ -1014,10 +990,6 @@ object Trees {
         case tree: SingletonTypeTree if ref eq tree.ref => tree
         case _ => finalize(tree, untpd.SingletonTypeTree(ref))
       }
-      def SelectFromTypeTree(tree: Tree)(qualifier: Tree, name: Name): SelectFromTypeTree = tree match {
-        case tree: SelectFromTypeTree if (qualifier eq tree.qualifier) && (name == tree.name) => tree
-        case _ => finalize(tree, untpd.SelectFromTypeTree(qualifier, name))
-      }
       def AndTypeTree(tree: Tree)(left: Tree, right: Tree): AndTypeTree = tree match {
         case tree: AndTypeTree if (left eq tree.left) && (right eq tree.right) => tree
         case _ => finalize(tree, untpd.AndTypeTree(left, right))
@@ -1132,8 +1104,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) =>
@@ -1160,8 +1130,6 @@ object Trees {
           tree
         case SingletonTypeTree(ref) =>
           cpy.SingletonTypeTree(tree)(transform(ref))
-        case SelectFromTypeTree(qualifier, name) =>
-          cpy.SelectFromTypeTree(tree)(transform(qualifier), name)
         case AndTypeTree(left, right) =>
           cpy.AndTypeTree(tree)(transform(left), transform(right))
         case OrTypeTree(left, right) =>
@@ -1238,8 +1206,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) =>
@@ -1266,8 +1232,6 @@ object Trees {
             x
           case SingletonTypeTree(ref) =>
             this(x, ref)
-          case SelectFromTypeTree(qualifier, name) =>
-            this(x, qualifier)
           case AndTypeTree(left, right) =>
             this(this(x, left), right)
           case OrTypeTree(left, right) =>
@@ -1343,7 +1307,6 @@ object Trees {
         case tree: DefDef => cpy.DefDef(tree)(name = newName.asTermName)
         case tree: untpd.PolyTypeDef => untpd.cpy.PolyTypeDef(tree)(newName.asTypeName, tree.tparams, tree.rhs).withMods(tree.rawMods)
         case tree: TypeDef => cpy.TypeDef(tree)(name = newName.asTypeName)
-        case tree: SelectFromTypeTree => cpy.SelectFromTypeTree(tree)(tree.qualifier, newName)
       }
     }.asInstanceOf[tree.ThisTree[T]]
   }
diff --git a/src/dotty/tools/dotc/ast/tpd.scala b/src/dotty/tools/dotc/ast/tpd.scala
index 022671540366..31a9c6975ea8 100644
--- a/src/dotty/tools/dotc/ast/tpd.scala
+++ b/src/dotty/tools/dotc/ast/tpd.scala
@@ -30,11 +30,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def Select(qualifier: Tree, name: Name)(implicit ctx: Context): Select =
     ta.assignType(untpd.Select(qualifier, name), qualifier)
 
-  def SelectFromTypeTree(qualifier: Tree, name: Name)(implicit ctx: Context): SelectFromTypeTree =
-    ta.assignType(untpd.SelectFromTypeTree(qualifier, name), qualifier)
-
-  def SelectFromTypeTree(qualifier: Tree, tp: NamedType)(implicit ctx: Context): SelectFromTypeTree =
-    untpd.SelectFromTypeTree(qualifier, tp.name).withType(tp)
+  def Select(qualifier: Tree, tp: NamedType)(implicit ctx: Context): Select =
+    untpd.Select(qualifier, tp.name).withType(tp)
 
   def This(cls: ClassSymbol)(implicit ctx: Context): This =
     untpd.This(cls.name).withType(cls.thisType)
@@ -59,9 +56,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)
 
@@ -336,7 +330,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       Ident(tp)
     else tp.prefix match {
       case pre: SingletonType => followOuterLinks(singleton(pre)).select(tp)
-      case pre => SelectFromTypeTree(TypeTree(pre), tp)
+      case pre => Select(TypeTree(pre), tp)
     } // no checks necessary
 
   def ref(sym: Symbol)(implicit ctx: Context): Tree =
@@ -493,14 +487,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 092cb95c09e7..d6af6ecd016c 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)
@@ -155,7 +154,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def TypeTree(original: Tree): TypeTree = new TypeTree(original)
   def TypeTree() = new TypeTree(EmptyTree)
   def SingletonTypeTree(ref: Tree): SingletonTypeTree = new SingletonTypeTree(ref)
-  def SelectFromTypeTree(qualifier: Tree, name: Name): SelectFromTypeTree = new SelectFromTypeTree(qualifier, name)
   def AndTypeTree(left: Tree, right: Tree): AndTypeTree = new AndTypeTree(left, right)
   def OrTypeTree(left: Tree, right: Tree): OrTypeTree = new OrTypeTree(left, right)
   def RefinedTypeTree(tpt: Tree, refinements: List[Tree]): RefinedTypeTree = new RefinedTypeTree(tpt, refinements)
diff --git a/src/dotty/tools/dotc/core/tasty/TastyFormat.scala b/src/dotty/tools/dotc/core/tasty/TastyFormat.scala
index 394d8f11af04..e9de68e7fb55 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 be3999533fb8..e5cacfc00824 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 31247c00502a..f7363e72bba7 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 371d20e60b00..d278fdef1fff 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)
@@ -1194,7 +1194,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
       case SELECTFROMTYPEtree =>
         val qualifier = readTreeRef()
         val selector = readTypeNameRef()
-        SelectFromTypeTree(qualifier, symbol.namedType)
+        Select(qualifier, symbol.namedType)
 
       case COMPOUNDTYPEtree =>
         readTemplateRef()
diff --git a/src/dotty/tools/dotc/parsing/JavaParsers.scala b/src/dotty/tools/dotc/parsing/JavaParsers.scala
index 4c549039d222..ed7cf9e3f9cd 100644
--- a/src/dotty/tools/dotc/parsing/JavaParsers.scala
+++ b/src/dotty/tools/dotc/parsing/JavaParsers.scala
@@ -227,7 +227,7 @@ object JavaParsers {
     def convertToTypeId(tree: Tree): Tree = convertToTypeName(tree) match {
       case Some(t)  => t withPos tree.pos
       case _        => tree match {
-        case AppliedTypeTree(_, _) | SelectFromTypeTree(_, _) =>
+        case AppliedTypeTree(_, _) | Select(_, _) =>
           tree
         case _ =>
           syntaxError("identifier expected", tree.pos)
@@ -281,14 +281,11 @@ object JavaParsers {
         if (in.token == FINAL) in.nextToken()
         if (in.token == IDENTIFIER) {
           var t = typeArgs(atPos(in.offset)(Ident(ident())))
-          // typeSelect generates Select nodes is the lhs is an Ident or Select,
-          // SelectFromTypeTree otherwise. See #3567.
-          // Select nodes can be later
-          // converted in the typechecker to SelectFromTypeTree if the class
-          // turns out to be an instance ionner class instead of a static inner class.
+          // typeSelect generates Select nodes if the lhs is an Ident or Select,
+          // For other nodes it always assumes that the selected item is a type.
           def typeSelect(t: Tree, name: Name) = t match {
             case Ident(_) | Select(_, _) => Select(t, name)
-            case _ => SelectFromTypeTree(t, name.toTypeName)
+            case _ => Select(t, name.toTypeName)
           }
           while (in.token == DOT) {
             in.nextToken()
diff --git a/src/dotty/tools/dotc/parsing/Parsers.scala b/src/dotty/tools/dotc/parsing/Parsers.scala
index c41515814ef3..86330f3abc1a 100644
--- a/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -614,7 +614,7 @@ object Parsers {
       val interpolator = in.name
       in.nextToken()
       while (in.token == STRINGPART) {
-        segmentBuf += Thicket(List(
+        segmentBuf += Thicket(
             literal(),
             atPos(in.offset) {
               if (in.token == IDENTIFIER)
@@ -630,7 +630,7 @@ object Parsers {
                 syntaxErrorOrIncomplete("error in interpolated string: identifier or block expected")
                 EmptyTree
               }
-            }))
+            })
       }
       if (in.token == STRINGLIT) segmentBuf += literal()
       InterpolatedString(interpolator, segmentBuf.toList)
@@ -795,7 +795,7 @@ object Parsers {
     private def typeProjection(t: Tree): Tree = {
       accept(HASH)
       val id = typeIdent()
-      atPos(t.pos.start, id.pos.start) { SelectFromTypeTree(t, id.name) }
+      atPos(t.pos.start, id.pos.start) { Select(t, id.name) }
     }
 
     /** NamedTypeArg      ::=  id `=' Type
@@ -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 32d152c2ed74..1125f5f01f0a 100644
--- a/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -281,7 +281,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           case _ => toText(name)
         }
       case tree @ Select(qual, name) =>
-        toTextLocal(qual) ~ ("." ~ nameIdText(tree) provided name != nme.CONSTRUCTOR)
+        if (qual.isType) toTextLocal(qual) ~ "#" ~ toText(name)
+        else toTextLocal(qual) ~ ("." ~ nameIdText(tree) provided name != nme.CONSTRUCTOR)
       case tree: This =>
         optDotPrefix(tree) ~ "this" ~ idText(tree)
       case Super(qual: This, mix) =>
@@ -311,8 +312,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) =>
@@ -351,8 +350,6 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         if (tree.hasType) toText(tree.typeOpt) else toText(orig)
       case SingletonTypeTree(ref) =>
         toTextLocal(ref) ~ ".type"
-      case SelectFromTypeTree(qual, name) =>
-        toTextLocal(qual) ~ "#" ~ toText(name)
       case AndTypeTree(l, r) =>
         changePrec(AndPrec) { toText(l) ~ " & " ~ toText(r) }
       case OrTypeTree(l, r) =>
@@ -416,7 +413,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 026a518cedc0..a36b47aa8e64 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/Erasure.scala b/src/dotty/tools/dotc/transform/Erasure.scala
index 24dea5118e7d..a503d55e5af7 100644
--- a/src/dotty/tools/dotc/transform/Erasure.scala
+++ b/src/dotty/tools/dotc/transform/Erasure.scala
@@ -388,9 +388,6 @@ object Erasure extends TypeTestsCasts{
       recur(typed(tree.qualifier, AnySelectionProto))
     }
 
-    override def typedSelectFromTypeTree(tree: untpd.SelectFromTypeTree, pt: Type)(implicit ctx: Context) =
-      untpd.Ident(tree.name).withPos(tree.pos).withType(erasedType(tree))
-
     override def typedThis(tree: untpd.This)(implicit ctx: Context): Tree =
       if (tree.symbol == ctx.owner.enclosingClass || tree.symbol.isStaticOwner) promote(tree)
       else {
diff --git a/src/dotty/tools/dotc/transform/LazyVals.scala b/src/dotty/tools/dotc/transform/LazyVals.scala
index 504f9250b003..424bc4f8eb68 100644
--- a/src/dotty/tools/dotc/transform/LazyVals.scala
+++ b/src/dotty/tools/dotc/transform/LazyVals.scala
@@ -220,14 +220,14 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
         val containerTree = ValDef(containerSymbol, defaultValue(tpe))
         if (x.tpe.isNotNull && tpe <:< defn.ObjectType) { // can use 'null' value instead of flag
           val slowPath = DefDef(x.symbol.asTerm, mkDefNonThreadSafeNonNullable(containerSymbol, x.rhs))
-          Thicket(List(containerTree, slowPath))
+          Thicket(containerTree, slowPath)
         }
         else {
           val flagName = ctx.freshName(x.name ++ StdNames.nme.BITMAP_PREFIX).toTermName
           val flagSymbol = ctx.newSymbol(x.symbol.owner, flagName,  containerFlags | Flags.Private, defn.BooleanType).enteredAfter(this)
           val flag = ValDef(flagSymbol, Literal(Constants.Constant(false)))
           val slowPath = DefDef(x.symbol.asTerm, mkNonThreadSafeDef(ref(containerSymbol), ref(flagSymbol), x.rhs))
-          Thicket(List(containerTree, flag, slowPath))
+          Thicket(containerTree, flag, slowPath)
         }
     }
 
@@ -390,8 +390,8 @@ class LazyVals extends MiniPhaseTransform with IdentityDenotTransformer {
 
         val accessor = mkThreadSafeDef(x.symbol.asTerm, claz, ord, containerSymbol, x.rhs, tpe, offset, getFlag, state, cas, setFlag, wait)
         if (flag eq EmptyTree)
-          Thicket(List(containerTree, accessor))
-        else Thicket(List(containerTree, flag, accessor))
+          Thicket(containerTree, accessor)
+        else Thicket(containerTree, flag, accessor)
     }
 }
 
diff --git a/src/dotty/tools/dotc/transform/TreeChecker.scala b/src/dotty/tools/dotc/transform/TreeChecker.scala
index 9d6445dc9c9f..7cd1267b81b7 100644
--- a/src/dotty/tools/dotc/transform/TreeChecker.scala
+++ b/src/dotty/tools/dotc/transform/TreeChecker.scala
@@ -200,7 +200,6 @@ class TreeChecker extends Phase with SymTransformer {
     def checkIdentNotJavaClass(tree: Tree)(implicit ctx: Context): Unit = tree match {
       // case tree: untpd.Ident =>
       // case tree: untpd.Select =>
-      // case tree: untpd.SelectFromTypeTree =>
       // case tree: untpd.Bind =>
       case vd : ValDef =>
         assertIdentNotJavaClass(vd.forceIfLazy)
@@ -213,9 +212,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 89ae927b78d6..05961508a148 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
@@ -83,7 +82,6 @@ object TreeTransforms {
     def prepareForTry(tree: Try)(implicit ctx: Context) = this
     def prepareForSeqLiteral(tree: SeqLiteral)(implicit ctx: Context) = this
     def prepareForTypeTree(tree: TypeTree)(implicit ctx: Context) = this
-    def prepareForSelectFromTypeTree(tree: SelectFromTypeTree)(implicit ctx: Context) = this
     def prepareForBind(tree: Bind)(implicit ctx: Context) = this
     def prepareForAlternative(tree: Alternative)(implicit ctx: Context) = this
     def prepareForTypeDef(tree: TypeDef)(implicit ctx: Context) = this
@@ -104,7 +102,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
@@ -116,7 +113,6 @@ object TreeTransforms {
     def transformTry(tree: Try)(implicit ctx: Context, info: TransformerInfo): Tree = tree
     def transformSeqLiteral(tree: SeqLiteral)(implicit ctx: Context, info: TransformerInfo): Tree = tree
     def transformTypeTree(tree: TypeTree)(implicit ctx: Context, info: TransformerInfo): Tree = tree
-    def transformSelectFromTypeTree(tree: SelectFromTypeTree)(implicit ctx: Context, info: TransformerInfo): Tree = tree
     def transformBind(tree: Bind)(implicit ctx: Context, info: TransformerInfo): Tree = tree
     def transformAlternative(tree: Alternative)(implicit ctx: Context, info: TransformerInfo): Tree = tree
     def transformUnApply(tree: UnApply)(implicit ctx: Context, info: TransformerInfo): Tree = tree
@@ -267,7 +263,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")
@@ -279,7 +274,6 @@ object TreeTransforms {
       nxPrepTry = index(transformations, "prepareForTry")
       nxPrepSeqLiteral = index(transformations, "prepareForSeqLiteral")
       nxPrepTypeTree = index(transformations, "prepareForTypeTree")
-      nxPrepSelectFromTypeTree = index(transformations, "prepareForSelectFromTypeTree")
       nxPrepBind = index(transformations, "prepareForBind")
       nxPrepAlternative = index(transformations, "prepareForAlternative")
       nxPrepUnApply = index(transformations, "prepareForUnApply")
@@ -299,7 +293,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")
@@ -311,7 +304,6 @@ object TreeTransforms {
       nxTransTry = index(transformations, "transformTry")
       nxTransSeqLiteral = index(transformations, "transformSeqLiteral")
       nxTransTypeTree = index(transformations, "transformTypeTree")
-      nxTransSelectFromTypeTree = index(transformations, "transformSelectFromTypeTree")
       nxTransBind = index(transformations, "transformBind")
       nxTransAlternative = index(transformations, "transformAlternative")
       nxTransUnApply = index(transformations, "transformUnApply")
@@ -341,7 +333,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)
@@ -353,7 +344,6 @@ object TreeTransforms {
       nxPrepTry = indexUpdate(prev.nxPrepTry, changedTransformationClass, transformationIndex, "prepareForTry", copy)
       nxPrepSeqLiteral = indexUpdate(prev.nxPrepSeqLiteral, changedTransformationClass, transformationIndex, "prepareForSeqLiteral", copy)
       nxPrepTypeTree = indexUpdate(prev.nxPrepTypeTree, changedTransformationClass, transformationIndex, "prepareForTypeTree", copy)
-      nxPrepSelectFromTypeTree = indexUpdate(prev.nxPrepSelectFromTypeTree, changedTransformationClass, transformationIndex, "prepareForSelectFromTypeTree", copy)
       nxPrepBind = indexUpdate(prev.nxPrepBind, changedTransformationClass, transformationIndex, "prepareForBind", copy)
       nxPrepAlternative = indexUpdate(prev.nxPrepAlternative, changedTransformationClass, transformationIndex, "prepareForAlternative", copy)
       nxPrepUnApply = indexUpdate(prev.nxPrepUnApply, changedTransformationClass, transformationIndex, "prepareForUnApply", copy)
@@ -372,7 +362,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)
@@ -384,7 +373,6 @@ object TreeTransforms {
       nxTransTry = indexUpdate(prev.nxTransTry, changedTransformationClass, transformationIndex, "transformTry", copy)
       nxTransSeqLiteral = indexUpdate(prev.nxTransSeqLiteral, changedTransformationClass, transformationIndex, "transformSeqLiteral", copy)
       nxTransTypeTree = indexUpdate(prev.nxTransTypeTree, changedTransformationClass, transformationIndex, "transformTypeTree", copy)
-      nxTransSelectFromTypeTree = indexUpdate(prev.nxTransSelectFromTypeTree, changedTransformationClass, transformationIndex, "transformSelectFromTypeTree", copy)
       nxTransBind = indexUpdate(prev.nxTransBind, changedTransformationClass, transformationIndex, "transformBind", copy)
       nxTransAlternative = indexUpdate(prev.nxTransAlternative, changedTransformationClass, transformationIndex, "transformAlternative", copy)
       nxTransUnApply = indexUpdate(prev.nxTransUnApply, changedTransformationClass, transformationIndex, "transformUnApply", copy)
@@ -409,7 +397,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] = _
@@ -421,7 +408,6 @@ object TreeTransforms {
     var nxPrepTry: Array[Int] = _
     var nxPrepSeqLiteral: Array[Int] = _
     var nxPrepTypeTree: Array[Int] = _
-    var nxPrepSelectFromTypeTree: Array[Int] = _
     var nxPrepBind: Array[Int] = _
     var nxPrepAlternative: Array[Int] = _
     var nxPrepUnApply: Array[Int] = _
@@ -441,7 +427,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] = _
@@ -453,7 +438,6 @@ object TreeTransforms {
     var nxTransTry: Array[Int] = _
     var nxTransSeqLiteral: Array[Int] = _
     var nxTransTypeTree: Array[Int] = _
-    var nxTransSelectFromTypeTree: Array[Int] = _
     var nxTransBind: Array[Int] = _
     var nxTransAlternative: Array[Int] = _
     var nxTransUnApply: Array[Int] = _
@@ -520,7 +504,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)
@@ -533,7 +516,6 @@ object TreeTransforms {
     val prepForTry: Mutator[Try] = (trans, tree, ctx) => trans.prepareForTry(tree)(ctx)
     val prepForSeqLiteral: Mutator[SeqLiteral] = (trans, tree, ctx) => trans.prepareForSeqLiteral(tree)(ctx)
     val prepForTypeTree: Mutator[TypeTree] = (trans, tree, ctx) => trans.prepareForTypeTree(tree)(ctx)
-    val prepForSelectFromTypeTree: Mutator[SelectFromTypeTree] = (trans, tree, ctx) => trans.prepareForSelectFromTypeTree(tree)(ctx)
     val prepForBind: Mutator[Bind] = (trans, tree, ctx) => trans.prepareForBind(tree)(ctx)
     val prepForAlternative: Mutator[Alternative] = (trans, tree, ctx) => trans.prepareForAlternative(tree)(ctx)
     val prepForUnApply: Mutator[UnApply] = (trans, tree, ctx) => trans.prepareForUnApply(tree)(ctx)
@@ -637,17 +619,6 @@ object TreeTransforms {
       } else tree
     }
 
-    @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) {
@@ -780,17 +751,6 @@ object TreeTransforms {
       } else tree
     }
 
-    @tailrec
-    final private[TreeTransforms] def goSelectFromTypeTree(tree: SelectFromTypeTree, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = {
-      if (cur < info.transformers.length) {
-        val trans = info.transformers(cur)
-        trans.transformSelectFromTypeTree(tree)(ctx.withPhase(trans.treeTransformPhase), info) match {
-          case t: SelectFromTypeTree => goSelectFromTypeTree(t, info.nx.nxTransSelectFromTypeTree(cur + 1))
-          case t => transformSingle(t, cur + 1)
-        }
-      } else tree
-    }
-
     @tailrec
     final private[TreeTransforms] def goBind(tree: Bind, cur: Int)(implicit ctx: Context, info: TransformerInfo): Tree = {
       if (cur < info.transformers.length) {
@@ -900,8 +860,6 @@ object TreeTransforms {
       tree match {
         case tree: Ident => goIdent(tree, info.nx.nxTransIdent(cur))
         case tree: Select => goSelect(tree, info.nx.nxTransSelect(cur))
-        case tree: SelectFromTypeTree =>
-          goSelectFromTypeTree(tree, info.nx.nxTransSelectFromTypeTree(cur))
         case tree: Bind => goBind(tree, cur)
         case tree: ValDef if !tree.isEmpty => goValDef(tree, info.nx.nxTransValDef(cur))
         case tree: DefDef => goDefDef(tree, info.nx.nxTransDefDef(cur))
@@ -917,7 +875,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))
@@ -967,13 +924,6 @@ object TreeTransforms {
             val qual = transform(tree.qualifier, mutatedInfo, cur)
             goSelect(cpy.Select(tree)(qual, tree.name), mutatedInfo.nx.nxTransSelect(cur))
           }
-        case tree: SelectFromTypeTree =>
-          implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForSelectFromTypeTree, info.nx.nxPrepSelectFromTypeTree, tree, cur)
-          if (mutatedInfo eq null) tree
-          else {
-            val qual = transform(tree.qualifier, mutatedInfo, cur)
-            goSelectFromTypeTree(cpy.SelectFromTypeTree(tree)(qual, tree.name), mutatedInfo.nx.nxTransSelectFromTypeTree(cur))
-          }
         case tree: Bind =>
           implicit val mutatedInfo: TransformerInfo = mutateTransformers(info, prepForBind, info.nx.nxPrepBind, tree, cur)
           if (mutatedInfo eq null) tree
@@ -1052,14 +1002,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/Checking.scala b/src/dotty/tools/dotc/typer/Checking.scala
index 2db6d497e78f..415cd5d6a55e 100644
--- a/src/dotty/tools/dotc/typer/Checking.scala
+++ b/src/dotty/tools/dotc/typer/Checking.scala
@@ -99,8 +99,6 @@ object Checking {
           checkValidIfHKApply(ctx.addMode(Mode.AllowLambdaWildcardApply))
         case Select(qual, name) if name.isTypeName =>
           checkRealizable(qual.tpe, qual.pos)
-        case SelectFromTypeTree(qual, name) if name.isTypeName =>
-          checkRealizable(qual.tpe, qual.pos)
         case SingletonTypeTree(ref) =>
           checkRealizable(ref.tpe, ref.pos)
         case _ =>
diff --git a/src/dotty/tools/dotc/typer/ImportInfo.scala b/src/dotty/tools/dotc/typer/ImportInfo.scala
index 2105d9ccc9de..3aa2891812e4 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/ReTyper.scala b/src/dotty/tools/dotc/typer/ReTyper.scala
index a4f92271ae1a..9750957bf8e6 100644
--- a/src/dotty/tools/dotc/typer/ReTyper.scala
+++ b/src/dotty/tools/dotc/typer/ReTyper.scala
@@ -38,12 +38,6 @@ class ReTyper extends Typer {
     untpd.cpy.Select(tree)(qual1, tree.name).withType(tree.typeOpt)
   }
 
-  override def typedSelectFromTypeTree(tree: untpd.SelectFromTypeTree, pt: Type)(implicit ctx: Context): Tree = {
-    assert(tree.hasType)
-    val qual1 = typed(tree.qualifier, AnySelectionProto)
-    untpd.cpy.SelectFromTypeTree(tree)(qual1, tree.name).withType(tree.typeOpt)
-  }
-
   override def typedLiteral(tree: untpd.Literal)(implicit ctc: Context): Literal =
     promote(tree)
 
diff --git a/src/dotty/tools/dotc/typer/TypeAssigner.scala b/src/dotty/tools/dotc/typer/TypeAssigner.scala
index 740fa26589cd..ba8f35cd8ae5 100644
--- a/src/dotty/tools/dotc/typer/TypeAssigner.scala
+++ b/src/dotty/tools/dotc/typer/TypeAssigner.scala
@@ -263,9 +263,6 @@ trait TypeAssigner {
     tree.withType(tp)
   }
 
-  def assignType(tree: untpd.SelectFromTypeTree, qual: Tree)(implicit ctx: Context) =
-    tree.withType(accessibleSelectionType(tree, qual))
-
   def assignType(tree: untpd.New, tpt: Tree)(implicit ctx: Context) =
     tree.withType(tpt.tpe)
 
@@ -376,9 +373,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 af09a8283bf5..562af75f6e2a 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
         }
@@ -359,52 +363,42 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     else tree
 
   def typedSelect(tree: untpd.Select, pt: Type)(implicit ctx: Context): Tree = track("typedSelect") {
-    def asSelect(implicit ctx: Context): Tree = {
+    def typeSelectOnTerm(implicit ctx: Context): Tree = {
       val qual1 = typedExpr(tree.qualifier, selectionProto(tree.name, pt, this))
       if (tree.name.isTypeName) checkStable(qual1.tpe, qual1.pos)
       val select = typedSelect(tree, pt, qual1)
       if (select.tpe ne TryDynamicCallType) select
       else if (pt.isInstanceOf[PolyProto] || pt.isInstanceOf[FunProto] || pt == AssignProto) select
       else typedDynamicSelect(tree, Nil, pt)
-   }
-
-    def asJavaSelectFromTypeTree(implicit ctx: Context): Tree = {
-      // Translate names in Select/Ident nodes to type names.
-      def convertToTypeName(tree: untpd.Tree): Option[untpd.Tree] = tree match {
-        case Select(qual, name) => Some(untpd.Select(qual, name.toTypeName))
-        case Ident(name)        => Some(untpd.Ident(name.toTypeName))
-        case _                  => None
-      }
+    }
 
-      // Try to convert Select(qual, name) to a SelectFromTypeTree.
-      def convertToSelectFromType(qual: untpd.Tree, origName: Name): Option[untpd.SelectFromTypeTree] =
-        convertToTypeName(qual) match {
-          case Some(qual1)  => Some(untpd.SelectFromTypeTree(qual1 withPos qual.pos, origName.toTypeName))
-          case _            => None
-        }
+    def typeSelectOnType(qual: untpd.Tree)(implicit ctx: Context) =
+      typedSelect(untpd.cpy.Select(tree)(qual, tree.name.toTypeName), pt)
 
-      convertToSelectFromType(tree.qualifier, tree.name) match {
-        case Some(sftt) => typedSelectFromTypeTree(sftt, pt)
-        case _ => ctx.error(em"Could not convert $tree to a SelectFromTypeTree"); EmptyTree
-      }
+    def tryJavaSelectOnType(implicit ctx: Context): Tree = tree.qualifier match {
+      case Select(qual, name) => typeSelectOnType(untpd.Select(qual, name.toTypeName))
+      case Ident(name)        => typeSelectOnType(untpd.Ident(name.toTypeName))
+      case _                  => errorTree(tree, "cannot convert to type selection") // will never be printed due to fallback
     }
 
-    def selectWithFallback(fallBack: => Tree) =
-      tryEither(tryCtx => asSelect(tryCtx))((_, _) => fallBack)
+    def selectWithFallback(fallBack: Context => Tree) =
+      tryAlternatively(typeSelectOnTerm(_))(fallBack)
 
-    if (ctx.compilationUnit.isJava && tree.name.isTypeName)
+    if (tree.qualifier.isType) {
+      val qual1 = typedType(tree.qualifier, selectionProto(tree.name, pt, this))
+      assignType(cpy.Select(tree)(qual1, tree.name), qual1)
+    }
+    else if (ctx.compilationUnit.isJava && tree.name.isTypeName)
       // SI-3120 Java uses the same syntax, A.B, to express selection from the
       // value A and from the type A. We have to try both.
-      selectWithFallback(asJavaSelectFromTypeTree(ctx))
+      selectWithFallback(tryJavaSelectOnType(_)) // !!! possibly exponential bcs of qualifier retyping
     else if (tree.name == nme.withFilter && tree.getAttachment(desugar.MaybeFilter).isDefined)
-      selectWithFallback(typedSelect(untpd.cpy.Select(tree)(tree.qualifier, nme.filter), pt))
+      selectWithFallback {
+        implicit ctx =>
+          typedSelect(untpd.cpy.Select(tree)(tree.qualifier, nme.filter), pt) // !!! possibly exponential bcs of qualifier retyping
+      }
     else
-      asSelect(ctx)
-  }
-
-  def typedSelectFromTypeTree(tree: untpd.SelectFromTypeTree, pt: Type)(implicit ctx: Context): Tree = track("typedSelectFromTypeTree") {
-    val qual1 = typedType(tree.qualifier, selectionProto(tree.name, pt, this))
-    assignType(cpy.SelectFromTypeTree(tree)(qual1, tree.name), qual1)
+      typeSelectOnTerm(ctx)
   }
 
   def typedThis(tree: untpd.This)(implicit ctx: Context): Tree = track("typedThis") {
@@ -448,16 +442,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)
@@ -1399,7 +1383,6 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
           tree match {
             case tree: untpd.Ident => typedIdent(tree, pt)
             case tree: untpd.Select => typedSelect(tree, pt)
-            case tree: untpd.SelectFromTypeTree => typedSelectFromTypeTree(tree, pt)
             case tree: untpd.Bind => typedBind(tree, pt)
             case tree: untpd.ValDef =>
               if (tree.isEmpty) tpd.EmptyValDef
@@ -1422,7 +1405,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)
@@ -1523,6 +1505,17 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     }
   }
 
+  /** Try `op1`, if there are errors, try `op2`, if `op2` also causes errors, fall back
+   *  to errors and result of `op1`.
+   */
+  def tryAlternatively[T](op1: Context => T)(op2: Context => T)(implicit ctx: Context): T =
+    tryEither(op1) { (failedVal, failedState) =>
+      tryEither(op2) { (_, _) =>
+        failedState.commit
+        failedVal
+      }
+    }
+
   /** Add apply node or implicit conversions. Two strategies are tried, and the first
    *  that is successful is picked. If neither of the strategies are successful, continues with
    *  `fallBack`.