Merge pull request lampepfl#28 from dotty-staging/fix-all-warinings

Fix all warnings

Author: nicolasstucki

src/compiler/scala/tools/nsc/backend/WorklistAlgorithm.scala

@@ -23,7 +23,20 @@ import scala.collection.mutable
  */
 trait WorklistAlgorithm {
   type Elem
-  type WList = mutable.Stack[Elem]
+  class WList {
+    private[this] var list: List[Elem] = Nil
+    def isEmpty = list.isEmpty
+    def nonEmpty = !isEmpty
+    def push(e: Elem): Unit = { list = e :: list }
+    def pop(): Elem = {
+      val head = list.head
+      list = list.tail
+      head
+    }
+    def pushAll(xs: Iterable[Elem]): Unit = xs.foreach(push)
+    def clear(): Unit = list = Nil
+
+  }
 
   val worklist: WList
 

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

@@ -72,7 +72,7 @@ import interface._
     enclosingClass(classSym.originalOwner)
   }
 
-  final case class EnclosingMethodEntry(owner: String, name: String, methodDescriptor: String)
+  /*final*/ case class EnclosingMethodEntry(owner: String, name: String, methodDescriptor: String)
 
   /**
    * Data for emitting an EnclosingMethod attribute. None if `classSym` is a member class (not

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

@@ -478,7 +478,7 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
      * Otherwise it's safe to call from multiple threads.
      */
     def genConstant(const: Constant): Unit = {
-      (const.tag: @switch) match {
+      (const.tag/*: @switch*/) match {
 
         case BooleanTag => bc.boolconst(const.booleanValue)
 
@@ -625,7 +625,7 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
         for (i <- args.length until dims) elemKind = ArrayBType(elemKind)
       }
       genLoadArguments(args, List.fill(args.size)(INT))
-      (argsSize : @switch) match {
+      (argsSize /*: @switch*/) match {
         case 1 => bc newarray elemKind
         case _ =>
           val descr = ("[" * argsSize) + elemKind.descriptor // denotes the same as: arrayN(elemKind, argsSize).descriptor
@@ -871,7 +871,7 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
 
       if(!int.shouldEmitJumpAfterLabels) genNormalBlock
       else {
-        val (prefixLabels: List[LabelDef], stats1) = stats.span {
+        val (prefixLabels: List[LabelDef] @unchecked, stats1) = stats.span {
           case t@LabelDef(_, _, _) => true
           case _ => false
         }
@@ -1221,7 +1221,7 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
         if (tk.isIntSizedType) { // BOOL, BYTE, CHAR, SHORT, or INT
           bc.emitIF(op, success)
         } else if (tk.isRef) { // REFERENCE(_) | ARRAY(_)
-          op match { // references are only compared with EQ and NE
+          (op: @unchecked) match { // references are only compared with EQ and NE
             case EQ => bc emitIFNULL    success
             case NE => bc emitIFNONNULL success
           }
@@ -1415,7 +1415,8 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
         new asm.Handle(invokeStyle,
           classBTypeFromSymbol(lambdaTarget.owner).internalName,
           lambdaTarget.name.mangledString,
-          asmMethodType(lambdaTarget).descriptor)
+          asmMethodType(lambdaTarget).descriptor,
+          invokeStyle == asm.Opcodes.H_INVOKEINTERFACE)
 
       val (a,b) = lambdaTarget.info.paramTypes.splitAt(environmentSize)
       var (capturedParamsTypes, lambdaParamTypes) = if(int.doLabmdasFollowJVMMetafactoryOrder) (a,b) else (b,a)
@@ -1445,6 +1446,7 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
   val lambdaMetaFactoryBootstrapHandle =
     new asm.Handle(asm.Opcodes.H_INVOKESTATIC,
       int.LambdaMetaFactory.javaBinaryName, int.MetafactoryName,
-      "(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;")
+      "(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;",
+      false)
 
 }

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,14 +382,14 @@ 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")
 
       val linkedClass  = moduleClass.companionClass
       lazy val conflictingNames: Set[Name] = {
         // Dotty deviation: needed to add ": Symbol" because of https://github.com/lampepfl/dotty/issues/2143
-        (linkedClass.info.members collect { case sym: Symbol if sym.name.isTermName => sym.name }).toSet
+        (linkedClass.info.members collect { case sym if sym.name.isTermName => sym.name }).toSet
       }
       debuglog(s"Potentially conflicting names for forwarders: $conflictingNames")
 
@@ -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/BCodeIdiomatic.scala

@@ -415,7 +415,7 @@ trait BCodeIdiomatic {
     }
 
     final def invokedynamic(owner: String, name: String, desc: String): Unit = {
-      jmethod.visitMethodInsn(Opcodes.INVOKEDYNAMIC, owner, name, desc)
+      jmethod.visitMethodInsn(Opcodes.INVOKEDYNAMIC, owner, name, desc, false)
      }
 
     // can-multi-thread

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/BTypes.scala

@@ -738,7 +738,7 @@ abstract class BTypes {
      * Custom equals / hashCode: we only compare the name (offset / length)
      */
     override def equals(o: Any): Boolean = (this eq o.asInstanceOf[Object]) || (o match {
-      case c: ClassBType => c.internalName == this.internalName
+      case c: ClassBType @unchecked => c.internalName == this.internalName
       case _ => false
     })
 
@@ -859,5 +859,5 @@ abstract class BTypes {
   /**
    * Just a named pair, used in CoreBTypes.asmBoxTo/asmUnboxTo.
    */
-  final case class MethodNameAndType(name: String, methodType: MethodBType)
+  /*final*/ case class MethodNameAndType(name: String, methodType: MethodBType)
 }

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)