Handle MergeErrors in RefChecks

Used to throw an uncaught merge error in checkAllOverrides
when compiling i1240c.scala.

Author: odersky

src/dotty/tools/dotc/typer/RefChecks.scala

@@ -837,14 +837,18 @@ class RefChecks extends MiniPhase { thisTransformer =>
       if (tree.symbol is Macro) EmptyTree else tree
     }
 
-    override def transformTemplate(tree: Template)(implicit ctx: Context, info: TransformerInfo) = {
+    override def transformTemplate(tree: Template)(implicit ctx: Context, info: TransformerInfo) = try {
       val cls = ctx.owner
       checkOverloadedRestrictions(cls)
       checkParents(cls)
       checkCompanionNameClashes(cls)
       checkAllOverrides(cls)
       checkDerivedValueClass(cls, tree.body)
       tree
+    } catch {
+      case ex: MergeError =>
+        ctx.error(ex.getMessage, tree.pos)
+        tree
     }
 
     override def transformTypeTree(tree: TypeTree)(implicit ctx: Context, info: TransformerInfo) = {

tests/neg/i1240b.scala

@@ -1,17 +1,12 @@
-// yet another variant, testing super accessors
-
-trait T {
-  def foo[B](x: C[B]): C[B]
+// yet another variant, testing type parameters
+trait T[X] {
+  def foo(x: X): X
 }
-abstract class A extends T {
-  type C[X]
-  def foo[B](x: C[B]): C[B]       = {println("A.C"); x}
-  def foo[B](x: List[B]): List[B] = {println("A.List"); x}
+abstract class A[X] extends T[X] {
+  def foo(x: X): X           = {println("A.X"); x}
+  def foo(x: String): String = {println("A.String"); x}
 }
-trait U extends T {
-  def foo[B](x: C[B]): C[B] = super.foo[B](x)
-}
-object Test extends A with U {
-  type C[X] = List[X]
-  def main(args: Array[String]) = foo(List(""))
+trait U[X] extends T[X] {
+  abstract override def foo(x: X): X = super.foo(x)
 }
+object Test extends A[String] with U[String] // error: accidental override

tests/neg/i1240c.scala

@@ -0,0 +1,17 @@
+// yet another variant, testing super accessors
+// (but exhibited a crash in RefChecks).
+
+trait T {
+  def foo[B](x: C[B]): C[B]
+}
+abstract class A extends T {
+  type C[X]
+  def foo[B](x: C[B]): C[B]       = {println("A.C"); x}
+  def foo[B](x: List[B]): List[B] = {println("A.List"); x}
+}
+trait U extends T {
+  abstract override def foo[B](x: C[B]): C[B] = super.foo[B](x)
+}
+object Test extends A with U {
+  type C[X] = List[X]
+}