Imported From: https://issues.scala-lang.org/browse/SI-9878?orig=1
Reporter: @Atry
Affected Versions: 2.11.8

@SethTisue said:
would you agree this illustrates the same issue, but with less code?

class W[T <: AnyRef](val f: T) {
  type F = f.type
  type SelfW = W[T] { type F = W.this.F }
  def error(w: SelfW) = w.f: w.F
}

S.scala:4: error: type mismatch;
 found   : w.f.type (with underlying type T)
 required: w.F
    (which expands to)  W.this.f.type
  def error(w: SelfW) = w.f: w.F
                          ^
one error found

@Atry said:
Your example is similar, but less ridiculous.

@SethTisue said:
Well, I think my example isn't a bug, actually – the compiler has no guarantee that the two instances of W share the same f.

Your example is so complicated, I don't know what it is. I think it's unlikely it will get attention unless you can simplify it.

@SethTisue said:
Hmm, now I'm wondering.... are you actually saying your original code should compile, or are you just reporting that the error message is confusing?

The error message is confusing, I'll give you that. But I very much doubt that your code is correct. I think you may have an incorrect idea of what it means to "override" a type in a type alias. Scala will let you write e.g.:

trait A { type T = Int ; def f: T = 3 }
type U = A { type T = String }

but that doesn't mean that in U, you have somehow changed the type of f. The type of f is still Int.

By the same token, in your code you write:

type Self = W { type F = outer.F }

but that doesn't mean that if I have a value w of type Self, def w.selfF is constrained to be outer.F!

@Atry said (edited on Aug 23, 2016 6:17:30 AM UTC):
The type T in your example is a concrete type, while the type Self and F in my original example are abstract types.

Scalac does change the type in expression def f: T so long as T is an abstract type. For example:

Welcome to Scala 2.11.8 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_77).
Type in expressions for evaluation. Or try :help.

scala> trait A { type T; def f: T }
defined trait A

scala> type U = A { type T = String }
defined type alias U

scala> new A { type T = String; def f = "f" }
res0: A{type T = String} = $anon$1@68f7aae2

scala> res0: U
res1: U = $anon$1@68f7aae2

scala> res1.f.substring(0, 1) // res1.f is a String 
res2: String = f

@SethTisue said:
{quote}the type Self and F in my original example are abstract types{quote}

It seems to me that Self is abstract but F is not — F is a type alias. See SLS 4.3.