Fix derivedSelect in avoid

Test case in i2945.scala.

Author: odersky

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -3895,14 +3895,14 @@ object Types {
       case _ => tp
     }
 
-    /** Derived selection.
-     *  @pre   the (upper bound of) prefix `pre` has a member named `tp.name`.
+    /** Try to widen a named type to its info relative to given prefix `pre`, where possible.
+     *  The possible cases are listed inline in the code. Return `default` if no widening is
+     *  possible.
      */
-    override protected def derivedSelect(tp: NamedType, pre: Type) =
-      if (pre eq tp.prefix) tp
-      else pre match {
-        case Range(preLo, preHi) =>
-          preHi.member(tp.name).info.widenExpr match {
+    def tryWiden(tp: NamedType, pre: Type)(default: => Type): Type =
+      pre.member(tp.name) match {
+        case d: SingleDenotation =>
+          d.info match {
             case TypeAlias(alias) =>
               // if H#T = U, then for any x in L..H, x.T =:= U,
               // hence we can replace with U under all variances
@@ -3916,9 +3916,21 @@ object Types {
               // hence we can replace with y.type under all variances
               reapply(info)
             case _ =>
-              range(tp.derivedSelect(preLo), tp.derivedSelect(preHi))
+              default
           }
-        case _ => tp.derivedSelect(pre)
+        case _ => default
+      }
+
+    /** Derived selection.
+     *  @pre   the (upper bound of) prefix `pre` has a member named `tp.name`.
+     */
+    override protected def derivedSelect(tp: NamedType, pre: Type) =
+      if (pre eq tp.prefix) tp
+      else pre match {
+        case Range(preLo, preHi) =>
+          tryWiden(tp, preHi)(range(tp.derivedSelect(preLo), tp.derivedSelect(preHi)))
+        case _ =>
+          tp.derivedSelect(pre)
       }
 
     override protected def derivedRefinedType(tp: RefinedType, parent: Type, info: Type) =

compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala

@@ -108,18 +108,26 @@ trait TypeAssigner {
           mapOver(tp)
       }
 
-      /** Two deviations from standard derivedSelect:
-       *   1. The teh approximation result is a singleton references C#x.type, we
+      /** Three deviations from standard derivedSelect:
+       *   1. We first try a widening conversion to the type's info with
+       *      the original prefix. Since the original prefix is known to
+       *      be a subtype of the returned prefix, this can improve results.
+       *   2. IThen, if the approximation result is a singleton reference C#x.type, we
        *      replace by the widened type, which is usually more natural.
-       *   2. We need to handle the case where the prefix type does not have a member
-       *      named `tp.name` anymmore.
+       *   3. Finally, we need to handle the case where the prefix type does not have a member
+       *      named `tp.name` anymmore. In that case, we need to fall back to Bot..Top.
        */
       override def derivedSelect(tp: NamedType, pre: Type) =
-        if (pre eq tp.prefix) tp
-        else if (tp.isTerm && variance > 0 && !pre.isInstanceOf[SingletonType])
-          apply(tp.info.widenExpr)
-        else if (upper(pre).member(tp.name).exists) super.derivedSelect(tp, pre)
-        else range(tp.bottomType, tp.topType)
+        if (pre eq tp.prefix)
+          tp
+        else tryWiden(tp, tp.prefix) {
+          if (tp.isTerm && variance > 0 && !pre.isInstanceOf[SingletonType])
+          	apply(tp.info.widenExpr)
+          else if (upper(pre).member(tp.name).exists)
+            super.derivedSelect(tp, pre)
+          else
+            range(tp.bottomType, tp.topType)
+        }
     }
 
     widenMap(tp)

tests/pos/i2945.scala

@@ -0,0 +1,13 @@
+object Test {
+  def test = {
+    object Hi {
+      type A = Int
+    }
+
+    val x: Hi.A = 1
+
+    List(x)
+  }
+
+  val hi: List[Int] = test // Used to fail because `test` had type `List[Any]` instead of `List[Int]`
+}