problems existentially quantifying prefix of a module type

[scabug]

https://groups.google.com/forum/#!topic/scala-language/qqbDyxaU24E

'm struggling to explain that behaviour, though: 

$ scala 
Welcome to Scala version 2.10.0-20121205-235900-18481cef9b (OpenJDK 
64-Bit Server VM, Java 1.7.0_09). 
Type in expressions to have them evaluated. 
Type :help for more information. 

scala> class X { object Y } 
defined class X 

scala> val x = new X 
x: X = X@4c769a3 

scala> type XY = x.Y.type forSome { val x: X } 
warning: there were 2 feature warnings; re-run with -feature for details 
defined type alias XY 

scala> val y1 = x.Y 
y1: x.Y.type = X$Y$@14eee870 

scala> val y2: XY = x.Y 
y2: XY = X$Y$@14eee870 

scala> val y2: (x.Y.type forSome { val x: X }) = x.Y 
<console>:9: error: type mismatch; 
 found   : x.Y.type 
 required: x.Y.type forSome { val x: => X } 
       val y2: (x.Y.type forSome { val x: X }) = x.Y 
                                                   ^ 

[scabug]

Imported From: https://issues.scala-lang.org/browse/SI-8419?orig=1
Reporter: @retronym
Affected Versions: 2.10.3

[scabug]

@retronym said (edited on Mar 16, 2014 11:47:39 AM UTC):
Another example from the mailing lists (https://groups.google.com/d/msg/scala-user/izL9tkKrj-c/a-V92vTdLRoJ):

class Outer {
  type W = Int
  object Inner {
    val x = scala.util.Random.nextInt(100)
  }
  def foo1(t: Outer) : outer.Inner.type forSome { val outer: Outer } = if (t.Inner.x < Inner.x) t.Inner else Inner
  def foo2(t: Outer) : W = if (t.Inner.x < Inner.x) t.Inner.x else Inner.x
  def foo3(t: Outer) : Inner.type = Inner
  
  val ox : Outer#W = 3
}

qbin/scalac -explaintypes sandbox/test1.scala
sandbox/test1.scala:6: error: type mismatch;
 found   : Outer#Inner.type
 required: outer.Inner.type( forSome { val outer: Outer })
  def foo1(t: Outer) : outer.Inner.type forSome { val outer: Outer } = if (t.Inner.x < Inner.x) t.Inner else Inner
                                                                       ^
Outer#Inner.type <: outer.Inner.type( forSome { val outer: Outer })?
  Outer = ?0outer.type?
  true
  Nothing <: Outer?
  true
  Outer <: Outer with Singleton?
  false
false
one error found

[scabug]

@retronym said:
While debugging this, I noted this suspect code:

  class SubstWildcardMap(from: List[Symbol]) extends TypeMap {
    def apply(tp: Type): Type = try {
      tp match {
        case TypeRef(_, sym, _) if from contains sym =>
          BoundedWildcardType(sym.info.bounds)
        ...

Why is it okay to discard the prefix and type arguments? Shouldn't they be used to calculate the bounds?

[scabug]

@retronym said:
That type map is used when widening the expected type

pt.dealias = outer.Inner.type( forSome { val outer: Outer })
ptWild = ? <: Outer with Singleton#Inner.type( forSome { val outer: Outer })

[scabug]

@retronym said:
Example with more commentary:

class Outer {
  type W = Int
  object Inner {
    val x = scala.util.Random.nextInt(100)
  }
  // okay, infers `Outer#Inner.type`. Internally, that is `ModuleTypeRef(pre = class Outer, sym = Inner)
  // But we can't express that in the source syntax of Scala!
  def foo0(t: Outer) = if (t.Inner.x < Inner.x) t.Inner else Inner

  // okay, we can use an similar existential type instead, but this runs into a bug with
  // existential expected types where the existential is a prefix of a stable selection.
  // we need to explicitly push the expected type into each branch of the `if` to workaround.
  def foo1(t: Outer) : Outer.InnerExistential = if (t.Inner.x < Inner.x) (t.Inner: Outer.InnerExistential) else (Inner: Outer.InnerExistential)

  // fail. the rhs LUBs to `ModuleTypeRef(pre = Outer, sym = Inner)`, the prefix
  // doesn't conform to `Outer with Singleton`.
  // 
  // Note that The existential expected type is widened to
  // `(? <: Outer with Singleton)#Inner.type forSome { val outer: Outer })
  def foo2(t: Outer) : Outer.InnerExistential = if (t.Inner.x < Inner.x) t.Inner else Inner
  
  val ox : Outer#W = 3
}

object Outer {
  type InnerExistential = outer.Inner.type forSome { val outer: Outer }
}