Merge pull request #2557 from dotty-staging/fix-junit4

Fix #2556, make JUnit4 work in dotty compiled classes.

Author: DarkDimius

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

@@ -6,13 +6,18 @@ import Symbols._, Types._, Contexts._, SymDenotations._, DenotTransformers._, Fl
 import util.Positions._
 import SymUtils._
 import StdNames._, NameOps._
+import Decorators._
 
 class MixinOps(cls: ClassSymbol, thisTransform: DenotTransformer)(implicit ctx: Context) {
   import ast.tpd._
 
   val superCls: Symbol = cls.superClass
   val mixins: List[ClassSymbol] = cls.mixins
 
+  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,
@@ -59,10 +64,14 @@ class MixinOps(cls: ClassSymbol, thisTransform: DenotTransformer)(implicit ctx:
     def needsDisambiguation = competingMethods.exists(x=> !(x is Deferred)) // multiple implementations are available
     def hasNonInterfaceDefinition = competingMethods.exists(!_.owner.is(Trait)) // there is a definition originating from class
     meth.is(Method, butNot = PrivateOrAccessorOrDeferred) &&
-    (meth.owner.is(Scala2x) || needsDisambiguation || hasNonInterfaceDefinition ) &&
+    (meth.owner.is(Scala2x) || needsDisambiguation || hasNonInterfaceDefinition || needsJUnit4Fix(meth) ) &&
     isCurrent(meth)
   }
 
+  private def needsJUnit4Fix(meth: Symbol): Boolean = {
+    meth.annotations.nonEmpty && JUnit4Annotations.exists(annot => meth.hasAnnotation(annot))
+  }
+
   /** Get `sym` of the method that needs a forwarder
     *  Method needs a forwarder in those cases:
     *   - there is a trait that defines a primitive version of implemented polymorphic method.

tests/run/junitForwarders/C_1.scala

@@ -0,0 +1,15 @@
+trait T {
+  @org.junit.Test def foo = 0
+}
+
+class C extends T
+
+object Test extends App {
+  def check(c: Class[_], e: String) = {
+    val s = c.getDeclaredMethods.sortBy(_.getName).map(m => s"${m.getName} - ${m.getDeclaredAnnotations.mkString(", ")}").mkString(";")
+    assert(s == e, s"found: $s\nexpected: $e")
+  }
+  check(classOf[C], "foo - @org.junit.Test()")
+  // TODO scala-dev#213: should `foo$` really carry the @Test annotation?
+  check(classOf[T], "$init$ - ;foo - @org.junit.Test()")
+}

tests/run/junitForwarders/Test.java

@@ -0,0 +1,10 @@
+package org.junit;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.METHOD})
+public @interface Test { }