From 2d908c792fcf4287b4cb493f0e51dfbdb106cf69 Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Sun, 25 Sep 2016 12:31:13 +0200
Subject: [PATCH 1/5] 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.
---
 src/dotty/tools/dotc/ast/Desugar.scala        | 35 +++++--------------
 src/dotty/tools/dotc/ast/Trees.scala          | 20 +----------
 src/dotty/tools/dotc/ast/tpd.scala            | 11 ------
 src/dotty/tools/dotc/ast/untpd.scala          |  1 -
 .../tools/dotc/core/tasty/TastyFormat.scala   |  5 ++-
 .../tools/dotc/core/tasty/TreePickler.scala   |  5 +--
 .../tools/dotc/core/tasty/TreeUnpickler.scala |  4 +--
 .../core/unpickleScala2/Scala2Unpickler.scala |  2 +-
 src/dotty/tools/dotc/parsing/Parsers.scala    |  2 +-
 .../tools/dotc/printing/RefinedPrinter.scala  |  4 +--
 .../tools/dotc/sbt/ExtractDependencies.scala  |  2 +-
 .../tools/dotc/transform/TreeChecker.scala    |  3 --
 .../tools/dotc/transform/TreeTransform.scala  | 29 ---------------
 src/dotty/tools/dotc/typer/ImportInfo.scala   |  6 ++--
 src/dotty/tools/dotc/typer/TypeAssigner.scala |  3 --
 src/dotty/tools/dotc/typer/Typer.scala        | 33 +++++++----------
 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 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/Trees.scala b/src/dotty/tools/dotc/ast/Trees.scala
index 5744742b81e9..0f8a63c12c14 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 022671540366..1d23bdfd9873 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 092cb95c09e7..ae444d1236d7 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 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..a667438bec7e 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 c41515814ef3..21a6a232f37a 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 32d152c2ed74..cbe48409c32e 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 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/TreeChecker.scala b/src/dotty/tools/dotc/transform/TreeChecker.scala
index 9d6445dc9c9f..47d2395a0a44 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 89ae927b78d6..f31116629bc3 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)
@@ -637,17 +628,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) {
@@ -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 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/TypeAssigner.scala b/src/dotty/tools/dotc/typer/TypeAssigner.scala
index 740fa26589cd..42302e5ff77a 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 af09a8283bf5..072240248b32 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)

From 80cbe114cc5d641d66512c58402eca4ae69f9f2a Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Sun, 25 Sep 2016 17:04:22 +0200
Subject: [PATCH 2/5] Get rid of SelectFromType tree node.

Roll its functionality into Select. Since we can always
tell whether a tree is a type or term there is no expressiveness
gained by having a separate tree node.
---
 src/dotty/tools/dotc/ast/TreeInfo.scala       |  2 +-
 src/dotty/tools/dotc/ast/Trees.scala          | 21 +-----
 src/dotty/tools/dotc/ast/tpd.scala            |  9 +--
 src/dotty/tools/dotc/ast/untpd.scala          |  1 -
 .../core/unpickleScala2/Scala2Unpickler.scala |  2 +-
 .../tools/dotc/parsing/JavaParsers.scala      |  6 +-
 src/dotty/tools/dotc/parsing/Parsers.scala    |  2 +-
 .../tools/dotc/printing/RefinedPrinter.scala  |  5 +-
 src/dotty/tools/dotc/transform/Erasure.scala  |  3 -
 .../tools/dotc/transform/TreeTransform.scala  | 29 -------
 src/dotty/tools/dotc/typer/Checking.scala     |  2 -
 src/dotty/tools/dotc/typer/ReTyper.scala      |  6 --
 src/dotty/tools/dotc/typer/TypeAssigner.scala |  3 -
 src/dotty/tools/dotc/typer/Typer.scala        | 75 ++++++++++---------
 14 files changed, 51 insertions(+), 115 deletions(-)

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 0f8a63c12c14..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]
@@ -549,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] {
@@ -841,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]
@@ -1000,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))
@@ -1144,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) =>
@@ -1248,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) =>
@@ -1325,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 1d23bdfd9873..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)
@@ -333,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 =
diff --git a/src/dotty/tools/dotc/ast/untpd.scala b/src/dotty/tools/dotc/ast/untpd.scala
index ae444d1236d7..d6af6ecd016c 100644
--- a/src/dotty/tools/dotc/ast/untpd.scala
+++ b/src/dotty/tools/dotc/ast/untpd.scala
@@ -154,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/unpickleScala2/Scala2Unpickler.scala b/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala
index a667438bec7e..d278fdef1fff 100644
--- a/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala
+++ b/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala
@@ -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..a5418340a135 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)
@@ -285,10 +285,10 @@ object JavaParsers {
           // 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.
+          // turns out to be an instance inner class instead of a static inner class.
           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 21a6a232f37a..d43b12684892 100644
--- a/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -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
diff --git a/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index cbe48409c32e..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) =>
@@ -349,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) =>
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/TreeTransform.scala b/src/dotty/tools/dotc/transform/TreeTransform.scala
index f31116629bc3..05961508a148 100644
--- a/src/dotty/tools/dotc/transform/TreeTransform.scala
+++ b/src/dotty/tools/dotc/transform/TreeTransform.scala
@@ -82,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
@@ -114,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
@@ -276,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")
@@ -307,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")
@@ -348,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)
@@ -378,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)
@@ -414,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] = _
@@ -445,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] = _
@@ -524,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)
@@ -760,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) {
@@ -880,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))
@@ -946,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
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/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 42302e5ff77a..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)
 
diff --git a/src/dotty/tools/dotc/typer/Typer.scala b/src/dotty/tools/dotc/typer/Typer.scala
index 072240248b32..2550da793f76 100644
--- a/src/dotty/tools/dotc/typer/Typer.scala
+++ b/src/dotty/tools/dotc/typer/Typer.scala
@@ -363,52 +363,45 @@ 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 = {
-      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
+    def typeAsIs(implicit ctx: Context): Tree = {
+      if (tree.qualifier.isType) {
+        val qual1 = typedType(tree.qualifier, selectionProto(tree.name, pt, this))
+        assignType(cpy.Select(tree)(qual1, tree.name), qual1)
       }
+      else {
+        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)
+      }
+    }
 
-      // 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
-        }
-
-      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 asJavaSelectFromType(implicit ctx: Context): Tree = {
+      def typeSelectOnType(qual: untpd.Tree) =
+        typedSelect(untpd.cpy.Select(tree)(qual, tree.name.toTypeName), pt)
+      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(typeAsIs(_))(fallBack)
 
     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(asJavaSelectFromType(_)) // !!! 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)
+      typeAsIs(ctx)
   }
 
   def typedThis(tree: untpd.This)(implicit ctx: Context): Tree = track("typedThis") {
@@ -1393,7 +1386,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
@@ -1516,6 +1508,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`.

From 9ede23872f1f03576c61a224703b9f0443f614b4 Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Sun, 25 Sep 2016 17:06:41 +0200
Subject: [PATCH 3/5] Get rid of Thicket(List(...)) as an expression

Thicket has a vararg constructor, so this syntax is redundant.
---
 src/dotty/tools/dotc/parsing/Parsers.scala    | 4 ++--
 src/dotty/tools/dotc/transform/LazyVals.scala | 8 ++++----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/dotty/tools/dotc/parsing/Parsers.scala b/src/dotty/tools/dotc/parsing/Parsers.scala
index d43b12684892..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)
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)
     }
 }
 

From bb224fb4feb0f50dd99a80818ee76144e5b874ab Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Sun, 25 Sep 2016 17:34:36 +0200
Subject: [PATCH 4/5] Eliminate SelectFromTypeTree from docs

---
 docs/SyntaxSummary.txt                           | 2 +-
 src/dotty/tools/dotc/parsing/JavaParsers.scala   | 7 ++-----
 src/dotty/tools/dotc/transform/TreeChecker.scala | 1 -
 3 files changed, 3 insertions(+), 7 deletions(-)

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/parsing/JavaParsers.scala b/src/dotty/tools/dotc/parsing/JavaParsers.scala
index a5418340a135..ed7cf9e3f9cd 100644
--- a/src/dotty/tools/dotc/parsing/JavaParsers.scala
+++ b/src/dotty/tools/dotc/parsing/JavaParsers.scala
@@ -281,11 +281,8 @@ 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 inner 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 _ => Select(t, name.toTypeName)
diff --git a/src/dotty/tools/dotc/transform/TreeChecker.scala b/src/dotty/tools/dotc/transform/TreeChecker.scala
index 47d2395a0a44..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)

From d096f004b5e6ad88ec406b4ca0163a9cdd4fcb17 Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Sun, 25 Sep 2016 18:10:52 +0200
Subject: [PATCH 5/5] Simplify typedSelect logic

---
 src/dotty/tools/dotc/typer/Typer.scala | 47 ++++++++++++--------------
 1 file changed, 22 insertions(+), 25 deletions(-)

diff --git a/src/dotty/tools/dotc/typer/Typer.scala b/src/dotty/tools/dotc/typer/Typer.scala
index 2550da793f76..562af75f6e2a 100644
--- a/src/dotty/tools/dotc/typer/Typer.scala
+++ b/src/dotty/tools/dotc/typer/Typer.scala
@@ -363,45 +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 typeAsIs(implicit ctx: Context): Tree = {
-      if (tree.qualifier.isType) {
-        val qual1 = typedType(tree.qualifier, selectionProto(tree.name, pt, this))
-        assignType(cpy.Select(tree)(qual1, tree.name), qual1)
-      }
-      else {
-        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 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 asJavaSelectFromType(implicit ctx: Context): Tree = {
-      def typeSelectOnType(qual: untpd.Tree) =
-        typedSelect(untpd.cpy.Select(tree)(qual, tree.name.toTypeName), pt)
-      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 typeSelectOnType(qual: untpd.Tree)(implicit ctx: Context) =
+      typedSelect(untpd.cpy.Select(tree)(qual, tree.name.toTypeName), pt)
+
+    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: Context => Tree) =
-      tryAlternatively(typeAsIs(_))(fallBack)
+      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(asJavaSelectFromType(_)) // !!! possibly exponential bcs of qualifier retyping
+      selectWithFallback(tryJavaSelectOnType(_)) // !!! possibly exponential bcs of qualifier retyping
     else if (tree.name == nme.withFilter && tree.getAttachment(desugar.MaybeFilter).isDefined)
       selectWithFallback {
         implicit ctx =>
           typedSelect(untpd.cpy.Select(tree)(tree.qualifier, nme.filter), pt) // !!! possibly exponential bcs of qualifier retyping
       }
     else
-      typeAsIs(ctx)
+      typeSelectOnTerm(ctx)
   }
 
   def typedThis(tree: untpd.This)(implicit ctx: Context): Tree = track("typedThis") {