SI-4788/SI-5948 Respect RetentionPolicy of Java annotations

Note that I removed the check to ignore @deprecated:
- @deprecated extends StaticAnnotation, so they aren't
  supposed to show up in the RuntimeInvisibleAnnotation
  attribute anyway, and the earlier check for "extends
  ClassfileAnnotationClass" makes this check superflous
  anyway.
- Otherwise, if @deprecated was extending
  ClassfileAnnotationClass it would seem inconsistent
  that we don't emit @deprecated, but would do so for
  @deprecatedOverriding, @deprecatedInheritance, etc.
  Anyway, due to ClassfileAnnotation not working in
  Scala, and the additional check which only allows
  Java-defined annotations, this is pretty pointless
  from every perspective.

6 files changed, 106 insertions, 120 deletions

diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala
index 0c0d726630..4285858bf8 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala
@@ -14,6 +14,13 @@ import PartialFunction._
  */
 final class BCodeAsmCommon[G <: Global](val global: G) {
   import global._
+  import definitions._
+
+  val ExcludedForwarderFlags = {
+    import scala.tools.nsc.symtab.Flags._
+    // Should include DEFERRED but this breaks findMember.
+    ( SPECIALIZED | LIFTED | PROTECTED | STATIC | EXPANDEDNAME | BridgeAndPrivateFlags | MACRO )
+  }
 
   /**
    * True if `classSym` is an anonymous class or a local class. I.e., false if `classSym` is a
@@ -124,4 +131,29 @@ final class BCodeAsmCommon[G <: Global](val global: G) {
       assert(r != NoSymbol, sym.fullLocationString)
       r
   })(collection.breakOut)
+
+  lazy val AnnotationRetentionPolicyModule       = AnnotationRetentionPolicyAttr.companionModule
+  lazy val AnnotationRetentionPolicySourceValue  = AnnotationRetentionPolicyModule.tpe.member(TermName("SOURCE"))
+  lazy val AnnotationRetentionPolicyClassValue   = AnnotationRetentionPolicyModule.tpe.member(TermName("CLASS"))
+  lazy val AnnotationRetentionPolicyRuntimeValue = AnnotationRetentionPolicyModule.tpe.member(TermName("RUNTIME"))
+
+  /** Whether an annotation should be emitted as a Java annotation
+    * .initialize: if 'annot' is read from pickle, atp might be un-initialized
+    */
+  def shouldEmitAnnotation(annot: AnnotationInfo) = {
+    annot.symbol.initialize.isJavaDefined &&
+      annot.matches(ClassfileAnnotationClass) &&
+      retentionPolicyOf(annot) != AnnotationRetentionPolicySourceValue &&
+      annot.args.isEmpty
+  }
+
+  def isRuntimeVisible(annot: AnnotationInfo): Boolean =
+    annot.atp.typeSymbol.getAnnotation(AnnotationRetentionAttr)
+      .exists(_.assocs.contains((nme.value -> LiteralAnnotArg(Constant(AnnotationRetentionPolicyRuntimeValue)))))
+
+  private def retentionPolicyOf(annot: AnnotationInfo): Symbol =
+    annot.atp.typeSymbol.getAnnotation(AnnotationRetentionAttr).map(_.assocs).map(assoc =>
+      assoc.collectFirst {
+        case (`nme`.value, LiteralAnnotArg(Constant(value: Symbol))) => value
+      }).flatten.getOrElse(AnnotationRetentionPolicyClassValue)
 }
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala
index 14bffd67ab..806d4b277c 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala
@@ -469,6 +469,7 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
   trait BCAnnotGen extends BCInnerClassGen {
 
     import genASM.{ubytesToCharArray, arrEncode}
+    import bCodeAsmCommon.{shouldEmitAnnotation, isRuntimeVisible}
 
     /*
      *  can-multi-thread
@@ -533,17 +534,6 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
       }
     }
 
-    /* Whether an annotation should be emitted as a Java annotation
-     *   .initialize: if 'annot' is read from pickle, atp might be un-initialized
-     *
-     * must-single-thread
-     */
-    private def shouldEmitAnnotation(annot: AnnotationInfo) =
-      annot.symbol.initialize.isJavaDefined &&
-      annot.matches(definitions.ClassfileAnnotationClass) &&
-      annot.args.isEmpty &&
-      !annot.matches(definitions.DeprecatedAttr)
-
     /*
      * In general,
      *   must-single-thread
@@ -563,7 +553,7 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
       for(annot <- annotations; if shouldEmitAnnotation(annot)) {
         val AnnotationInfo(typ, args, assocs) = annot
         assert(args.isEmpty, args)
-        val av = cw.visitAnnotation(descriptor(typ), true)
+        val av = cw.visitAnnotation(descriptor(typ), isRuntimeVisible(annot))
         emitAssocs(av, assocs)
       }
     }
@@ -575,7 +565,7 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
       for(annot <- annotations; if shouldEmitAnnotation(annot)) {
         val AnnotationInfo(typ, args, assocs) = annot
         assert(args.isEmpty, args)
-        val av = mw.visitAnnotation(descriptor(typ), true)
+        val av = mw.visitAnnotation(descriptor(typ), isRuntimeVisible(annot))
         emitAssocs(av, assocs)
       }
     }
@@ -587,7 +577,7 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
       for(annot <- annotations; if shouldEmitAnnotation(annot)) {
         val AnnotationInfo(typ, args, assocs) = annot
         assert(args.isEmpty, args)
-        val av = fw.visitAnnotation(descriptor(typ), true)
+        val av = fw.visitAnnotation(descriptor(typ), isRuntimeVisible(annot))
         emitAssocs(av, assocs)
       }
     }
@@ -602,7 +592,7 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
            annot <- annots) {
         val AnnotationInfo(typ, args, assocs) = annot
         assert(args.isEmpty, args)
-        val pannVisitor: asm.AnnotationVisitor = jmethod.visitParameterAnnotation(idx, descriptor(typ), true)
+        val pannVisitor: asm.AnnotationVisitor = jmethod.visitParameterAnnotation(idx, descriptor(typ), isRuntimeVisible(annot))
         emitAssocs(pannVisitor, assocs)
       }
     }
@@ -625,13 +615,6 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
 
   trait BCForwardersGen extends BCAnnotGen with BCJGenSigGen {
 
-    // -----------------------------------------------------------------------------------------
-    // Static forwarders (related to mirror classes but also present in
-    // a plain class lacking companion module, for details see `isCandidateForForwarders`).
-    // -----------------------------------------------------------------------------------------
-
-    val ExcludedForwarderFlags = genASM.ExcludedForwarderFlags
-
     /* Adds a @remote annotation, actual use unknown.
      *
      * Invoked from genMethod() and addForwarder().
@@ -727,7 +710,7 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
       }
       debuglog(s"Potentially conflicting names for forwarders: $conflictingNames")
 
-      for (m <- moduleClass.info.membersBasedOnFlags(ExcludedForwarderFlags, symtab.Flags.METHOD)) {
+      for (m <- moduleClass.info.membersBasedOnFlags(bCodeAsmCommon.ExcludedForwarderFlags, symtab.Flags.METHOD)) {
         if (m.isType || m.isDeferred || (m.owner eq definitions.ObjectClass) || m.isConstructor)
           debuglog(s"No forwarder for '$m' from $jclassName to '$moduleClass'")
         else if (conflictingNames(m.name))
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
index 7c4c02c2d3..d0a12c32e5 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
@@ -20,7 +20,7 @@ import scala.annotation.tailrec
  *
  * Documentation at http://lamp.epfl.ch/~magarcia/ScalaCompilerCornerReloaded/2012Q2/GenASM.pdf
  */
-abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { self =>
+abstract class GenASM extends SubComponent with BytecodeWriters { self =>
   import global._
   import icodes._
   import icodes.opcodes._
@@ -99,6 +99,63 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM {
       }
     }
 
+    private def isJavaEntryPoint(icls: IClass) = {
+      val sym = icls.symbol
+      def fail(msg: String, pos: Position = sym.pos) = {
+        reporter.warning(sym.pos,
+          sym.name + " has a main method with parameter type Array[String], but " + sym.fullName('.') + " will not be a runnable program.\n" +
+            "  Reason: " + msg
+          // TODO: make this next claim true, if possible
+          //   by generating valid main methods as static in module classes
+          //   not sure what the jvm allows here
+          // + "  You can still run the program by calling it as " + sym.javaSimpleName + " instead."
+        )
+        false
+      }
+      def failNoForwarder(msg: String) = {
+        fail(msg + ", which means no static forwarder can be generated.\n")
+      }
+      val possibles = if (sym.hasModuleFlag) (sym.tpe nonPrivateMember nme.main).alternatives else Nil
+      val hasApproximate = possibles exists { m =>
+        m.info match {
+          case MethodType(p :: Nil, _) => p.tpe.typeSymbol == ArrayClass
+          case _                       => false
+        }
+      }
+      // At this point it's a module with a main-looking method, so either succeed or warn that it isn't.
+      hasApproximate && {
+        // Before erasure so we can identify generic mains.
+        enteringErasure {
+          val companion     = sym.linkedClassOfClass
+
+          if (hasJavaMainMethod(companion))
+            failNoForwarder("companion contains its own main method")
+          else if (companion.tpe.member(nme.main) != NoSymbol)
+            // this is only because forwarders aren't smart enough yet
+            failNoForwarder("companion contains its own main method (implementation restriction: no main is allowed, regardless of signature)")
+          else if (companion.isTrait)
+            failNoForwarder("companion is a trait")
+          // Now either succeeed, or issue some additional warnings for things which look like
+          // attempts to be java main methods.
+          else (possibles exists isJavaMainMethod) || {
+            possibles exists { m =>
+              m.info match {
+                case PolyType(_, _) =>
+                  fail("main methods cannot be generic.")
+                case MethodType(params, res) =>
+                  if (res.typeSymbol :: params exists (_.isAbstractType))
+                    fail("main methods cannot refer to type parameters or abstract types.", m.pos)
+                  else
+                    isJavaMainMethod(m) || fail("main method must have exact signature (Array[String])Unit", m.pos)
+                case tp =>
+                  fail("don't know what this is: " + tp, m.pos)
+              }
+            }
+          }
+        }
+      }
+    }
+
     override def run() {
 
       if (settings.debug)
@@ -807,15 +864,6 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM {
       for (ThrownException(exc) <- excs.distinct)
       yield javaName(exc)
 
-    /** Whether an annotation should be emitted as a Java annotation
-     *   .initialize: if 'annot' is read from pickle, atp might be un-initialized
-     */
-    private def shouldEmitAnnotation(annot: AnnotationInfo) =
-      annot.symbol.initialize.isJavaDefined &&
-      annot.matches(ClassfileAnnotationClass) &&
-      annot.args.isEmpty &&
-      !annot.matches(DeprecatedAttr)
-
     def getCurrentCUnit(): CompilationUnit
 
     def getGenericSignature(sym: Symbol, owner: Symbol) = self.getGenericSignature(sym, owner, getCurrentCUnit())
@@ -877,7 +925,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM {
       for(annot <- annotations; if shouldEmitAnnotation(annot)) {
         val AnnotationInfo(typ, args, assocs) = annot
         assert(args.isEmpty, args)
-        val av = cw.visitAnnotation(descriptor(typ), true)
+        val av = cw.visitAnnotation(descriptor(typ), isRuntimeVisible(annot))
         emitAssocs(av, assocs)
       }
     }
@@ -886,7 +934,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM {
       for(annot <- annotations; if shouldEmitAnnotation(annot)) {
         val AnnotationInfo(typ, args, assocs) = annot
         assert(args.isEmpty, args)
-        val av = mw.visitAnnotation(descriptor(typ), true)
+        val av = mw.visitAnnotation(descriptor(typ), isRuntimeVisible(annot))
         emitAssocs(av, assocs)
       }
     }
@@ -895,7 +943,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM {
       for(annot <- annotations; if shouldEmitAnnotation(annot)) {
         val AnnotationInfo(typ, args, assocs) = annot
         assert(args.isEmpty, args)
-        val av = fw.visitAnnotation(descriptor(typ), true)
+        val av = fw.visitAnnotation(descriptor(typ), isRuntimeVisible(annot))
         emitAssocs(av, assocs)
       }
     }
@@ -907,7 +955,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM {
            annot <- annots) {
         val AnnotationInfo(typ, args, assocs) = annot
         assert(args.isEmpty, args)
-        val pannVisitor: asm.AnnotationVisitor = jmethod.visitParameterAnnotation(idx, descriptor(typ), true)
+        val pannVisitor: asm.AnnotationVisitor = jmethod.visitParameterAnnotation(idx, descriptor(typ), isRuntimeVisible(annot))
         emitAssocs(pannVisitor, assocs)
       }
     }
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenJVMASM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenJVMASM.scala
deleted file mode 100644
index 2bcde7f7b9..0000000000
--- a/src/compiler/scala/tools/nsc/backend/jvm/GenJVMASM.scala
+++ /dev/null
@@ -1,83 +0,0 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author  Jason Zaugg
- */
-
-package scala.tools.nsc
-package backend.jvm
-import scala.tools.nsc.symtab._
-
-/** Code shared between the erstwhile legacy backend (aka GenJVM)
- *  and the new backend [[scala.tools.nsc.backend.jvm.GenASM]]. There should be
- *  more here, but for now I'm starting with the refactorings that are either
- *  straightforward to review or necessary for maintenance.
- */
-trait GenJVMASM {
-  val global: Global
-  import global._
-  import icodes._
-  import definitions._
-
-  val ExcludedForwarderFlags = {
-    import Flags._
-    // Should include DEFERRED but this breaks findMember.
-    ( SPECIALIZED | LIFTED | PROTECTED | STATIC | EXPANDEDNAME | BridgeAndPrivateFlags | MACRO )
-  }
-
-  protected def isJavaEntryPoint(icls: IClass) = {
-    val sym = icls.symbol
-    def fail(msg: String, pos: Position = sym.pos) = {
-      reporter.warning(sym.pos,
-        sym.name + " has a main method with parameter type Array[String], but " + sym.fullName('.') + " will not be a runnable program.\n" +
-          "  Reason: " + msg
-        // TODO: make this next claim true, if possible
-        //   by generating valid main methods as static in module classes
-        //   not sure what the jvm allows here
-        // + "  You can still run the program by calling it as " + sym.javaSimpleName + " instead."
-      )
-      false
-    }
-    def failNoForwarder(msg: String) = {
-      fail(msg + ", which means no static forwarder can be generated.\n")
-    }
-    val possibles = if (sym.hasModuleFlag) (sym.tpe nonPrivateMember nme.main).alternatives else Nil
-    val hasApproximate = possibles exists { m =>
-      m.info match {
-        case MethodType(p :: Nil, _) => p.tpe.typeSymbol == ArrayClass
-        case _                       => false
-      }
-    }
-    // At this point it's a module with a main-looking method, so either succeed or warn that it isn't.
-    hasApproximate && {
-      // Before erasure so we can identify generic mains.
-      enteringErasure {
-        val companion     = sym.linkedClassOfClass
-
-        if (hasJavaMainMethod(companion))
-          failNoForwarder("companion contains its own main method")
-        else if (companion.tpe.member(nme.main) != NoSymbol)
-          // this is only because forwarders aren't smart enough yet
-          failNoForwarder("companion contains its own main method (implementation restriction: no main is allowed, regardless of signature)")
-        else if (companion.isTrait)
-          failNoForwarder("companion is a trait")
-        // Now either succeeed, or issue some additional warnings for things which look like
-        // attempts to be java main methods.
-        else (possibles exists isJavaMainMethod) || {
-          possibles exists { m =>
-            m.info match {
-              case PolyType(_, _) =>
-                fail("main methods cannot be generic.")
-              case MethodType(params, res) =>
-                if (res.typeSymbol :: params exists (_.isAbstractType))
-                  fail("main methods cannot refer to type parameters or abstract types.", m.pos)
-                else
-                  isJavaMainMethod(m) || fail("main method must have exact signature (Array[String])Unit", m.pos)
-              case tp =>
-                fail("don't know what this is: " + tp, m.pos)
-            }
-          }
-        }
-      }
-    }
-  }
-}
diff --git a/src/reflect/scala/reflect/internal/Definitions.scala b/src/reflect/scala/reflect/internal/Definitions.scala
index 02578e2038..57a17693ad 100644
--- a/src/reflect/scala/reflect/internal/Definitions.scala
+++ b/src/reflect/scala/reflect/internal/Definitions.scala
@@ -1087,6 +1087,10 @@ trait Definitions extends api.StandardDefinitions {
     lazy val ClassfileAnnotationClass   = requiredClass[scala.annotation.ClassfileAnnotation]
     lazy val StaticAnnotationClass      = requiredClass[scala.annotation.StaticAnnotation]
 
+    // Java retention annotations
+    lazy val AnnotationRetentionAttr       = requiredClass[java.lang.annotation.Retention]
+    lazy val AnnotationRetentionPolicyAttr = requiredClass[java.lang.annotation.RetentionPolicy]
+
     // Annotations
     lazy val BridgeClass                = requiredClass[scala.annotation.bridge]
     lazy val ElidableMethodClass        = requiredClass[scala.annotation.elidable]
diff --git a/src/reflect/scala/reflect/runtime/JavaUniverseForce.scala b/src/reflect/scala/reflect/runtime/JavaUniverseForce.scala
index dcd262c288..18a3c5d63f 100644
--- a/src/reflect/scala/reflect/runtime/JavaUniverseForce.scala
+++ b/src/reflect/scala/reflect/runtime/JavaUniverseForce.scala
@@ -360,6 +360,8 @@ trait JavaUniverseForce { self: runtime.JavaUniverse  =>
     definitions.AnnotationClass
     definitions.ClassfileAnnotationClass
     definitions.StaticAnnotationClass
+    definitions.AnnotationRetentionAttr
+    definitions.AnnotationRetentionPolicyAttr
     definitions.BridgeClass
     definitions.ElidableMethodClass
     definitions.ImplicitNotFoundClass