IncompatibleClassChangeError with targetName

[cchantep]

Compiler version

3.0.1-RC1-bin-20210407-8b35b67-NIGHTLY

Minimized code

class Foo(val strings: Seq[String]) extends FooLowPriority

trait FooLowPriority { self: Foo =>
  @scala.annotation.targetName("appendFromProducers")
  def append(v: String): Foo = new Foo(v +: self.strings)
}

trait FooBar { self: Foo =>
  @scala.annotation.targetName("appendFromProducers")
  final override def append(v: String): Foo = new Foo(self.strings :+ v)
}

object Foo {
  type Bar = Foo with FooBar

  def bar(vs: String*): Bar = new Foo(vs) with FooBar
}

Foo.bar("foo").append("bar") // Throw runtime exception

Output

Compile without error, but running the final call throw the following Exception

Caused by: java.lang.IncompatibleClassChangeError: Conflicting default methods: test/FooLowPriority.appendFromProducers test/FooBar.appendFromProducers
	at Foo$$anon$1.appendFromProducers(..)

Without @targetName, it runs fine.

With plain inheritance/no mixin, it runs files:

class Foo(val strings: Seq[String]) extends FooLowPriority

trait FooLowPriority { self: Foo =>
  @scala.annotation.targetName("appendFromProducers")
  def append(v: String): Foo = new Foo(v +: self.strings)
}

class FooBar(strings: Seq[String]) extends Foo(strings) {
  @scala.annotation.targetName("appendFromProducers")
  final override def append(v: String): Foo = new Foo(strings :+ v)
}

object Foo {
  def bar(vs: String*): FooBar = new FooBar(vs)
}

Expectation

Compile and run without error

[odersky]

There are a lot of complex features mixed into this. I verified that for straight trait overriding @targetName works. So this will need a minimization to find out what combination exactly causes the problem.

[cchantep]

Yes it works with simple inheritance.
May be incompatible with mixin.

[odersky]

I'd need a concrete minimization. Specifically, which of the following elements do/do not influence the result:

• private[test]
• sealed
• self types
• varargs Gen*
• operators ++ vs normal methods
• anonymous classes

Try to change one parameter at a time until you have a minimal set of features. Then, demonstrate by removing one more feature the program runs correctly

[cchantep]

Also, with variation about the same targetName theme, it seems that the annotation prevent an appropriate overriding.

sealed abstract class Foo { self =>
  def strings: Seq[String]

  @scala.annotation.targetName("appendStrings")
  def append(v: String): Foo = new Foo {
    println("_Foo")
    val strings = v +: self.strings
  }
}

sealed trait FooBar extends Foo { self =>
  @scala.annotation.targetName("appendStrings")
  final override def append(v: String): Foo = new FooBar {
    println("_Bar")
    val strings = self.strings ++: Seq(v)
  }
}

(new FooBar {
  val strings = Seq("foo")
}).append("bar").strings

The final call should display _Bar as FooBar.append should be invoked, and the strings == Seq("foo", "bar"). Actually, it print _Fooandstrings == Seq("bar", "foo")as the not overridenFoo.append` is invoked.

Without the annotation it runs fine (but would raise conflicting error with other append with same erasure ... one of the reason why the annotation was introduced as far as I understand):

sealed abstract class Foo { self =>
  def strings: Seq[String]

  def append(v: String): Foo = new Foo {
    println("_Foo")
    val strings = v +: self.strings
  }
}

sealed trait FooBar extends Foo { self =>
  final override def append(v: String): Foo = new FooBar {
    println("_Bar")
    val strings = self.strings ++: Seq(v)
  }
}