Avoid exceptions when merging denotations

It's better to form a safe type than to thrown an exception.

Author: odersky

compiler/src/dotty/tools/dotc/core/Denotations.scala

@@ -260,6 +260,14 @@ object Denotations {
       (for ((name1, name2, idx) <- (tp1.paramNames, tp2.paramNames, tp1.paramNames.indices).zipped)
        yield if (name1 == name2) name1 else tp1.companion.syntheticParamName(idx)).toList
 
+    /** Merge parameter infos. This is always dowwards via gb because that's the
+     *  only safe direction. It's safe to assume that two method implementations
+     *  with the same signature work on the intersection of their domains.
+     */
+    private def mergeParamInfos(tp1: LambdaType, tp2: LambdaType)(implicit ctx: Context): List[tp1.PInfo] =
+      tp1.paramInfos.zipWithConserve(tp2.paramInfos)(
+        (pi1: Type, pi2: Type) => (pi1 & pi2).asInstanceOf[tp1.PInfo])
+
     /** Form a denotation by conjoining with denotation `that`.
      *
      *  NoDenotations are dropped. MultiDenotations are handled by merging
@@ -326,12 +334,10 @@ object Denotations {
                 //    and result types.
                 if (tp1.isInstanceOf[PolyType] && tp2.isInstanceOf[MethodType]) tp2
                 else if (tp2.isInstanceOf[PolyType] && tp1.isInstanceOf[MethodType]) tp1
-                else if (ctx.typeComparer.matchingParams(tp1, tp2) &&
-                         tp1.isImplicit == tp2.isImplicit)
+                else
                   tp1.derivedLambdaType(
-                    mergeParamNames(tp1, tp2), tp1.paramInfos,
+                    mergeParamNames(tp1, tp2), mergeParamInfos(tp1, tp2),
                     infoMeet(tp1.resultType, tp2.resultType.subst(tp2, tp1)))
-                else mergeConflict(tp1, tp2)
               case _ =>
                 mergeConflict(tp1, tp2)
             }
@@ -481,11 +487,9 @@ object Denotations {
           }
         case tp1: MethodOrPoly =>
           tp2 match {
-            case tp2: MethodOrPoly
-            if ctx.typeComparer.matchingParams(tp1, tp2) &&
-               tp1.isImplicit == tp2.isImplicit =>
+            case tp2: MethodOrPoly =>
               tp1.derivedLambdaType(
-                mergeParamNames(tp1, tp2), tp1.paramInfos,
+                mergeParamNames(tp1, tp2), mergeParamInfos(tp1, tp2),
                 tp1.resultType | tp2.resultType.subst(tp2, tp1))
             case _ =>
               mergeConflict(tp1, tp2)

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

@@ -17,7 +17,7 @@ class MixinOps(cls: ClassSymbol, thisTransform: DenotTransformer)(implicit ctx:
   lazy val JUnit4Annotations: List[Symbol] = List("Test", "Ignore", "Before", "After", "BeforeClass", "AfterClass").
     map(n => ctx.getClassIfDefined("org.junit." + n)).
     filter(_.exists)
-  
+
   def implementation(member: TermSymbol): TermSymbol = {
     val res = member.copy(
       owner = cls,