Remove compiler dependency on @remote

This was already partially done in
31f9681. This mirror similar changes
done by Adriaan Moors in scala#6164

Author: smarter

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

@@ -179,9 +179,6 @@ class BTypesFromSymbols[I <: BackendInterface](val int: I) extends BTypes {
     }
   }
 
-  // legacy, to be removed when the @remote annotation gets removed
-  final def hasPublicBitSet(flags: Int) = ((flags & asm.Opcodes.ACC_PUBLIC) != 0)
-
   /**
    * Return the Java modifiers for the given symbol.
    * Java modifiers for classes:

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

@@ -557,7 +557,6 @@ abstract class BackendInterface extends BackendInterfaceDefinitions {
     def isOriginallyStaticOwner: Boolean
 
 
-    def addRemoteRemoteExceptionAnnotation: Unit
     def samMethod(): Symbol
   }
 
@@ -722,7 +721,6 @@ abstract class BackendInterfaceDefinitions { self: BackendInterface =>
 
   val ClassfileAnnotationClass: Symbol = requiredClass[scala.annotation.ClassfileAnnotation]
   val BoxedNumberClass: Symbol = requiredClass[java.lang.Number]
-  val RemoteExceptionClass: Symbol = requiredClass[java.rmi.RemoteException]
   val ThrowsClass: Symbol = requiredClass[scala.throws[_]]
 
   // Module symbols used in backend

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

@@ -241,7 +241,6 @@ abstract class GenASM extends SubComponent with BytecodeWriters { self =>
 
   private def mkFlags(args: Int*)         = args.foldLeft(0)(_ | _)
   private def hasPublicBitSet(flags: Int) = (flags & asm.Opcodes.ACC_PUBLIC) != 0
-  private def isRemote(s: Symbol)         = s hasAnnotation RemoteAttr
 
   /**
    * Return the Java modifiers for the given symbol.
@@ -1032,7 +1031,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters { self =>
      *  a method with the same name is defined both in a class and its companion object:
      *  method signature is not taken into account.
      */
-    def addForwarders(isRemoteClass: Boolean, jclass: asm.ClassVisitor, jclassName: String, moduleClass: Symbol) {
+    def addForwarders(jclass: asm.ClassVisitor, jclassName: String, moduleClass: Symbol) {
       assert(moduleClass.isModuleClass, moduleClass)
       debuglog("Dumping mirror class for object: " + moduleClass)
 
@@ -1051,7 +1050,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters { self =>
           log(s"No forwarder for non-public member $m")
         else {
           debuglog(s"Adding static forwarder for '$m' from $jclassName to '$moduleClass'")
-          addForwarder(isRemoteClass, jclass, moduleClass, m)
+          addForwarder(jclass, moduleClass, m)
         }
       }
     }
@@ -1190,16 +1189,9 @@ abstract class GenASM extends SubComponent with BytecodeWriters { self =>
     def serialVUID: Option[Long] = clasz.symbol.serialVUID
 
     private def getSuperInterfaces(c: IClass): Array[String] = {
-
-        // Additional interface parents based on annotations and other cues
-        def newParentForAttr(ann: AnnotationInfo): Symbol = ann.symbol match {
-          case RemoteAttr       => RemoteInterfaceClass
-          case _                => NoSymbol
-        }
-
       val ps = c.symbol.info.parents
       val superInterfaces0: List[Symbol] = if(ps.isEmpty) Nil else c.symbol.mixinClasses
-      val superInterfaces = existingSymbols(superInterfaces0 ++ c.symbol.annotations.map(newParentForAttr)).distinct
+      val superInterfaces = existingSymbols(superInterfaces0).distinct
 
       if(superInterfaces.isEmpty) EMPTY_STRING_ARRAY
       else mkArray(erasure.minimizeInterfaces(superInterfaces.map(_.info)).map(t => javaName(t.typeSymbol)))
@@ -1281,7 +1273,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters { self =>
             }
             if (isCandidateForForwarders) {
               log("Adding static forwarders from '%s' to implementations in '%s'".format(c.symbol, lmoc))
-              addForwarders(isRemote(clasz.symbol), jclass, thisName, lmoc.moduleClass)
+              addForwarders(false, jclass, thisName, lmoc.moduleClass)
             }
           }
         }
@@ -1372,7 +1364,6 @@ abstract class GenASM extends SubComponent with BytecodeWriters { self =>
 
       // TODO needed? for(ann <- m.symbol.annotations) { ann.symbol.initialize }
       val jgensig = getGenericSignature(m.symbol, clasz.symbol)
-      addRemoteExceptionAnnot(isRemote(clasz.symbol), hasPublicBitSet(flags), m.symbol)
       val (excs, others) = m.symbol.annotations partition (_.symbol == ThrowsClass)
       val thrownExceptions: List[String] = getExceptions(excs)
 
@@ -2793,7 +2784,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters { self =>
       // typestate: entering mode with valid call sequences:
       //   ( visitInnerClass | visitField | visitMethod )* visitEnd
 
-      addForwarders(isRemote(modsym), mirrorClass, mirrorName, modsym)
+      addForwarders(false, mirrorClass, mirrorName, modsym)
 
       addInnerClasses(modsym, mirrorClass)
       mirrorClass.visitEnd()

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

@@ -554,12 +554,6 @@ class ScalacBackendInterface[G <: Global](val global: G) extends BackendInterfac
     })(collection.breakOut)
 
 
-    def addRemoteRemoteExceptionAnnotation: Unit = {
-      val c   = new Constant(RemoteExceptionClass.tpe)
-      val arg = new Literal(c) setType c.tpe
-      sym.addAnnotation(appliedType(definitions.ThrowsClass, c.tpe), arg)
-    }
-
     def linkedClass: Symbol = exitingPickler(sym.linkedClassOfClass) // linkedCoC does not work properly in late phases
     def companionModuleMembers: List[Symbol] = {
       // phase travel to exitingPickler: this makes sure that memberClassesOf only sees member classes,
@@ -573,14 +567,8 @@ class ScalacBackendInterface[G <: Global](val global: G) extends BackendInterfac
      *
      */
      def superInterfaces: List[Symbol] =  {
-
-      // Additional interface parents based on annotations and other cues
-      def newParentForAnnotation(ann: AnnotationInfo): Symbol =
-        if (ann.symbol eq RemoteAttr) RemoteInterfaceClass
-        else NoSymbol
-
       val superInterfaces0: List[Symbol] = sym.mixinClasses
-      val superInterfaces = existingSymbols(superInterfaces0 ++ sym.annotations.map(newParentForAnnotation)).distinct
+      val superInterfaces = existingSymbols(superInterfaces0).distinct
 
       assert(!superInterfaces.contains(NoSymbol), s"found NoSymbol among: ${superInterfaces.mkString(", ")}")
       assert(superInterfaces.forall(s => s.isInterface || s.isTrait), s"found non-interface among: ${superInterfaces.mkString(", ")}")