object overriding a val: duplicate class error

[scabug]

class Test
trait A {
  val a: Test = new Test
}
trait B extends A {
  override object a extends Test
}

object Test extends App {
  val b = new B{}
}

qscalac -Xprint:erasure sandbox/test.scala && qscala Test
[[syntax trees at end of                   erasure]] // test.scala
package <empty> {
  class Test extends Object {
    def <init>(): Test = {
      Test.super.<init>();
      ()
    }
  };
  abstract trait A extends Object {
    <stable> <accessor> def a(): Test
  };
  abstract trait B extends Object with A {
    object a extends Test {
      def <init>($outer: B): B.this.a.type = {
        a.super.<init>();
        ()
      };
      <synthetic> <paramaccessor> <artifact> private[this] val $outer: B = _;
      <synthetic> <stable> <artifact> def $outer(): B = a.this.$outer
    };
    override <stable> def a(): B#a.type
  };
  object Test extends Object with App {
    def <init>(): Test.type = {
      Test.super.<init>();
      Test.this.$asInstanceOf[App$class]()./*App$class*/$init$();
      ()
    };
    private[this] val b: B = {
      final class $anon extends Object with B {
        def <init>(): <$anon: B> = {
          $anon.super.<init>();
          $anon.this.$asInstanceOf[A$class]()./*A$class*/$init$();
          $anon.this.$asInstanceOf[B$class]()./*B$class*/$init$();
          ()
        };
        override <stable> <bridge> <artifact> def a(): Test = $anon.this.a()
      };
      new <$anon: B>()
    };
    <stable> <accessor> def b(): B = Test.this.b
  };
  abstract trait A$class extends Object with A {
    def /*A$class*/$init$(): Unit = {
      ()
    };
    private[this] val a: Test = new Test();
    <stable> <accessor> def a(): Test = A$class.this.a
  };
  abstract trait B$class extends Object with A$class with B {
    def /*B$class*/$init$(): Unit = {
      ()
    };
    @volatile <synthetic> var a$module: B#a.type = _;
    override <stable> def a(): B#a.type = new B#a.type(B$class.this)
  }
}

java.lang.ClassFormatError: Duplicate method name&signature in class file Test$$anon$1
	at java.lang.ClassLoader.defineClass1(Native Method)
	at java.lang.ClassLoader.defineClass(ClassLoader.java:

[scabug]

Imported From: https://issues.scala-lang.org/browse/SI-8663?orig=1
Reporter: @retronym
Affected Versions: 2.10.4, 2.11.1

[scabug]

Denis Rosset (denisrosset) said:
I have the same problem with an inner trait:

trait A {
  trait Test
  val instance: Test = new Test { }
}

class B extends A {
  override object instance extends Test
}


object Run extends App {
  val b = new B
}

gives java.lang.ClassFormatError: Duplicate method name&signature in class file B

However, when making trait A a class, the problem disappears on both 2.10.4 and 2.11.5.

The wordaround is to use something along the lines of:

  override val instance = new Test { }

[som-snytt]

doti:

-- Error: t8663.scala:6:2 ------------------------------------------------------
6 |  override object a extends Test
  |  ^
  |  error overriding value a in trait A of type Test;
  |    object a may not override a concrete non-lazy value
1 error found

it may override a lazy val, but scalac:

t8663.scala:6: error: value must be lazy when overriding concrete lazy value:
lazy val a: Test (defined in trait A)
  override object a extends Test
                  ^

even though the equivalence of object member as lazy val is enshrined in spec.

[som-snytt]

As a reminder that the pandemic isn't over, the second example with a class B

trait A {
  trait Test
  val instance: Test = new Test { }
}

class B extends A {
  override object instance extends Test
}

object Test extends App {
  val b = new B
}

yields

Exception in thread "main" java.lang.AbstractMethodError: Receiver class B does not define or inherit an implementation of the resolved method 'abstract void A$_setter_$instance_$eq(A$Test)' of interface A.
        at A.$init$(t8663.scala:4)
        at B.<init>(t8663.scala:7)

and the original example with trait B

class Test
trait A {
  val instance: Test = new Test
}

trait B extends A {
  override object instance extends Test
}

object Test extends App {
  val b = new B {}
}

still yields Exception in thread "main" java.lang.ClassFormatError: Duplicate method name "instance" with signature "()LB$instance$;" in class file Test$$anon$1

Overriding lazy val is at #5187

Constant type overriding and mixin is at #12301

The wordaround is to use something along the lines of

favorite word of the day is "wordaround". That must be when one discusses a problem into irrelevance.