New bridge implementation

compiler/src/dotty/tools/dotc/transform/ElimErasedValueType.scala

@@ -11,6 +11,9 @@ import TypeErasure.ErasedValueType, ValueClasses._
 /** This phase erases ErasedValueType to their underlying type.
  *  It also removes the synthetic cast methods u2evt$ and evt2u$ which are
  *  no longer needed afterwards.
+ *  Finally, it checks that we don't introduce "double definitions" of pairs
+ *  of methods that now have the same signature but were not considered matching
+ *  before erasure.
  */
 class ElimErasedValueType extends MiniPhaseTransform with InfoTransformer {
 
@@ -67,6 +70,44 @@ class ElimErasedValueType extends MiniPhaseTransform with InfoTransformer {
     transformTypeOfTree(t)
   }
 
+  /** Check that we don't have pairs of methods that override each other after
+   *  this phase, yet do not have matching types before erasure.
+   *  The before erasure test is performed after phase elimRepeated, so we
+   *  do not need to special case pairs of `T* / Seq[T]` parameters.
+   */
+  private def checkNoClashes(root: Symbol)(implicit ctx: Context) = {
+    val opc = new OverridingPairs.Cursor(root) {
+      override def exclude(sym: Symbol) =
+        !sym.is(Method) || sym.is(Bridge) || super.exclude(sym)
+      override def matches(sym1: Symbol, sym2: Symbol) =
+        sym1.signature == sym2.signature
+    }
+    def checkNoConflict(sym1: Symbol, sym2: Symbol, info: Type)(implicit ctx: Context): Unit = {
+      val site = root.thisType
+      val info1 = site.memberInfo(sym1)
+      val info2 = site.memberInfo(sym2)
+      if (!info1.matchesLoosely(info2))
+        ctx.error(
+            em"""double definition:
+                |$sym1: $info1 in ${sym1.owner} ${sym1.flags} and
+                |$sym2: $info2 in ${sym2.owner} ${sym2.flags}
+                |have same type after erasure: $info""",
+            root.pos)
+    }
+    val earlyCtx = ctx.withPhase(ctx.elimRepeatedPhase.next)
+    while (opc.hasNext) {
+      val sym1 = opc.overriding
+      val sym2 = opc.overridden
+      checkNoConflict(sym1, sym2, sym1.info)(earlyCtx)
+      opc.next()
+    }
+  }
+
+  override def transformTypeDef(tree: TypeDef)(implicit ctx: Context, info: TransformerInfo): Tree = {
+    checkNoClashes(tree.symbol)
+    tree
+  }
+
   override def transformInlined(tree: Inlined)(implicit ctx: Context, info: TransformerInfo): Tree =
     transformTypeOfTree(tree)
 

compiler/test/dotc/tests.scala

@@ -193,6 +193,9 @@ class tests extends CompilerTest {
   @Test def neg_i1050 = compileFile(negCustomArgs, "i1050", List("-strict"))
   @Test def neg_i1240 = compileFile(negCustomArgs, "i1240")(allowDoubleBindings)
   @Test def neg_i2002 = compileFile(negCustomArgs, "i2002")(allowDoubleBindings)
+  @Test def neg_valueclasses_doubledefs = compileFile(negCustomArgs, "valueclasses-doubledefs")(allowDoubleBindings)
+  @Test def neg_valueclasses_doubledefs2 = compileFile(negCustomArgs, "valueclasses-doubledefs2")(allowDoubleBindings)
+  @Test def neg_valueclasses_pavlov = compileFile(negCustomArgs, "valueclasses-pavlov")(allowDoubleBindings)
 
   val negTailcallDir = negDir + "tailcall/"
   @Test def neg_tailcall_t1672b = compileFile(negTailcallDir, "t1672b")

tests/untried/neg/valueclasses-doubledefs.scala → tests/neg/customArgs/valueclasses-doubledefs.scala

@@ -2,5 +2,6 @@ class Meter(val x: Double) extends AnyVal
 
 class Foo {
  def apply(x: Double) = x.toString
- def apply(x: Meter) = x.toString
+ def apply(x: Meter) = x.toString // error: double def
 }
+

tests/neg/customArgs/valueclasses-doubledefs2.scala

@@ -0,0 +1,10 @@
+class Meter(val x: Double) extends AnyVal
+
+trait A {
+  def apply(x: Double) = x.toString
+}
+trait B {
+  def apply(x: Meter) = x.toString
+}
+
+object Test extends A with B // error: double def

tests/untried/neg/valueclasses-pavlov.scala → tests/neg/customArgs/valueclasses-pavlov.scala

@@ -5,7 +5,7 @@ trait Foo[T <: AnyVal] extends Any {
 
 class Box1(val value: String) extends AnyVal with Foo[Box2] {
   def foo(x: String) = "foo(String): ok"
-  def foo(x: Box2) = "foo(Box2): ok"
+  def foo(x: Box2) = "foo(Box2): ok"  // error: double def
 }
 
 class Box2(val value: String) extends AnyVal
@@ -17,7 +17,7 @@ object test2a {
     val b1 = new Box1(null)
     val b2 = new Box2(null)
     val f: Foo[Box2] = b1
-    println(f.foo(""))
-    println(f.foo(b2))
+    println(f.foo("")) // error: cannot merge
+    println(f.foo(b2)) // error: cannot merge
   }
 }