Remove deprecated remote annotation

Author: nicolasstucki

src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala

@@ -317,28 +317,11 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
 
   trait BCForwardersGen extends BCAnnotGen with BCJGenSigGen {
 
-    /* Adds a @remote annotation, actual use unknown.
-     *
-     * Invoked from genMethod() and addForwarder().
-     *
-     * must-single-thread
-     */
-    def addRemoteExceptionAnnot(isRemoteClass: Boolean, isJMethodPublic: Boolean, meth: Symbol): Unit = {
-      val needsAnnotation = (
-        (  isRemoteClass ||
-           isRemote(meth) && isJMethodPublic
-        ) && !(meth.throwsAnnotations contains RemoteExceptionClass)
-      )
-      if (needsAnnotation) {
-        meth.addRemoteRemoteExceptionAnnotation
-      }
-    }
-
     /* Add a forwarder for method m. Used only from addForwarders().
      *
      * must-single-thread
      */
-    private def addForwarder(isRemoteClass: Boolean, jclass: asm.ClassVisitor, module: Symbol, m: Symbol): Unit = {
+    private def addForwarder(jclass: asm.ClassVisitor, module: Symbol, m: Symbol): Unit = {
       val moduleName     = internalName(module)
       val methodInfo     = module.thisType.memberInfo(m)
       val paramJavaTypes: List[BType] = methodInfo.paramTypes map toTypeKind
@@ -356,7 +339,6 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
 
       // TODO needed? for(ann <- m.annotations) { ann.symbol.initialize }
       val jgensig = getStaticForwarderGenericSignature(m, module)
-      addRemoteExceptionAnnot(isRemoteClass, hasPublicBitSet(flags), m)
       val (throws, others) = m.annotations partition (_.symbol == ThrowsClass)
       val thrownExceptions: List[String] = getExceptions(throws)
 
@@ -400,7 +382,7 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
      *
      * must-single-thread
      */
-    def addForwarders(isRemoteClass: Boolean, jclass: asm.ClassVisitor, jclassName: String, moduleClass: Symbol): Unit = {
+    def addForwarders(jclass: asm.ClassVisitor, jclassName: String, moduleClass: Symbol): Unit = {
       assert(moduleClass.isModuleClass, moduleClass)
       debuglog(s"Dumping mirror class for object: $moduleClass")
 
@@ -420,7 +402,7 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
           log(s"No forwarder for non-public member $m")
         else {
           log(s"Adding static forwarder for '$m' from $jclassName to '$moduleClass'")
-          addForwarder(isRemoteClass, jclass, moduleClass, m)
+          addForwarder(jclass, moduleClass, m)
         }
       }
     }
@@ -515,7 +497,7 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
       mirrorClass.visitAttribute(if (ssa.isDefined) pickleMarkerLocal else pickleMarkerForeign)
       emitAnnotations(mirrorClass, moduleClass.annotations ++ ssa)
 
-      addForwarders(isRemote(moduleClass), mirrorClass, mirrorName, moduleClass)
+      addForwarders(mirrorClass, mirrorName, moduleClass)
 
       innerClassBufferASM ++= classBTypeFromSymbol(moduleClass).info.memberClasses
       addInnerClassesASM(mirrorClass, innerClassBufferASM.toList)

src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala

@@ -66,7 +66,6 @@ trait BCodeSkelBuilder extends BCodeHelpers {
     var claszSymbol: Symbol        = null
     var isCZParcelable             = false
     var isCZStaticModule           = false
-    var isCZRemote                 = false
 
     /* ---------------- idiomatic way to ask questions to typer ---------------- */
 
@@ -94,7 +93,6 @@ trait BCodeSkelBuilder extends BCodeHelpers {
       claszSymbol       = cd.symbol
       isCZParcelable    = isAndroidParcelableClass(claszSymbol)
       isCZStaticModule  = claszSymbol.isStaticModuleClass
-      isCZRemote        = isRemote(claszSymbol)
       thisName          = internalName(claszSymbol)
 
       cnode = new asm.tree.ClassNode()
@@ -175,7 +173,7 @@ trait BCodeSkelBuilder extends BCodeHelpers {
             val isCandidateForForwarders = lmoc.shouldEmitForwarders
             if (isCandidateForForwarders) {
               log(s"Adding static forwarders from '$claszSymbol' to implementations in '$lmoc'")
-              addForwarders(isRemote(claszSymbol), cnode, thisName, lmoc.moduleClass)
+              addForwarders(cnode, thisName, lmoc.moduleClass)
             }
           }
         }
@@ -519,7 +517,6 @@ trait BCodeSkelBuilder extends BCodeHelpers {
     def initJMethod(flags: Int, paramAnnotations: List[List[Annotation]]): Unit = {
 
       val jgensig = getGenericSignature(methSymbol, claszSymbol)
-      addRemoteExceptionAnnot(isCZRemote, hasPublicBitSet(flags), methSymbol)
       val (excs, others) = methSymbol.annotations partition (_.symbol == ThrowsClass)
       val thrownExceptions: List[String] = getExceptions(excs)
 

src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala

@@ -180,7 +180,6 @@ class BTypesFromSymbols[I <: BackendInterface](val int: I) extends BTypes {
   }
 
   // legacy, to be removed when the @remote annotation gets removed
-  final def isRemote(s: Symbol) = (s hasAnnotation RemoteAttr)
   final def hasPublicBitSet(flags: Int) = ((flags & asm.Opcodes.ACC_PUBLIC) != 0)
 
   /**

src/compiler/scala/tools/nsc/backend/jvm/BackendInterface.scala

@@ -689,8 +689,6 @@ abstract class BackendInterfaceDefinitions { self: BackendInterface =>
   // Class symbols used in backend.
   // Vals becouse they are to frequent in scala programs so that they are already loaded by backend
 
-  lazy val RemoteAttr: Symbol = requiredClass[scala.remote]
-  lazy val BeanInfoAttr: Symbol = requiredClass[scala.beans.BeanInfo]
   lazy val NativeAttr: Symbol = requiredClass[scala.native]
   lazy val TransientAttr = requiredClass[scala.transient]
   lazy val VolatileAttr = requiredClass[scala.volatile]

src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala

@@ -967,30 +967,13 @@ abstract class GenASM extends SubComponent with BytecodeWriters { self =>
       }
     }
 
-    /** Adds a @remote annotation, actual use unknown.
-     *
-     * Invoked from genMethod() and addForwarder().
-     */
-    def addRemoteExceptionAnnot(isRemoteClass: Boolean, isJMethodPublic: Boolean, meth: Symbol) {
-      val needsAnnotation = (
-        (  isRemoteClass ||
-           isRemote(meth) && isJMethodPublic
-        ) && !(meth.throwsAnnotations contains RemoteExceptionClass)
-      )
-      if (needsAnnotation) {
-        val c   = Constant(RemoteExceptionClass.tpe)
-        val arg = Literal(c) setType c.tpe
-        meth.addAnnotation(appliedType(ThrowsClass, c.tpe), arg)
-      }
-    }
-
     // -----------------------------------------------------------------------------------------
     // Static forwarders (related to mirror classes but also present in
     // a plain class lacking companion module, for details see `isCandidateForForwarders`).
     // -----------------------------------------------------------------------------------------
 
     /** Add a forwarder for method m. Used only from addForwarders(). */
-    private def addForwarder(isRemoteClass: Boolean, jclass: asm.ClassVisitor, module: Symbol, m: Symbol) {
+    private def addForwarder(jclass: asm.ClassVisitor, module: Symbol, m: Symbol) {
       val moduleName     = javaName(module)
       val methodInfo     = module.thisType.memberInfo(m)
       val paramJavaTypes: List[asm.Type] = methodInfo.paramTypes map javaType
@@ -1008,7 +991,6 @@ abstract class GenASM extends SubComponent with BytecodeWriters { self =>
 
       // TODO needed? for(ann <- m.annotations) { ann.symbol.initialize }
       val jgensig = staticForwarderGenericSignature(m, module)
-      addRemoteExceptionAnnot(isRemoteClass, hasPublicBitSet(flags), m)
       val (throws, others) = m.annotations partition (_.symbol == ThrowsClass)
       val thrownExceptions: List[String] = getExceptions(throws)