Self type without type ascription introduces type requirements

[bertlebee]

Compiler version

3.2.0

Minimized code

trait X { //missing requirement: self type Z[?] & X of trait X does not conform to self type Z[X.this.A] of required trait Z
  self: Z[?] => 
}

trait Z[A] extends X {
  self => // comment this to compile successfully
}

Output

compiler error:
missing requirement: self type Z[?] & X of trait X does not conform to self type Z[X.this.A]
of required trait Z

Expectation

The code should compile. Having a self type without a type ascription (i.e. just aliasing this) should not introduce any additional type requirements

Related comment from Aly https://discord.com/channels/632150470000902164/632150470000902166/1045191632049405992

[szymon-rd]

Thank you for reporting and reproduction!

[Kordyjan]

I thought it may have been fixed in #16441, but the bug is still reproducible in 3.3.0-RC1-bin-20221206-cfcdefa-NIGHTLY.

[prolativ]

It looks like extends X is not necessary to reproduce the problem:

trait X { //missing requirement: self type Z[?] & X of trait X does not conform to self type Z[X.this.A] of required trait Z
  self: Z[?] =>
}

trait Z[A] {
  self => // comment this to compile successfully
}

gives the same error message

[odersky]

Scala 3 requires that self types are "closed". See #702 that introduced this requirement. Closed means:
If class Z appears in the self type of some trait X then the self type of X must conform to the self type of Z. This example violates the condition. Z appears in the self type of X, but Z[?] does not conform to Z[A].

Going back to 2015, it seems the requirement was introduced to avoid a crash and to get some sanity about self type checking. I don't know whether lifting the requirement would constitute a soundness hold or not. But I believe it's better to be conservative.

Self type checking is only done if a self is declared explicitly. Here a simple name counts, it does not matter whether its type is inferred or not. I looked into it but it seems to be really hard to change this (and Scala 2 behaves the same, it's just that Scala 2 does not have the closedness requirement).

So the one remaining hole is: if closedness checking is really important, we should check classes with missing self types as well. If it is not important we should drop it.