prefix method call expansion is ruining the dependent method types party

[scabug]

=== What steps will reproduce the problem (please be specific and use wikiformatting)? ===
scalac -Xexperimental Broke.scala

class Broke {

  val tempval = new AnyRef {val roleA = new AnyRef with Bar}.roleA

  new AnyRef {} -: tempval // when not assigning to anything, no problem
  val broke_val = new AnyRef {} -: tempval // type mismatch error only when assigning

  trait Foo[AnyRef] {  }

  trait Bar extends Foo[AnyRef] {
    def -:(core: AnyRef): this.type with Foo[core.type] = throw new Exception()
  }
} 

=== What is the expected behavior? ===
Compiles without error, as it did with 2.7.7 and 2.8.1

=== What do you see instead? ===
Broke.scala:6: error: type mismatch;
found : Broke.this.tempval.type with Broke.this.Foo[x$$2.type(in value broke_val)] where type x$$2.type(in value broke_val) <: java.lang.Object with Singleton
required: Broke.this.tempval.type with Broke.this.Foo[x$$2.type(in value broke_val)] forSome { type x$$2.type(in value broke_val) <: java.lang.Object with Singleton }
val broke_val = new AnyRef {} -: tempval // type mismatch error only when assigning
^
one error found

=== Additional information ===
(for instance, a link to a relevant mailing list discussion)

=== What versions of the following are you using? ===

• Scala: 2.9RC1
• Java: n/a
• Operating system: Debian Linux sid

[scabug]

Imported From: https://issues.scala-lang.org/browse/SI-4518?orig=1
Reporter: tupshin
See #1980
Duplicates #1980

[scabug]

@odersky said:
It seems to have to do with the fact that the Singleton upper bounds is stripped somewhere.

[scabug]

@dragos said:
Actually, this fails the same way with 2.8.1, but works with 2.8.0.

[scabug]

@adriaanm said (edited on May 23, 2011 8:47:14 AM UTC):
changing the broken_val line to

val broke_val = tempval.-:(new AnyRef {}) // type mismatch error only when assigning

works around the bug... the prefix method call expansion seems to be ruining the dependent method types party

smaller test case and typer output:

object Test {
  trait Foo[T] 

  trait Bar {
    def -:(core: AnyRef): Foo[core.type] = error("")
  }

  val tempval: Bar = error("")
  val cor: AnyRef = error("")
  
  val ok : Foo[cor.type] = tempval.-:(cor)
  val oops : Foo[cor.type] = cor -: tempval 
}

    private[this] val ok: Test.Foo[Test.cor.type] = Test.this.tempval.-:(Test.this.cor);
    <stable> <accessor> def ok: Test.Foo[Test.cor.type] = Test.this.ok;
    private[this] val oops: Test.Foo[Test.cor.type] = {
      <synthetic> val x$1: AnyRef = Test.this.cor;
      Test.this.tempval.-:(x$1)
    };
    <stable> <accessor> def oops: Test.Foo[Test.cor.type] = Test.this.oops

[scabug]

@retronym said:
Merging into #1980

[som-snytt]

It wasn't fixed under the linked ticket after all.