From 76479b8770e053cde4468302e4082288ac107325 Mon Sep 17 00:00:00 2001 From: Arnout Engelen Date: Wed, 3 Apr 2019 13:13:44 +0200 Subject: [PATCH] [not for merge] Warnings as errors in akka-actor (#26634) Warnings as errors in akka-actor --- .../scala/akka/util/ByteIteratorSpec.scala | 36 +++++++++++++++++ .../typed/internal/routing/RoutingLogic.scala | 3 -- .../japi/function/Functions.scala.template | 4 ++ .../main/scala-2.12/akka/compat/Future.scala | 4 +- .../scala-2.12/akka/util/ByteIterator.scala | 12 ++++-- .../scala-2.13+/akka/util/ByteIterator.scala | 11 ++++-- .../scala-2.13+/akka/util/ByteString.scala | 32 +++++++-------- .../main/scala-2.13/akka/compat/Future.scala | 6 +-- .../main/scala/akka/actor/AbstractActor.scala | 2 + .../src/main/scala/akka/actor/ActorCell.scala | 2 + .../src/main/scala/akka/actor/ActorDSL.scala | 3 ++ .../src/main/scala/akka/actor/ActorPath.scala | 9 +++-- .../scala/akka/actor/ActorRefProvider.scala | 2 +- .../scala/akka/actor/ActorSelection.scala | 3 ++ .../main/scala/akka/actor/ActorSystem.scala | 4 +- .../src/main/scala/akka/actor/Deployer.scala | 4 ++ .../src/main/scala/akka/actor/FSM.scala | 3 +- .../main/scala/akka/actor/FaultHandling.scala | 1 + .../akka/actor/IndirectActorProducer.scala | 3 ++ .../akka/actor/ReflectiveDynamicAccess.scala | 2 +- .../akka/actor/RepointableActorRef.scala | 5 ++- .../src/main/scala/akka/actor/Scheduler.scala | 3 ++ .../src/main/scala/akka/actor/dsl/Inbox.scala | 5 +++ .../scala/akka/actor/dungeon/Children.scala | 7 ++-- .../actor/dungeon/ChildrenContainer.scala | 4 +- .../scala/akka/actor/dungeon/DeathWatch.scala | 2 + .../scala/akka/actor/dungeon/Dispatch.scala | 6 +-- .../akka/actor/dungeon/FaultHandling.scala | 1 + .../akka/dispatch/AbstractDispatcher.scala | 5 ++- .../main/scala/akka/dispatch/Dispatcher.scala | 8 ++++ .../scala/akka/dispatch/Dispatchers.scala | 4 ++ .../src/main/scala/akka/dispatch/Future.scala | 6 +++ .../main/scala/akka/event/EventStream.scala | 5 +++ .../src/main/scala/akka/event/Logging.scala | 19 +++++++-- akka-actor/src/main/scala/akka/io/Dns.scala | 1 + akka-actor/src/main/scala/akka/io/Tcp.scala | 20 +++++++++- .../main/scala/akka/io/TcpConnection.scala | 7 +++- .../scala/akka/io/TcpIncomingConnection.scala | 3 ++ akka-actor/src/main/scala/akka/io/Udp.scala | 6 +++ .../src/main/scala/akka/io/UdpConnected.scala | 4 ++ .../src/main/scala/akka/io/UdpSender.scala | 3 ++ .../main/scala/akka/io/dns/DnsSettings.scala | 1 + .../akka/io/dns/internal/DnsClient.scala | 18 ++++++--- .../akka/io/dns/internal/DnsMessage.scala | 2 + .../akka/io/dns/internal/DomainName.scala | 2 +- .../src/main/scala/akka/japi/JavaAPI.scala | 5 ++- .../scala/akka/japi/function/Function.scala | 8 ++++ .../main/scala/akka/pattern/AskSupport.scala | 4 ++ .../src/main/scala/akka/pattern/Backoff.scala | 2 + .../scala/akka/pattern/CircuitBreaker.scala | 7 +++- .../scala/akka/pattern/HandleBackoff.scala | 3 +- .../main/scala/akka/routing/Balancing.scala | 2 + .../main/scala/akka/routing/Broadcast.scala | 2 + .../main/scala/akka/routing/MurmurHash.scala | 4 ++ .../src/main/scala/akka/routing/Random.scala | 3 ++ .../main/scala/akka/routing/RoundRobin.scala | 3 ++ .../scala/akka/routing/RoutedActorCell.scala | 1 + .../scala/akka/routing/RoutedActorRef.scala | 2 + .../scala/akka/routing/RouterConfig.scala | 10 ++++- .../routing/ScatterGatherFirstCompleted.scala | 4 +- .../scala/akka/routing/SmallestMailbox.scala | 6 +++ .../scala/akka/routing/TailChopping.scala | 4 +- .../akka/serialization/Serialization.scala | 1 + .../main/scala/akka/util/ManifestInfo.scala | 2 + .../scala/akka/util/SubclassifiedIndex.scala | 1 + .../metrics/ClusterMetricsRouting.scala | 5 +++ .../transport/AbstractTransportAdapter.scala | 2 +- project/AkkaDisciplinePlugin.scala | 39 +++++++++---------- 68 files changed, 313 insertions(+), 100 deletions(-) create mode 100644 akka-actor-tests/src/test/scala/akka/util/ByteIteratorSpec.scala diff --git a/akka-actor-tests/src/test/scala/akka/util/ByteIteratorSpec.scala b/akka-actor-tests/src/test/scala/akka/util/ByteIteratorSpec.scala new file mode 100644 index 0000000000..db7d717f7e --- /dev/null +++ b/akka-actor-tests/src/test/scala/akka/util/ByteIteratorSpec.scala @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2019 Lightbend Inc. + */ + +package akka.util + +import akka.util.ByteIterator.ByteArrayIterator +import org.scalatest._ + +class ByteIteratorSpec extends WordSpec with Matchers { + "A ByteIterator" should { + + "correctly implement indexOf" in { + // Since the 'indexOf' operator invalidates the iterator, + // we must create a new one for each test: + def freshIterator(): ByteIterator = ByteArrayIterator(Array(0x20, 0x20, 0x10, 0x20, 0x20, 0x10)) + freshIterator().indexOf(0x20) should be(0) + freshIterator().indexOf(0x10) should be(2) + + freshIterator().indexOf(0x20, 1) should be(1) + freshIterator().indexOf(0x10, 1) should be(2) + freshIterator().indexOf(0x10, 3) should be(5) + + // There is also an indexOf with another signature, which is hard to invoke :D + def otherIndexOf(iterator: ByteIterator, byte: Byte, from: Int): Int = + classOf[ByteIterator] + .getMethod("indexOf", classOf[Byte], classOf[Int]) + .invoke(iterator, byte.asInstanceOf[Object], from.asInstanceOf[Object]) + .asInstanceOf[Int] + + otherIndexOf(freshIterator(), 0x20, 1) should be(1) + otherIndexOf(freshIterator(), 0x10, 1) should be(2) + otherIndexOf(freshIterator(), 0x10, 3) should be(5) + } + } +} diff --git a/akka-actor-typed/src/main/scala/akka/actor/typed/internal/routing/RoutingLogic.scala b/akka-actor-typed/src/main/scala/akka/actor/typed/internal/routing/RoutingLogic.scala index c79ca914fc..06198f813f 100644 --- a/akka-actor-typed/src/main/scala/akka/actor/typed/internal/routing/RoutingLogic.scala +++ b/akka-actor-typed/src/main/scala/akka/actor/typed/internal/routing/RoutingLogic.scala @@ -16,9 +16,6 @@ import akka.dispatch.forkjoin.ThreadLocalRandom @InternalApi sealed private[akka] trait RoutingLogic[T] { - /** - * @param routees available routees, will contain at least one element. Must not be mutated by select logic. - */ def selectRoutee(): ActorRef[T] /** diff --git a/akka-actor/src/main/boilerplate/akka/japi/function/Functions.scala.template b/akka-actor/src/main/boilerplate/akka/japi/function/Functions.scala.template index a9519358ad..43f5a47b8c 100644 --- a/akka-actor/src/main/boilerplate/akka/japi/function/Functions.scala.template +++ b/akka-actor/src/main/boilerplate/akka/japi/function/Functions.scala.template @@ -4,10 +4,13 @@ package akka.japi.function +import com.github.ghik.silencer.silent + [3..22#/** * A Function interface. Used to create 1-arg first-class-functions is Java. * `Serializable` is needed to be able to grab line number for Java 8 lambdas. */ +@silent @SerialVersionUID(##1L) trait Function1[[#-T1#], +R] extends java.io.Serializable { @throws(classOf[Exception]) @@ -21,6 +24,7 @@ trait Function1[[#-T1#], +R] extends java.io.Serializable { * A Procedure is like a Function, but it doesn't produce a return value. * `Serializable` is needed to be able to grab line number for Java 8 lambdas. */ +@silent @SerialVersionUID(##1L) trait Procedure1[[#-T1#]] extends java.io.Serializable { @throws(classOf[Exception]) diff --git a/akka-actor/src/main/scala-2.12/akka/compat/Future.scala b/akka-actor/src/main/scala-2.12/akka/compat/Future.scala index b7d9f947aa..6ce86517ab 100644 --- a/akka-actor/src/main/scala-2.12/akka/compat/Future.scala +++ b/akka-actor/src/main/scala-2.12/akka/compat/Future.scala @@ -5,9 +5,11 @@ package akka.compat import akka.annotation.InternalApi + import scala.concurrent.{ ExecutionContext, Future => SFuture } import scala.collection.immutable import akka.util.ccompat._ +import com.github.ghik.silencer.silent /** * INTERNAL API @@ -17,7 +19,7 @@ import akka.util.ccompat._ * * Remove these classes as soon as support for Scala 2.11 is dropped! */ -@InternalApi private[akka] object Future { +@silent @InternalApi private[akka] object Future { def fold[T, R](futures: IterableOnce[SFuture[T]])(zero: R)(op: (R, T) => R)( implicit executor: ExecutionContext): SFuture[R] = SFuture.fold[T, R](futures)(zero)(op)(executor) diff --git a/akka-actor/src/main/scala-2.12/akka/util/ByteIterator.scala b/akka-actor/src/main/scala-2.12/akka/util/ByteIterator.scala index 9849bc7523..420a6b3fa7 100644 --- a/akka-actor/src/main/scala-2.12/akka/util/ByteIterator.scala +++ b/akka-actor/src/main/scala-2.12/akka/util/ByteIterator.scala @@ -277,8 +277,8 @@ object ByteIterator { final override def takeWhile(p: Byte => Boolean): this.type = { var stop = false - var builder = new ListBuffer[ByteArrayIterator] - while (!stop && !iterators.isEmpty) { + val builder = new ListBuffer[ByteArrayIterator] + while (!stop && iterators.nonEmpty) { val lastLen = current.len current.takeWhile(p) if (current.hasNext) builder += current @@ -460,7 +460,11 @@ abstract class ByteIterator extends BufferedIterator[Byte] { override def indexWhere(p: Byte => Boolean): Int = indexWhere(p, 0) override def indexWhere(p: Byte => Boolean, from: Int): Int = { - var index = from + var index = 0 + while (index < from) { + next() + index += 1 + } var found = false while (!found && hasNext) if (p(next())) { found = true @@ -471,7 +475,7 @@ abstract class ByteIterator extends BufferedIterator[Byte] { } def indexOf(elem: Byte): Int = indexOf(elem, 0) - def indexOf(elem: Byte, from: Int): Int = indexWhere(_ == elem, 0) + def indexOf(elem: Byte, from: Int): Int = indexWhere(_ == elem, from) override def indexOf[B >: Byte](elem: B): Int = indexOf[B](elem, 0) override def indexOf[B >: Byte](elem: B, from: Int): Int = indexWhere(_ == elem, from) diff --git a/akka-actor/src/main/scala-2.13+/akka/util/ByteIterator.scala b/akka-actor/src/main/scala-2.13+/akka/util/ByteIterator.scala index 5229ffdd12..80e74366e5 100644 --- a/akka-actor/src/main/scala-2.13+/akka/util/ByteIterator.scala +++ b/akka-actor/src/main/scala-2.13+/akka/util/ByteIterator.scala @@ -9,10 +9,10 @@ import akka.util.Collections.EmptyImmutableSeq import java.nio.{ ByteBuffer, ByteOrder } import scala.annotation.tailrec +import scala.collection.BufferedIterator import scala.collection.LinearSeq import scala.collection.mutable.ListBuffer import scala.reflect.ClassTag -import akka.util.ccompat._ object ByteIterator { object ByteArrayIterator { @@ -280,7 +280,7 @@ object ByteIterator { final override def takeWhile(p: Byte => Boolean): this.type = { var stop = false - var builder = new ListBuffer[ByteArrayIterator] + val builder = new ListBuffer[ByteArrayIterator] while (!stop && !iterators.isEmpty) { val lastLen = current.len current.takeWhile(p) @@ -415,8 +415,11 @@ abstract class ByteIterator extends BufferedIterator[Byte] { protected def clear(): Unit - def ++(that: IterableOnce[Byte]): ByteIterator = - if (that.isEmpty) this else ByteIterator.ByteArrayIterator(that.toArray) + def ++(that: IterableOnce[Byte]): ByteIterator = { + val it = that.iterator + if (it.isEmpty) this + else ByteIterator.ByteArrayIterator(it.toArray) + } // *must* be overridden by derived classes. This construction is necessary // to specialize the return type, as the method is already implemented in diff --git a/akka-actor/src/main/scala-2.13+/akka/util/ByteString.scala b/akka-actor/src/main/scala-2.13+/akka/util/ByteString.scala index 2b2743782e..bfe4d9b5ad 100644 --- a/akka-actor/src/main/scala-2.13+/akka/util/ByteString.scala +++ b/akka-actor/src/main/scala-2.13+/akka/util/ByteString.scala @@ -4,8 +4,6 @@ package akka.util -import akka.compat._ - import java.io.{ ObjectInputStream, ObjectOutputStream } import java.nio.{ ByteBuffer, ByteOrder } import java.lang.{ Iterable => JIterable } @@ -14,10 +12,8 @@ import scala.annotation.{ tailrec, varargs } import scala.collection.mutable.{ Builder, WrappedArray } import scala.collection.{ immutable, mutable } import scala.collection.immutable.{ IndexedSeq, IndexedSeqOps, StrictOptimizedSeqOps, VectorBuilder } -import scala.collection.generic.CanBuildFrom import scala.reflect.ClassTag import java.nio.charset.{ Charset, StandardCharsets } -import akka.util.ccompat._ object ByteString { @@ -214,7 +210,6 @@ object ByteString { if (n <= 0) this else toByteString1.drop(n) - override def indexOf[B >: Byte](elem: B): Int = indexOf(elem, 0) override def indexOf[B >: Byte](elem: B, from: Int): Int = { if (from >= length) -1 else { @@ -373,7 +368,6 @@ object ByteString { } } - override def indexOf[B >: Byte](elem: B): Int = indexOf(elem, 0) override def indexOf[B >: Byte](elem: B, from: Int): Int = { if (from >= length) -1 else { @@ -392,7 +386,7 @@ object ByteString { private[akka] object ByteStrings extends Companion { def apply(bytestrings: Vector[ByteString1]): ByteString = - new ByteStrings(bytestrings, (0 /: bytestrings)(_ + _.length)) + new ByteStrings(bytestrings, bytestrings.foldLeft(0)(_ + _.length)) def apply(bytestrings: Vector[ByteString1], length: Int): ByteString = new ByteStrings(bytestrings, length) @@ -474,7 +468,7 @@ object ByteString { /** Avoid `iterator` in performance sensitive code, call ops directly on ByteString instead */ override def iterator: ByteIterator.MultiByteArrayIterator = - ByteIterator.MultiByteArrayIterator(bytestrings.toStream.map { _.iterator }) + ByteIterator.MultiByteArrayIterator(bytestrings.to(LazyList).map { _.iterator }) def ++(that: ByteString): ByteString = { if (that.isEmpty) this @@ -602,7 +596,6 @@ object ByteString { new ByteStrings(bytestrings(fullDrops).drop1(remainingToDrop) +: bytestrings.drop(fullDrops + 1), length - n) } - override def indexOf[B >: Byte](elem: B): Int = indexOf(elem, 0) override def indexOf[B >: Byte](elem: B, from: Int): Int = { if (from >= length) -1 else { @@ -635,12 +628,12 @@ object ByteString { @SerialVersionUID(1L) private class SerializationProxy(@transient private var orig: ByteString) extends Serializable { - private def writeObject(out: ObjectOutputStream) { + private def writeObject(out: ObjectOutputStream): Unit = { out.writeByte(orig.byteStringCompanion.SerializationIdentity) orig.writeToOutputStream(out) } - private def readObject(in: ObjectInputStream) { + private def readObject(in: ObjectInputStream): Unit = { val serializationId = in.readByte() orig = Companion(from = serializationId).readFromInputStream(in) @@ -731,10 +724,10 @@ sealed abstract class ByteString override def splitAt(n: Int): (ByteString, ByteString) = (take(n), drop(n)) - override def indexWhere(p: Byte => Boolean): Int = iterator.indexWhere(p) + override def indexWhere(p: Byte => Boolean, from: Int): Int = iterator.indexWhere(p, from) // optimized in subclasses - override def indexOf[B >: Byte](elem: B): Int = indexOf(elem, 0) + override def indexOf[B >: Byte](elem: B, from: Int): Int = indexOf(elem, from) override def grouped(size: Int): Iterator[ByteString] = { if (size <= 0) { @@ -784,9 +777,7 @@ sealed abstract class ByteString * @param buffer a ByteBuffer to copy bytes to * @return the number of bytes actually copied */ - // *must* be overridden by derived classes. - def copyToBuffer(buffer: ByteBuffer): Int = - throw new UnsupportedOperationException("Method copyToBuffer is not implemented in ByteString") + def copyToBuffer(@unused buffer: ByteBuffer): Int /** * Create a new ByteString with all contents compacted into a single, @@ -879,8 +870,11 @@ object CompactByteString { /** * Creates a new CompactByteString by traversing bytes. */ - def apply(bytes: IterableOnce[Byte]): CompactByteString = - if (bytes.isEmpty) empty else ByteString.ByteString1C(bytes.toArray) + def apply(bytes: IterableOnce[Byte]): CompactByteString = { + val it = bytes.iterator + if (it.isEmpty) empty + else ByteString.ByteString1C(it.toArray) + } /** * Creates a new CompactByteString by converting from integral numbers to bytes. @@ -1022,7 +1016,7 @@ final class ByteStringBuilder extends Builder[Byte, ByteString] { override def addAll(xs: IterableOnce[Byte]): this.type = { xs match { - case _ if xs.isEmpty => + case _ if xs.iterator.isEmpty => // do nothing case b: ByteString1C => clearTemp() diff --git a/akka-actor/src/main/scala-2.13/akka/compat/Future.scala b/akka-actor/src/main/scala-2.13/akka/compat/Future.scala index c3b4869f09..e600f25174 100644 --- a/akka-actor/src/main/scala-2.13/akka/compat/Future.scala +++ b/akka-actor/src/main/scala-2.13/akka/compat/Future.scala @@ -20,7 +20,7 @@ import scala.collection.immutable def fold[T, R](futures: IterableOnce[SFuture[T]])(zero: R)(op: (R, T) => R)( implicit executor: ExecutionContext): SFuture[R] = { // This will have performance implications since the elements are copied to a Vector - SFuture.foldLeft[T, R](futures.to(immutable.Iterable))(zero)(op)(executor) + SFuture.foldLeft[T, R](futures.iterator.to(immutable.Iterable))(zero)(op)(executor) } def fold[T, R](futures: immutable.Iterable[SFuture[T]])(zero: R)(op: (R, T) => R)( @@ -30,7 +30,7 @@ import scala.collection.immutable def reduce[T, R >: T](futures: IterableOnce[SFuture[T]])(op: (R, T) => R)( implicit executor: ExecutionContext): SFuture[R] = { // This will have performance implications since the elements are copied to a Vector - SFuture.reduceLeft[T, R](futures.to(immutable.Iterable))(op)(executor) + SFuture.reduceLeft[T, R](futures.iterator.to(immutable.Iterable))(op)(executor) } def reduce[T, R >: T](futures: immutable.Iterable[SFuture[T]])(op: (R, T) => R)( @@ -40,7 +40,7 @@ import scala.collection.immutable def find[T](futures: IterableOnce[SFuture[T]])(p: T => Boolean)( implicit executor: ExecutionContext): SFuture[Option[T]] = { // This will have performance implications since the elements are copied to a Vector - SFuture.find[T](futures.to(immutable.Iterable))(p)(executor) + SFuture.find[T](futures.iterator.to(immutable.Iterable))(p)(executor) } def find[T](futures: immutable.Iterable[SFuture[T]])(p: T => Boolean)( diff --git a/akka-actor/src/main/scala/akka/actor/AbstractActor.scala b/akka-actor/src/main/scala/akka/actor/AbstractActor.scala index 8264bd21b7..b3e05127c5 100644 --- a/akka-actor/src/main/scala/akka/actor/AbstractActor.scala +++ b/akka-actor/src/main/scala/akka/actor/AbstractActor.scala @@ -11,6 +11,7 @@ import scala.runtime.BoxedUnit import java.util.Optional import akka.util.JavaDurationConverters +import com.github.ghik.silencer.silent import scala.concurrent.ExecutionContextExecutor import scala.concurrent.duration.Duration @@ -279,6 +280,7 @@ abstract class AbstractActor extends Actor { // TODO In 2.6.0 we can remove deprecation and make the method final @deprecated("Override preRestart with message parameter with Optional type instead", "2.5.0") @throws(classOf[Exception]) + @silent override def preRestart(reason: Throwable, message: Option[Any]): Unit = { import scala.compat.java8.OptionConverters._ preRestart(reason, message.asJava) diff --git a/akka-actor/src/main/scala/akka/actor/ActorCell.scala b/akka-actor/src/main/scala/akka/actor/ActorCell.scala index 9653b256d0..d548c4b6aa 100644 --- a/akka-actor/src/main/scala/akka/actor/ActorCell.scala +++ b/akka-actor/src/main/scala/akka/actor/ActorCell.scala @@ -19,6 +19,7 @@ import akka.event.Logging.{ Debug, Error, LogEvent } import akka.japi.Procedure import akka.util.{ unused, Reflect } import akka.annotation.InternalApi +import com.github.ghik.silencer.silent /** * The actor context - the view of the actor cell from the actor. @@ -442,6 +443,7 @@ private[akka] object ActorCell { * supported APIs in this place. This is not the API you were looking * for! (waves hand) */ +@silent private[akka] class ActorCell( val system: ActorSystemImpl, val self: InternalActorRef, diff --git a/akka-actor/src/main/scala/akka/actor/ActorDSL.scala b/akka-actor/src/main/scala/akka/actor/ActorDSL.scala index e026f02af0..787d240808 100644 --- a/akka-actor/src/main/scala/akka/actor/ActorDSL.scala +++ b/akka-actor/src/main/scala/akka/actor/ActorDSL.scala @@ -6,9 +6,11 @@ package akka.actor import scala.concurrent.duration._ import akka.pattern.ask + import scala.concurrent.Await import akka.util.Helpers.ConfigOps import akka.util.JavaDurationConverters._ +import com.github.ghik.silencer.silent /** * This object contains elements which make writing actors and related code @@ -164,5 +166,6 @@ object Inbox { /** * Create a new Inbox within the given system. */ + @silent def create(system: ActorSystem): Inbox = ActorDSL.inbox()(system) } diff --git a/akka-actor/src/main/scala/akka/actor/ActorPath.scala b/akka-actor/src/main/scala/akka/actor/ActorPath.scala index 599bc0a0d2..75000d735d 100644 --- a/akka-actor/src/main/scala/akka/actor/ActorPath.scala +++ b/akka-actor/src/main/scala/akka/actor/ActorPath.scala @@ -9,6 +9,8 @@ import akka.japi.Util.immutableSeq import java.net.MalformedURLException import java.lang.{ StringBuilder => JStringBuilder } +import com.github.ghik.silencer.silent + /** * Java API */ @@ -149,6 +151,7 @@ object ActorPath { * references are compared the unique id of the actor is not taken into account * when comparing actor paths. */ +@silent @SerialVersionUID(1L) sealed trait ActorPath extends Comparable[ActorPath] with Serializable { @@ -274,13 +277,13 @@ final case class RootActorPath(address: Address, name: String = "/") extends Act override def elements: immutable.Iterable[String] = ActorPath.emptyActorPath - override val toString: String = address + name + override val toString: String = address.toString + name override val toSerializationFormat: String = toString override def toStringWithAddress(addr: Address): String = - if (address.host.isDefined) address + name - else addr + name + if (address.host.isDefined) address.toString + name + else addr.toString + name override def toSerializationFormatWithAddress(addr: Address): String = toStringWithAddress(addr) diff --git a/akka-actor/src/main/scala/akka/actor/ActorRefProvider.scala b/akka-actor/src/main/scala/akka/actor/ActorRefProvider.scala index 4ff3e2a120..0c26a0bcd5 100644 --- a/akka-actor/src/main/scala/akka/actor/ActorRefProvider.scala +++ b/akka-actor/src/main/scala/akka/actor/ActorRefProvider.scala @@ -532,7 +532,7 @@ private[akka] class LocalActorRefProvider private[akka] ( override def stop(): Unit = { causeOfTermination.trySuccess( Terminated(provider.rootGuardian)(existenceConfirmed = true, addressTerminated = true)) //Idempotent - terminationPromise.tryCompleteWith(causeOfTermination.future) // Signal termination downstream, idempotent + terminationPromise.completeWith(causeOfTermination.future) // Signal termination downstream, idempotent } @deprecated("Use context.watch(actor) and receive Terminated(actor)", "2.2") diff --git a/akka-actor/src/main/scala/akka/actor/ActorSelection.scala b/akka-actor/src/main/scala/akka/actor/ActorSelection.scala index 243bc33869..988b73f035 100644 --- a/akka-actor/src/main/scala/akka/actor/ActorSelection.scala +++ b/akka-actor/src/main/scala/akka/actor/ActorSelection.scala @@ -23,12 +23,14 @@ import akka.dispatch.ExecutionContexts import scala.compat.java8.FutureConverters import akka.util.ccompat._ +import com.github.ghik.silencer.silent /** * An ActorSelection is a logical view of a section of an ActorSystem's tree of Actors, * allowing for broadcasting of messages to that section. */ @SerialVersionUID(1L) +@ccompatUsedUntil213 abstract class ActorSelection extends Serializable { this: ScalaActorSelection => @@ -324,6 +326,7 @@ private[akka] final case class ActorSelectionMessage( /** * INTERNAL API */ +@silent @SerialVersionUID(1L) private[akka] sealed trait SelectionPathElement diff --git a/akka-actor/src/main/scala/akka/actor/ActorSystem.scala b/akka-actor/src/main/scala/akka/actor/ActorSystem.scala index 69d6e42dee..1b89323ab9 100644 --- a/akka-actor/src/main/scala/akka/actor/ActorSystem.scala +++ b/akka-actor/src/main/scala/akka/actor/ActorSystem.scala @@ -9,7 +9,7 @@ import java.util.concurrent._ import java.util.concurrent.atomic.AtomicReference import com.typesafe.config.{ Config, ConfigFactory } -import akka.event.{ LoggingFilterWithMarker, _ } +import akka.event._ import akka.dispatch._ import akka.japi.Util.immutableSeq import akka.actor.dungeon.ChildrenContainer @@ -1081,7 +1081,7 @@ private[akka] class ActorSystemImpl( (toDie.toSeq.sorted.mkString("\n" + indent + " | toDie: ", "\n" + indent + " | ", "")) case x @ (ChildrenContainer.TerminatedChildrenContainer | ChildrenContainer.EmptyChildrenContainer) => x.toString - case n: ChildrenContainer.NormalChildrenContainer => n.c.size + " children" + case n: ChildrenContainer.NormalChildrenContainer => n.c.size.toString + " children" case x => Logging.simpleName(x) }) + (if (cell.childrenRefs.children.isEmpty) "" else "\n") + diff --git a/akka-actor/src/main/scala/akka/actor/Deployer.scala b/akka-actor/src/main/scala/akka/actor/Deployer.scala index a5e7bcf0f0..4bac7fda1c 100644 --- a/akka-actor/src/main/scala/akka/actor/Deployer.scala +++ b/akka-actor/src/main/scala/akka/actor/Deployer.scala @@ -8,6 +8,7 @@ import java.util.concurrent.atomic.AtomicReference import akka.routing._ import akka.util.WildcardIndex +import com.github.ghik.silencer.silent import com.typesafe.config._ import scala.annotation.tailrec @@ -92,6 +93,7 @@ trait Scope { def withFallback(other: Scope): Scope } +@silent @SerialVersionUID(1L) abstract class LocalScope extends Scope @@ -100,6 +102,7 @@ abstract class LocalScope extends Scope * which do not set a different scope. It is also the only scope handled by * the LocalActorRefProvider. */ +@silent @SerialVersionUID(1L) case object LocalScope extends LocalScope { @@ -114,6 +117,7 @@ case object LocalScope extends LocalScope { /** * This is the default value and as such allows overrides. */ +@silent @SerialVersionUID(1L) abstract class NoScopeGiven extends Scope @SerialVersionUID(1L) diff --git a/akka-actor/src/main/scala/akka/actor/FSM.scala b/akka-actor/src/main/scala/akka/actor/FSM.scala index fcc32202f7..20981f4289 100644 --- a/akka-actor/src/main/scala/akka/actor/FSM.scala +++ b/akka-actor/src/main/scala/akka/actor/FSM.scala @@ -9,10 +9,10 @@ import scala.concurrent.duration.Duration import scala.collection.mutable import scala.concurrent.duration.FiniteDuration import scala.concurrent.duration._ - import akka.routing.{ Deafen, Listen, Listeners } import akka.annotation.InternalApi import akka.util.{ unused, JavaDurationConverters } +import com.github.ghik.silencer.silent object FSM { @@ -225,6 +225,7 @@ object FSM { * Modify state transition descriptor with new state data. The data will be * set when transitioning to the new state. */ + @silent def using(@deprecatedName('nextStateDate) nextStateData: D): State[S, D] = { copy(stateData = nextStateData) } diff --git a/akka-actor/src/main/scala/akka/actor/FaultHandling.scala b/akka-actor/src/main/scala/akka/actor/FaultHandling.scala index 9a79ec98b3..b01a4bf35d 100644 --- a/akka-actor/src/main/scala/akka/actor/FaultHandling.scala +++ b/akka-actor/src/main/scala/akka/actor/FaultHandling.scala @@ -33,6 +33,7 @@ private[akka] case object ChildNameReserved extends ChildStats * ChildRestartStats is the statistics kept by every parent Actor for every child Actor * and is used for SupervisorStrategies to know how to deal with problems that occur for the children. */ +@ccompatUsedUntil213 final case class ChildRestartStats( child: ActorRef, var maxNrOfRetriesCount: Int = 0, diff --git a/akka-actor/src/main/scala/akka/actor/IndirectActorProducer.scala b/akka-actor/src/main/scala/akka/actor/IndirectActorProducer.scala index 0e82b15e64..d8519a703d 100644 --- a/akka-actor/src/main/scala/akka/actor/IndirectActorProducer.scala +++ b/akka-actor/src/main/scala/akka/actor/IndirectActorProducer.scala @@ -6,6 +6,8 @@ package akka.actor import akka.japi.Creator import akka.util.Reflect +import com.github.ghik.silencer.silent + import scala.collection.immutable /** @@ -40,6 +42,7 @@ private[akka] object IndirectActorProducer { val CreatorConsumerClass = classOf[CreatorConsumer] val TypedCreatorFunctionConsumerClass = classOf[TypedCreatorFunctionConsumer] + @silent def apply(clazz: Class[_], args: immutable.Seq[Any]): IndirectActorProducer = { if (classOf[IndirectActorProducer].isAssignableFrom(clazz)) { def get1stArg[T]: T = args.head.asInstanceOf[T] diff --git a/akka-actor/src/main/scala/akka/actor/ReflectiveDynamicAccess.scala b/akka-actor/src/main/scala/akka/actor/ReflectiveDynamicAccess.scala index f15086894e..91f6c03bf4 100644 --- a/akka-actor/src/main/scala/akka/actor/ReflectiveDynamicAccess.scala +++ b/akka-actor/src/main/scala/akka/actor/ReflectiveDynamicAccess.scala @@ -21,7 +21,7 @@ class ReflectiveDynamicAccess(val classLoader: ClassLoader) extends DynamicAcces Try[Class[_ <: T]]({ val c = Class.forName(fqcn, false, classLoader).asInstanceOf[Class[_ <: T]] val t = implicitly[ClassTag[T]].runtimeClass - if (t.isAssignableFrom(c)) c else throw new ClassCastException(t + " is not assignable from " + c) + if (t.isAssignableFrom(c)) c else throw new ClassCastException(t.toString + " is not assignable from " + c) }) override def createInstanceFor[T: ClassTag](clazz: Class[_], args: immutable.Seq[(Class[_], AnyRef)]): Try[T] = diff --git a/akka-actor/src/main/scala/akka/actor/RepointableActorRef.scala b/akka-actor/src/main/scala/akka/actor/RepointableActorRef.scala index 016a582dc0..f9496b8495 100644 --- a/akka-actor/src/main/scala/akka/actor/RepointableActorRef.scala +++ b/akka-actor/src/main/scala/akka/actor/RepointableActorRef.scala @@ -14,6 +14,7 @@ import akka.event.Logging.Warning import akka.util.{ unused, Unsafe } import akka.dispatch._ import akka.dispatch.sysmsg._ +import com.github.ghik.silencer.silent import scala.util.control.NonFatal @@ -47,8 +48,8 @@ private[akka] class RepointableActorRef( * processing the very first message (i.e. before Cell.start()). Hence there * are two refs here, one for each function, and they are switched just so. */ - @volatile private var _cellDoNotCallMeDirectly: Cell = _ - @volatile private var _lookupDoNotCallMeDirectly: Cell = _ + @silent @volatile private var _cellDoNotCallMeDirectly: Cell = _ + @silent @volatile private var _lookupDoNotCallMeDirectly: Cell = _ def underlying: Cell = Unsafe.instance.getObjectVolatile(this, cellOffset).asInstanceOf[Cell] def lookup = Unsafe.instance.getObjectVolatile(this, lookupOffset).asInstanceOf[Cell] diff --git a/akka-actor/src/main/scala/akka/actor/Scheduler.scala b/akka-actor/src/main/scala/akka/actor/Scheduler.scala index 193a48dec7..3322676eaa 100644 --- a/akka-actor/src/main/scala/akka/actor/Scheduler.scala +++ b/akka-actor/src/main/scala/akka/actor/Scheduler.scala @@ -5,6 +5,8 @@ package akka.actor import akka.util.JavaDurationConverters +import com.github.ghik.silencer.silent + import scala.concurrent.ExecutionContext import scala.concurrent.duration._ import scala.util.control.NoStackTrace @@ -47,6 +49,7 @@ trait Scheduler { * * Java & Scala API */ + @silent final def schedule(initialDelay: FiniteDuration, interval: FiniteDuration, receiver: ActorRef, message: Any)( implicit executor: ExecutionContext, diff --git a/akka-actor/src/main/scala/akka/actor/dsl/Inbox.scala b/akka-actor/src/main/scala/akka/actor/dsl/Inbox.scala index c13daed70a..c707bee1a1 100644 --- a/akka-actor/src/main/scala/akka/actor/dsl/Inbox.scala +++ b/akka-actor/src/main/scala/akka/actor/dsl/Inbox.scala @@ -6,10 +6,12 @@ package akka.actor.dsl import scala.concurrent.Await import akka.actor.ActorLogging + import scala.collection.immutable.TreeSet import scala.concurrent.duration._ import akka.actor.Cancellable import akka.actor.Actor + import scala.collection.mutable.Queue import akka.actor.ActorSystem import akka.actor.ActorRef @@ -17,9 +19,11 @@ import akka.util.Timeout import akka.actor.Status import java.util.concurrent.TimeoutException import java.util.concurrent.atomic.AtomicInteger + import akka.pattern.ask import akka.actor.ActorDSL import akka.actor.Props +import com.github.ghik.silencer.silent /** * INTERNAL API @@ -43,6 +47,7 @@ private[akka] object Inbox { } +@silent trait Inbox { this: ActorDSL.type => import Inbox._ diff --git a/akka-actor/src/main/scala/akka/actor/dungeon/Children.scala b/akka-actor/src/main/scala/akka/actor/dungeon/Children.scala index 53a6fafdeb..83e876bfad 100644 --- a/akka-actor/src/main/scala/akka/actor/dungeon/Children.scala +++ b/akka-actor/src/main/scala/akka/actor/dungeon/Children.scala @@ -9,10 +9,10 @@ import java.util.Optional import scala.annotation.tailrec import scala.util.control.NonFatal import scala.collection.immutable - import akka.actor._ import akka.serialization.{ Serialization, SerializationExtension, Serializers } import akka.util.{ Helpers, Unsafe } +import com.github.ghik.silencer.silent private[akka] object Children { val GetNobody = () => Nobody @@ -22,6 +22,7 @@ private[akka] trait Children { this: ActorCell => import ChildrenContainer._ + @silent @volatile private var _childrenRefsDoNotCallMeDirectly: ChildrenContainer = EmptyChildrenContainer @@ -48,7 +49,7 @@ private[akka] trait Children { this: ActorCell => private[akka] def attachChild(props: Props, name: String, systemService: Boolean): ActorRef = makeChild(this, props, checkName(name), async = true, systemService = systemService) - @volatile private var _functionRefsDoNotCallMeDirectly = Map.empty[String, FunctionRef] + @silent @volatile private var _functionRefsDoNotCallMeDirectly = Map.empty[String, FunctionRef] private def functionRefs: Map[String, FunctionRef] = Unsafe.instance.getObjectVolatile(this, AbstractActorCell.functionRefsOffset).asInstanceOf[Map[String, FunctionRef]] @@ -101,7 +102,7 @@ private[akka] trait Children { this: ActorCell => refs.valuesIterator.foreach(_.stop()) } - @volatile private var _nextNameDoNotCallMeDirectly = 0L + @silent @volatile private var _nextNameDoNotCallMeDirectly = 0L final protected def randomName(sb: java.lang.StringBuilder): String = { val num = Unsafe.instance.getAndAddLong(this, AbstractActorCell.nextNameOffset, 1) Helpers.base64(num, sb) diff --git a/akka-actor/src/main/scala/akka/actor/dungeon/ChildrenContainer.scala b/akka-actor/src/main/scala/akka/actor/dungeon/ChildrenContainer.scala index 1f0f97a61e..540ca9fda6 100644 --- a/akka-actor/src/main/scala/akka/actor/dungeon/ChildrenContainer.scala +++ b/akka-actor/src/main/scala/akka/actor/dungeon/ChildrenContainer.scala @@ -140,7 +140,7 @@ private[akka] object ChildrenContainer { } override def toString = - if (c.size > 20) c.size + " children" + if (c.size > 20) c.size.toString + " children" else c.mkString("children:\n ", "\n ", "") } @@ -208,7 +208,7 @@ private[akka] object ChildrenContainer { override def isNormal: Boolean = reason == UserRequest override def toString = - if (c.size > 20) c.size + " children" + if (c.size > 20) c.size.toString + " children" else c.mkString("children (" + toDie.size + " terminating):\n ", "\n ", "\n") + toDie } diff --git a/akka-actor/src/main/scala/akka/actor/dungeon/DeathWatch.scala b/akka-actor/src/main/scala/akka/actor/dungeon/DeathWatch.scala index 55eb44113a..978ad8fcf5 100644 --- a/akka-actor/src/main/scala/akka/actor/dungeon/DeathWatch.scala +++ b/akka-actor/src/main/scala/akka/actor/dungeon/DeathWatch.scala @@ -9,6 +9,7 @@ import akka.event.Logging.{ Debug, Warning } import akka.actor.{ Actor, ActorCell, ActorRef, ActorRefScope, Address, InternalActorRef, MinimalActorRef, Terminated } import akka.event.AddressTerminatedTopic import akka.util.unused +import com.github.ghik.silencer.silent private[akka] trait DeathWatch { this: ActorCell => @@ -112,6 +113,7 @@ private[akka] trait DeathWatch { this: ActorCell => // TODO this should be removed and be replaced with `set - subject` // when all actor references have uid, i.e. actorFor is removed + @silent private def removeFromMap[T](subject: ActorRef, map: Map[ActorRef, T]): Map[ActorRef, T] = if (subject.path.uid != ActorCell.undefinedUid) (map - subject) - new UndefinedUidActorRef(subject) else map.filterKeys(_.path != subject.path).toMap diff --git a/akka-actor/src/main/scala/akka/actor/dungeon/Dispatch.scala b/akka-actor/src/main/scala/akka/actor/dungeon/Dispatch.scala index 2520ccbfde..db94a34544 100644 --- a/akka-actor/src/main/scala/akka/actor/dungeon/Dispatch.scala +++ b/akka-actor/src/main/scala/akka/actor/dungeon/Dispatch.scala @@ -5,7 +5,6 @@ package akka.actor.dungeon import scala.annotation.tailrec - import akka.AkkaException import akka.dispatch.{ Envelope, Mailbox } import akka.dispatch.sysmsg._ @@ -13,13 +12,14 @@ import akka.event.Logging.Error import akka.util.Unsafe import akka.actor._ import akka.serialization.{ DisabledJavaSerializer, SerializationExtension, Serializers } + import scala.util.control.{ NoStackTrace, NonFatal } import scala.util.control.Exception.Catcher - import akka.dispatch.MailboxType import akka.dispatch.ProducesMessageQueue import akka.dispatch.UnboundedMailbox import akka.serialization.Serialization +import com.github.ghik.silencer.silent @SerialVersionUID(1L) final case class SerializationCheckFailedException private (msg: Object, cause: Throwable) @@ -30,7 +30,7 @@ final case class SerializationCheckFailedException private (msg: Object, cause: private[akka] trait Dispatch { this: ActorCell => - @volatile private var _mailboxDoNotCallMeDirectly + @silent @volatile private var _mailboxDoNotCallMeDirectly : Mailbox = _ //This must be volatile since it isn't protected by the mailbox status @inline final def mailbox: Mailbox = diff --git a/akka-actor/src/main/scala/akka/actor/dungeon/FaultHandling.scala b/akka-actor/src/main/scala/akka/actor/dungeon/FaultHandling.scala index a0db8db0bc..9047deeeae 100644 --- a/akka-actor/src/main/scala/akka/actor/dungeon/FaultHandling.scala +++ b/akka-actor/src/main/scala/akka/actor/dungeon/FaultHandling.scala @@ -12,6 +12,7 @@ import akka.dispatch.sysmsg._ import akka.event.Logging import akka.event.Logging.Debug import akka.event.Logging.Error + import scala.collection.immutable import scala.concurrent.duration.Duration import scala.util.control.Exception._ diff --git a/akka-actor/src/main/scala/akka/dispatch/AbstractDispatcher.scala b/akka-actor/src/main/scala/akka/dispatch/AbstractDispatcher.scala index 654d168cee..b559cc5b1a 100644 --- a/akka-actor/src/main/scala/akka/dispatch/AbstractDispatcher.scala +++ b/akka-actor/src/main/scala/akka/dispatch/AbstractDispatcher.scala @@ -13,6 +13,7 @@ import akka.dispatch.sysmsg._ import akka.event.EventStream import akka.event.Logging.{ Debug, Error, LogEventException } import akka.util.{ unused, Index, Unsafe } +import com.github.ghik.silencer.silent import com.typesafe.config.Config import scala.annotation.tailrec @@ -96,8 +97,8 @@ abstract class MessageDispatcher(val configurator: MessageDispatcherConfigurator val mailboxes = prerequisites.mailboxes val eventStream = prerequisites.eventStream - @volatile private[this] var _inhabitantsDoNotCallMeDirectly: Long = _ // DO NOT TOUCH! - @volatile private[this] var _shutdownScheduleDoNotCallMeDirectly: Int = _ // DO NOT TOUCH! + @silent @volatile private[this] var _inhabitantsDoNotCallMeDirectly: Long = _ // DO NOT TOUCH! + @silent @volatile private[this] var _shutdownScheduleDoNotCallMeDirectly: Int = _ // DO NOT TOUCH! private final def addInhabitants(add: Long): Long = { val old = Unsafe.instance.getAndAddLong(this, inhabitantsOffset, add) diff --git a/akka-actor/src/main/scala/akka/dispatch/Dispatcher.scala b/akka-actor/src/main/scala/akka/dispatch/Dispatcher.scala index 98e9a2f7b2..a224668e32 100644 --- a/akka-actor/src/main/scala/akka/dispatch/Dispatcher.scala +++ b/akka-actor/src/main/scala/akka/dispatch/Dispatcher.scala @@ -9,10 +9,13 @@ import akka.actor.ActorCell import akka.event.Logging import akka.dispatch.sysmsg.SystemMessage import java.util.concurrent.{ ExecutorService, RejectedExecutionException } + import scala.concurrent.duration.Duration import scala.concurrent.duration.FiniteDuration import java.util.concurrent.atomic.AtomicReferenceFieldUpdater +import com.github.ghik.silencer.silent + /** * The event-based ``Dispatcher`` binds a set of Actors to a thread pool backed up by a * `BlockingQueue`. @@ -41,6 +44,11 @@ class Dispatcher( def copy(): LazyExecutorServiceDelegate = new LazyExecutorServiceDelegate(factory) } + /** + * At first glance this var does not seem to be updated anywhere, but in + * fact it is, via the esUpdater [[AtomicReferenceFieldUpdater]] below. + */ + @silent @volatile private var executorServiceDelegate: LazyExecutorServiceDelegate = new LazyExecutorServiceDelegate(executorServiceFactoryProvider.createExecutorServiceFactory(id, threadFactory)) diff --git a/akka-actor/src/main/scala/akka/dispatch/Dispatchers.scala b/akka-actor/src/main/scala/akka/dispatch/Dispatchers.scala index b240e2c68d..5d194d3a0d 100644 --- a/akka-actor/src/main/scala/akka/dispatch/Dispatchers.scala +++ b/akka-actor/src/main/scala/akka/dispatch/Dispatchers.scala @@ -5,12 +5,15 @@ package akka.dispatch import java.util.concurrent.{ ConcurrentHashMap, ThreadFactory } + import com.typesafe.config.{ Config, ConfigFactory } import akka.actor.{ ActorSystem, DynamicAccess, Scheduler } import akka.event.Logging.Warning import akka.event.EventStream import akka.ConfigurationException import akka.util.Helpers.ConfigOps +import com.github.ghik.silencer.silent + import scala.concurrent.ExecutionContext /** @@ -238,6 +241,7 @@ private[akka] object BalancingDispatcherConfigurator { * Returns the same dispatcher instance for each invocation * of the `dispatcher()` method. */ +@silent class BalancingDispatcherConfigurator(_config: Config, _prerequisites: DispatcherPrerequisites) extends MessageDispatcherConfigurator(BalancingDispatcherConfigurator.amendConfig(_config), _prerequisites) { diff --git a/akka-actor/src/main/scala/akka/dispatch/Future.scala b/akka-actor/src/main/scala/akka/dispatch/Future.scala index 1aa25f19a3..5ee0b761e2 100644 --- a/akka-actor/src/main/scala/akka/dispatch/Future.scala +++ b/akka-actor/src/main/scala/akka/dispatch/Future.scala @@ -18,6 +18,7 @@ import java.util.concurrent.CompletableFuture import akka.compat import akka.util.unused +import com.github.ghik.silencer.silent /** * ExecutionContexts is the Java API for ExecutionContexts @@ -240,6 +241,7 @@ object japi { * * Java API */ +@silent abstract class OnSuccess[-T] extends japi.CallbackBridge[T] { protected final override def internal(result: T) = onSuccess(result) @@ -257,6 +259,7 @@ abstract class OnSuccess[-T] extends japi.CallbackBridge[T] { * * Java API */ +@silent abstract class OnFailure extends japi.CallbackBridge[Throwable] { protected final override def internal(failure: Throwable) = onFailure(failure) @@ -274,6 +277,7 @@ abstract class OnFailure extends japi.CallbackBridge[Throwable] { * * Java API */ +@silent abstract class OnComplete[-T] extends japi.CallbackBridge[Try[T]] { protected final override def internal(value: Try[T]): Unit = value match { case Failure(t) => onComplete(t, null.asInstanceOf[T]) @@ -296,6 +300,7 @@ abstract class OnComplete[-T] extends japi.CallbackBridge[Try[T]] { * * Java API */ +@silent abstract class Recover[+T] extends japi.RecoverBridge[T] { protected final override def internal(result: Throwable): T = recover(result) @@ -349,6 +354,7 @@ object Filter { * SAM (Single Abstract Method) class * Java API */ +@silent abstract class Foreach[-T] extends japi.UnitFunctionBridge[T] { override final def internal(t: T): Unit = each(t) diff --git a/akka-actor/src/main/scala/akka/event/EventStream.scala b/akka-actor/src/main/scala/akka/event/EventStream.scala index 0b397f040a..f5db8d4ad4 100644 --- a/akka-actor/src/main/scala/akka/event/EventStream.scala +++ b/akka-actor/src/main/scala/akka/event/EventStream.scala @@ -8,6 +8,9 @@ import akka.actor.{ ActorRef, ActorSystem } import akka.event.Logging.simpleName import akka.util.Subclassification import java.util.concurrent.atomic.AtomicReference + +import com.github.ghik.silencer.silent + import scala.annotation.tailrec /** @@ -36,6 +39,8 @@ class EventStream(sys: ActorSystem, private val debug: Boolean) extends LoggingB protected def classify(event: Any): Class[_] = event.getClass + // TODO consider avoiding the deprecated `isTerminated`? + @silent protected def publish(event: Any, subscriber: ActorRef) = { if (sys == null && subscriber.isTerminated) unsubscribe(subscriber) else subscriber ! event diff --git a/akka-actor/src/main/scala/akka/event/Logging.scala b/akka-actor/src/main/scala/akka/event/Logging.scala index 173e8d1b33..a917ba1860 100644 --- a/akka-actor/src/main/scala/akka/event/Logging.scala +++ b/akka-actor/src/main/scala/akka/event/Logging.scala @@ -14,6 +14,7 @@ import akka.dispatch.RequiresMessageQueue import akka.event.Logging._ import akka.util.{ unused, Helpers, ReentrantGuard } import akka.{ AkkaException, ConfigurationException } +import com.github.ghik.silencer.silent import scala.annotation.implicitNotFound import scala.collection.immutable @@ -166,6 +167,7 @@ trait LoggingBus extends ActorEventBus { * Internal Akka use only */ private[akka] def stopDefaultLoggers(system: ActorSystem): Unit = { + @silent val level = _logLevel // volatile access before reading loggers if (!(loggers contains StandardOutLogger)) { setUpStdoutLogger(system.settings) @@ -1455,12 +1457,16 @@ trait LoggingAdapter { * there are more than four arguments. */ private def format1(t: String, arg: Any): String = arg match { - case a: Array[_] if !a.getClass.getComponentType.isPrimitive => format(t, a: _*) - case a: Array[_] => format(t, a.map(_.asInstanceOf[AnyRef]): _*) + case a: Array[_] if !a.getClass.getComponentType.isPrimitive => formatImpl(t, a.toSeq) + case a: Array[_] => formatImpl(t, a.map(_.asInstanceOf[AnyRef]).toSeq) case x => format(t, x) } def format(t: String, arg: Any*): String = { + formatImpl(t, arg) + } + + private def formatImpl(t: String, arg: Seq[Any]): String = { val sb = new java.lang.StringBuilder(64) var p = 0 var startIndex = 0 @@ -1498,6 +1504,11 @@ trait LoggingFilter { def isDebugEnabled(logClass: Class[_], logSource: String): Boolean } +/** + * In retrospect should have been abstract, but we cannot change that + * without breaking binary compatibility + */ +@silent trait LoggingFilterWithMarker extends LoggingFilter { def isErrorEnabled(logClass: Class[_], logSource: String, marker: LogMarker): Boolean = isErrorEnabled(logClass, logSource) @@ -1883,8 +1894,8 @@ class MarkerLoggingAdapter( // Copy of LoggingAdapter.format1 due to binary compatibility restrictions private def format1(t: String, arg: Any): String = arg match { - case a: Array[_] if !a.getClass.getComponentType.isPrimitive => format(t, a: _*) - case a: Array[_] => format(t, a.map(_.asInstanceOf[AnyRef]): _*) + case a: Array[_] if !a.getClass.getComponentType.isPrimitive => format(t, a.toIndexedSeq) + case a: Array[_] => format(t, a.map(_.asInstanceOf[AnyRef]).toIndexedSeq) case x => format(t, x) } } diff --git a/akka-actor/src/main/scala/akka/io/Dns.scala b/akka-actor/src/main/scala/akka/io/Dns.scala index 5e467ec79b..b389d0e5b9 100644 --- a/akka-actor/src/main/scala/akka/io/Dns.scala +++ b/akka-actor/src/main/scala/akka/io/Dns.scala @@ -18,6 +18,7 @@ import akka.util.unused import scala.collection.immutable import akka.util.ccompat._ +@ccompatUsedUntil213 abstract class Dns { /** diff --git a/akka-actor/src/main/scala/akka/io/Tcp.scala b/akka-actor/src/main/scala/akka/io/Tcp.scala index ace3d780d9..51b26df5da 100644 --- a/akka-actor/src/main/scala/akka/io/Tcp.scala +++ b/akka-actor/src/main/scala/akka/io/Tcp.scala @@ -18,9 +18,10 @@ import akka.util.Helpers.Requiring import akka.util.JavaDurationConverters._ import akka.actor._ import java.lang.{ Iterable => JIterable } -import java.nio.file.Path +import java.nio.file.{ Path, Paths } import akka.annotation.InternalApi +import com.github.ghik.silencer.silent /** * TCP Extension for Akka’s IO layer. @@ -116,6 +117,7 @@ object Tcp extends ExtensionId[TcpExt] with ExtensionIdProvider { * @param localAddress optionally specifies a specific address to bind to * @param options Please refer to the `Tcp.SO` object for a list of all supported options. */ + @silent final case class Connect( remoteAddress: InetSocketAddress, localAddress: Option[InetSocketAddress] = None, @@ -143,6 +145,7 @@ object Tcp extends ExtensionId[TcpExt] with ExtensionIdProvider { * * @param options Please refer to the `Tcp.SO` object for a list of all supported options. */ + @silent final case class Bind( handler: ActorRef, localAddress: InetSocketAddress, @@ -867,7 +870,20 @@ object TcpMessage { * a particular write has been sent by the O/S. */ def writeFile(filePath: String, position: Long, count: Long, ack: Event): Command = - WriteFile(filePath, position, count, ack) + WritePath(Paths.get(filePath), position, count, ack) + + /** + * Write `count` bytes starting at `position` from file at `filePath` to the connection. + * The count must be > 0. The connection actor will reply with a [[Tcp.CommandFailed]] + * message if the write could not be enqueued. If [[Tcp.SimpleWriteCommand#wantsAck]] + * returns true, the connection actor will reply with the supplied [[Tcp.SimpleWriteCommand#ack]] + * token once the write has been successfully enqueued to the O/S kernel. + * Note that this does not in any way guarantee that the data will be + * or have been sent! Unfortunately there is no way to determine whether + * a particular write has been sent by the O/S. + */ + def writePath(filePath: Path, position: Long, count: Long, ack: Event): Command = + WritePath(filePath, position, count, ack) /** * When `useResumeWriting` is in effect as was indicated in the [[Tcp.Register]] message diff --git a/akka-actor/src/main/scala/akka/io/TcpConnection.scala b/akka-actor/src/main/scala/akka/io/TcpConnection.scala index c973d41fa1..73e4794af9 100644 --- a/akka-actor/src/main/scala/akka/io/TcpConnection.scala +++ b/akka-actor/src/main/scala/akka/io/TcpConnection.scala @@ -17,6 +17,7 @@ import akka.io.Inet.SocketOption import akka.io.SelectionHandler._ import akka.io.Tcp._ import akka.util.ByteString +import com.github.ghik.silencer.silent import scala.annotation.tailrec import scala.collection.immutable @@ -202,6 +203,7 @@ private[io] abstract class TcpConnection(val tcp: TcpExt, val channel: SocketCha // AUXILIARIES and IMPLEMENTATION /** used in subclasses to start the common machinery above once a channel is connected */ + @silent def completeConnect( registration: ChannelRegistration, commander: ActorRef, @@ -415,8 +417,9 @@ private[io] abstract class TcpConnection(val tcp: TcpExt, val channel: SocketCha case Write(data, ack) if data.nonEmpty => PendingBufferWrite(commander, data, ack, tail) case WriteFile(path, offset, count, ack) => PendingWriteFile(commander, Paths.get(path), offset, count, ack, tail) - case WritePath(path, offset, count, ack) => PendingWriteFile(commander, path, offset, count, ack, tail) - case CompoundWrite(h, t) => create(h, t) + case WritePath(path, offset, count, ack) => + PendingWriteFile(commander, path, offset, count, ack, tail) + case CompoundWrite(h, t) => create(h, t) case x @ Write(_, ack) => // empty write with either an ACK or a non-standard NoACK if (x.wantsAck) commander ! ack create(tail) diff --git a/akka-actor/src/main/scala/akka/io/TcpIncomingConnection.scala b/akka-actor/src/main/scala/akka/io/TcpIncomingConnection.scala index b9596c180f..0af73f0c8c 100644 --- a/akka-actor/src/main/scala/akka/io/TcpIncomingConnection.scala +++ b/akka-actor/src/main/scala/akka/io/TcpIncomingConnection.scala @@ -5,9 +5,11 @@ package akka.io import java.nio.channels.SocketChannel + import scala.collection.immutable import akka.actor.ActorRef import akka.io.Inet.SocketOption +import com.github.ghik.silencer.silent /** * An actor handling the connection state machine for an incoming, already connected @@ -15,6 +17,7 @@ import akka.io.Inet.SocketOption * * INTERNAL API */ +@silent private[io] class TcpIncomingConnection( _tcp: TcpExt, _channel: SocketChannel, diff --git a/akka-actor/src/main/scala/akka/io/Udp.scala b/akka-actor/src/main/scala/akka/io/Udp.scala index 2481ae4042..27488422b8 100644 --- a/akka-actor/src/main/scala/akka/io/Udp.scala +++ b/akka-actor/src/main/scala/akka/io/Udp.scala @@ -6,13 +6,16 @@ package akka.io import java.net.DatagramSocket import java.net.InetSocketAddress + import com.typesafe.config.Config + import scala.collection.immutable import akka.io.Inet.{ SoJavaFactories, SocketOption } import akka.util.Helpers.Requiring import akka.util.ByteString import akka.actor._ import akka.util.ccompat._ +import com.github.ghik.silencer.silent /** * UDP Extension for Akka’s IO layer. @@ -26,6 +29,7 @@ import akka.util.ccompat._ * * The Java API for generating UDP commands is available at [[UdpMessage]]. */ +@ccompatUsedUntil213 object Udp extends ExtensionId[UdpExt] with ExtensionIdProvider { override def lookup = Udp @@ -94,6 +98,7 @@ object Udp extends ExtensionId[UdpExt] with ExtensionIdProvider { * The listener actor for the newly bound port will reply with a [[Bound]] * message, or the manager will reply with a [[CommandFailed]] message. */ + @silent final case class Bind( handler: ActorRef, localAddress: InetSocketAddress, @@ -117,6 +122,7 @@ object Udp extends ExtensionId[UdpExt] with ExtensionIdProvider { * The “simple sender” will not stop itself, you will have to send it a [[akka.actor.PoisonPill]] * when you want to close the socket. */ + @silent case class SimpleSender(options: immutable.Traversable[SocketOption] = Nil) extends Command object SimpleSender extends SimpleSender(Nil) diff --git a/akka-actor/src/main/scala/akka/io/UdpConnected.scala b/akka-actor/src/main/scala/akka/io/UdpConnected.scala index a41cab76ff..798175b49e 100644 --- a/akka-actor/src/main/scala/akka/io/UdpConnected.scala +++ b/akka-actor/src/main/scala/akka/io/UdpConnected.scala @@ -6,12 +6,14 @@ package akka.io import java.lang.{ Iterable => JIterable } import java.net.InetSocketAddress + import scala.collection.immutable import akka.io.Inet.SocketOption import akka.io.Udp.UdpSettings import akka.util.ByteString import akka.actor._ import akka.util.ccompat._ +import com.github.ghik.silencer.silent /** * UDP Extension for Akka’s IO layer. @@ -25,6 +27,7 @@ import akka.util.ccompat._ * * The Java API for generating UDP commands is available at [[UdpConnectedMessage]]. */ +@ccompatUsedUntil213 object UdpConnected extends ExtensionId[UdpConnectedExt] with ExtensionIdProvider { override def lookup = UdpConnected @@ -88,6 +91,7 @@ object UdpConnected extends ExtensionId[UdpConnectedExt] with ExtensionIdProvide * which is restricted to sending to and receiving from the given `remoteAddress`. * All received datagrams will be sent to the designated `handler` actor. */ + @silent final case class Connect( handler: ActorRef, remoteAddress: InetSocketAddress, diff --git a/akka-actor/src/main/scala/akka/io/UdpSender.scala b/akka-actor/src/main/scala/akka/io/UdpSender.scala index 233d1fdc1f..b98313893c 100644 --- a/akka-actor/src/main/scala/akka/io/UdpSender.scala +++ b/akka-actor/src/main/scala/akka/io/UdpSender.scala @@ -5,16 +5,19 @@ package akka.io import java.nio.channels.DatagramChannel + import scala.collection.immutable import scala.util.control.NonFatal import akka.dispatch.{ RequiresMessageQueue, UnboundedMessageQueueSemantics } import akka.io.Inet.SocketOption import akka.io.Udp._ import akka.actor._ +import com.github.ghik.silencer.silent /** * INTERNAL API */ +@silent private[io] class UdpSender( val udp: UdpExt, channelRegistry: ChannelRegistry, diff --git a/akka-actor/src/main/scala/akka/io/dns/DnsSettings.scala b/akka-actor/src/main/scala/akka/io/dns/DnsSettings.scala index 76485e80c3..01695e61a1 100644 --- a/akka-actor/src/main/scala/akka/io/dns/DnsSettings.scala +++ b/akka-actor/src/main/scala/akka/io/dns/DnsSettings.scala @@ -23,6 +23,7 @@ import akka.util.ccompat._ /** INTERNAL API */ @InternalApi +@ccompatUsedUntil213 private[dns] final class DnsSettings(system: ExtendedActorSystem, c: Config) { import DnsSettings._ diff --git a/akka-actor/src/main/scala/akka/io/dns/internal/DnsClient.scala b/akka-actor/src/main/scala/akka/io/dns/internal/DnsClient.scala index 32f1443f43..9b02ef07cc 100644 --- a/akka-actor/src/main/scala/akka/io/dns/internal/DnsClient.scala +++ b/akka-actor/src/main/scala/akka/io/dns/internal/DnsClient.scala @@ -11,7 +11,8 @@ import akka.actor.{ Actor, ActorLogging, ActorRef, NoSerializationVerificationNe import akka.annotation.InternalApi import akka.io.dns.{ RecordClass, RecordType, ResourceRecord } import akka.io.{ IO, Tcp, Udp } -import akka.pattern.BackoffSupervisor +import akka.pattern.{ BackoffOpts, BackoffSupervisor } +import com.github.ghik.silencer.silent import scala.collection.{ immutable => im } import scala.util.Try @@ -69,6 +70,10 @@ import scala.concurrent.duration._ Message(id, MessageFlags(), im.Seq(Question(name, recordType, RecordClass.IN))) } + /** + * Silent to allow map update syntax + */ + @silent def ready(socket: ActorRef): Receive = { case DropRequest(id) => log.debug("Dropping request [{}]", id) @@ -143,11 +148,12 @@ import scala.concurrent.duration._ def createTcpClient() = { context.actorOf( BackoffSupervisor.props( - Props(classOf[TcpDnsClient], tcp, ns, self), - childName = "tcpDnsClient", - minBackoff = 10.millis, - maxBackoff = 20.seconds, - randomFactor = 0.1), + BackoffOpts.onFailure( + Props(classOf[TcpDnsClient], tcp, ns, self), + childName = "tcpDnsClient", + minBackoff = 10.millis, + maxBackoff = 20.seconds, + randomFactor = 0.1)), "tcpDnsClientSupervisor") } } diff --git a/akka-actor/src/main/scala/akka/io/dns/internal/DnsMessage.scala b/akka-actor/src/main/scala/akka/io/dns/internal/DnsMessage.scala index ae36d894a6..8f95967b85 100644 --- a/akka-actor/src/main/scala/akka/io/dns/internal/DnsMessage.scala +++ b/akka-actor/src/main/scala/akka/io/dns/internal/DnsMessage.scala @@ -7,6 +7,7 @@ package akka.io.dns.internal import akka.annotation.InternalApi import akka.io.dns.ResourceRecord import akka.util.{ ByteString, ByteStringBuilder } +import com.github.ghik.silencer.silent import scala.collection.GenTraversableOnce import scala.collection.immutable.Seq @@ -155,6 +156,7 @@ private[internal] object Message { } import scala.language.implicitConversions + @silent implicit def flattener[T](tried: Try[T]): GenTraversableOnce[T] = if (flags.isTruncated) tried.toOption else diff --git a/akka-actor/src/main/scala/akka/io/dns/internal/DomainName.scala b/akka-actor/src/main/scala/akka/io/dns/internal/DomainName.scala index b55d8dcc7f..47eecba1a9 100644 --- a/akka-actor/src/main/scala/akka/io/dns/internal/DomainName.scala +++ b/akka-actor/src/main/scala/akka/io/dns/internal/DomainName.scala @@ -27,7 +27,7 @@ private[akka] object DomainName { } def parse(it: ByteIterator, msg: ByteString): String = { - val ret = StringBuilder.newBuilder + val ret = new StringBuilder() while (true) { val length = it.getByte if (length == 0) { diff --git a/akka-actor/src/main/scala/akka/japi/JavaAPI.scala b/akka-actor/src/main/scala/akka/japi/JavaAPI.scala index a02893e252..f0f15fab7f 100644 --- a/akka-actor/src/main/scala/akka/japi/JavaAPI.scala +++ b/akka-actor/src/main/scala/akka/japi/JavaAPI.scala @@ -7,6 +7,7 @@ package akka.japi import java.util.Collections.{ emptyList, singletonList } import akka.util.Collections.EmptyImmutableSeq +import com.github.ghik.silencer.silent import scala.collection.immutable import scala.language.implicitConversions @@ -82,6 +83,7 @@ object Pair { * * This class is kept for compatibility, but for future API's please prefer [[akka.japi.function.Creator]]. */ +@silent @SerialVersionUID(1L) trait Creator[T] extends Serializable { @@ -241,7 +243,8 @@ object Util { /** * Turns an array into an immutable Scala sequence (by copying it). */ - def immutableSeq[T](arr: Array[T]): immutable.Seq[T] = if ((arr ne null) && arr.length > 0) Vector(arr: _*) else Nil + def immutableSeq[T](arr: Array[T]): immutable.Seq[T] = + if ((arr ne null) && arr.length > 0) arr.toIndexedSeq else Nil /** * Turns an [[java.lang.Iterable]] into an immutable Scala sequence (by copying it). diff --git a/akka-actor/src/main/scala/akka/japi/function/Function.scala b/akka-actor/src/main/scala/akka/japi/function/Function.scala index bd78ffd96a..c595ad00d0 100644 --- a/akka-actor/src/main/scala/akka/japi/function/Function.scala +++ b/akka-actor/src/main/scala/akka/japi/function/Function.scala @@ -4,11 +4,14 @@ package akka.japi.function +import com.github.ghik.silencer.silent + /** * A Function interface. Used to create first-class-functions is Java. * `Serializable` is needed to be able to grab line number for Java 8 lambdas. * Supports throwing `Exception` in the apply, which the `java.util.function.Function` counterpart does not. */ +@silent @SerialVersionUID(1L) trait Function[-T, +R] extends java.io.Serializable { @throws(classOf[Exception]) @@ -20,6 +23,7 @@ trait Function[-T, +R] extends java.io.Serializable { * `Serializable` is needed to be able to grab line number for Java 8 lambdas. * Supports throwing `Exception` in the apply, which the `java.util.function.BiFunction` counterpart does not. */ +@silent @SerialVersionUID(1L) trait Function2[-T1, -T2, +R] extends java.io.Serializable { @throws(classOf[Exception]) @@ -31,6 +35,7 @@ trait Function2[-T1, -T2, +R] extends java.io.Serializable { * `Serializable` is needed to be able to grab line number for Java 8 lambdas. * Supports throwing `Exception` in the apply, which the `java.util.function.Consumer` counterpart does not. */ +@silent @SerialVersionUID(1L) trait Procedure[-T] extends java.io.Serializable { @throws(classOf[Exception]) @@ -42,6 +47,7 @@ trait Procedure[-T] extends java.io.Serializable { * `Serializable` is needed to be able to grab line number for Java 8 lambdas. * Supports throwing `Exception` in the apply, which the `java.util.function.Effect` counterpart does not. */ +@silent @SerialVersionUID(1L) trait Effect extends java.io.Serializable { @@ -54,6 +60,7 @@ trait Effect extends java.io.Serializable { * `Serializable` is needed to be able to grab line number for Java 8 lambdas. * Supports throwing `Exception` in the apply, which the `java.util.function.Predicate` counterpart does not. */ +@silent @SerialVersionUID(1L) trait Predicate[-T] extends java.io.Serializable { def test(param: T): Boolean @@ -63,6 +70,7 @@ trait Predicate[-T] extends java.io.Serializable { * A constructor/factory, takes no parameters but creates a new value of type T every call. * Supports throwing `Exception` in the apply, which the `java.util.function.Creator` counterpart does not. */ +@silent @SerialVersionUID(1L) trait Creator[+T] extends Serializable { diff --git a/akka-actor/src/main/scala/akka/pattern/AskSupport.scala b/akka-actor/src/main/scala/akka/pattern/AskSupport.scala index 20ffbcc192..7b5baddc88 100644 --- a/akka-actor/src/main/scala/akka/pattern/AskSupport.scala +++ b/akka-actor/src/main/scala/akka/pattern/AskSupport.scala @@ -11,6 +11,8 @@ import akka.annotation.InternalApi import akka.dispatch.sysmsg._ import akka.util.{ Timeout, Unsafe } +import com.github.ghik.silencer.silent + import scala.annotation.tailrec import scala.concurrent.{ ExecutionContext, Future, Promise } import scala.language.implicitConversions @@ -524,9 +526,11 @@ private[akka] final class PromiseActorRef private ( * Stopped => stopped, path not yet created */ @volatile + @silent private[this] var _stateDoNotCallMeDirectly: AnyRef = _ @volatile + @silent private[this] var _watchedByDoNotCallMeDirectly: Set[ActorRef] = ActorCell.emptyActorRefSet @inline diff --git a/akka-actor/src/main/scala/akka/pattern/Backoff.scala b/akka-actor/src/main/scala/akka/pattern/Backoff.scala index 7490f24694..52c54cb342 100644 --- a/akka-actor/src/main/scala/akka/pattern/Backoff.scala +++ b/akka-actor/src/main/scala/akka/pattern/Backoff.scala @@ -8,6 +8,7 @@ import akka.actor.{ OneForOneStrategy, Props, SupervisorStrategy } import akka.annotation.DoNotInherit import akka.pattern.internal.{ BackoffOnRestartSupervisor, BackoffOnStopSupervisor } import akka.util.JavaDurationConverters._ +import com.github.ghik.silencer.silent import scala.concurrent.duration.{ Duration, FiniteDuration } @@ -565,6 +566,7 @@ trait BackoffOptions { private[akka] def props: Props } +@silent private final case class BackoffOptionsImpl( backoffType: BackoffType = RestartImpliesFailure, childProps: Props, diff --git a/akka-actor/src/main/scala/akka/pattern/CircuitBreaker.scala b/akka-actor/src/main/scala/akka/pattern/CircuitBreaker.scala index 8899c30073..bc0574a426 100644 --- a/akka-actor/src/main/scala/akka/pattern/CircuitBreaker.scala +++ b/akka-actor/src/main/scala/akka/pattern/CircuitBreaker.scala @@ -24,6 +24,8 @@ import scala.util.control.NonFatal import scala.util.{ Failure, Success, Try } import akka.dispatch.ExecutionContexts.sameThreadExecutionContext +import com.github.ghik.silencer.silent + import scala.compat.java8.FutureConverters /** @@ -165,7 +167,8 @@ class CircuitBreaker( // add the old constructor to make it binary compatible def this(scheduler: Scheduler, maxFailures: Int, callTimeout: FiniteDuration, resetTimeout: FiniteDuration)( - implicit executor: ExecutionContext) = { + implicit + executor: ExecutionContext) = { this(scheduler, maxFailures, callTimeout, resetTimeout, 36500.days, 1.0)(executor) } @@ -193,12 +196,14 @@ class CircuitBreaker( * Holds reference to current state of CircuitBreaker - *access only via helper methods* */ @volatile + @silent private[this] var _currentStateDoNotCallMeDirectly: State = Closed /** * Holds reference to current resetTimeout of CircuitBreaker - *access only via helper methods* */ @volatile + @silent private[this] var _currentResetTimeoutDoNotCallMeDirectly: FiniteDuration = resetTimeout /** diff --git a/akka-actor/src/main/scala/akka/pattern/HandleBackoff.scala b/akka-actor/src/main/scala/akka/pattern/HandleBackoff.scala index 86817a2d90..7af275e4ac 100644 --- a/akka-actor/src/main/scala/akka/pattern/HandleBackoff.scala +++ b/akka-actor/src/main/scala/akka/pattern/HandleBackoff.scala @@ -6,12 +6,11 @@ package akka.pattern import akka.actor.{ Actor, ActorRef, Props } import akka.annotation.InternalApi -import akka.pattern.internal.{ BackoffOnRestartSupervisor, BackoffOnStopSupervisor } /** * INTERNAL API * - * Implements basic backoff handling for [[BackoffOnRestartSupervisor]] and [[BackoffOnStopSupervisor]]. + * Implements basic backoff handling for [[internal.BackoffOnRestartSupervisor]] and [[internal.BackoffOnStopSupervisor]]. */ @InternalApi private[akka] trait HandleBackoff { this: Actor => diff --git a/akka-actor/src/main/scala/akka/routing/Balancing.scala b/akka-actor/src/main/scala/akka/routing/Balancing.scala index 1a933af627..cf846efc6b 100644 --- a/akka-actor/src/main/scala/akka/routing/Balancing.scala +++ b/akka-actor/src/main/scala/akka/routing/Balancing.scala @@ -13,6 +13,7 @@ import akka.actor.Props import akka.actor.SupervisorStrategy import akka.dispatch.BalancingDispatcherConfigurator import akka.dispatch.Dispatchers +import com.github.ghik.silencer.silent /** * INTERNAL API @@ -25,6 +26,7 @@ private[akka] object BalancingRoutingLogic { * INTERNAL API * Selects the first routee, balancing will be done by the dispatcher. */ +@silent @SerialVersionUID(1L) private[akka] final class BalancingRoutingLogic extends RoutingLogic { override def select(message: Any, routees: immutable.IndexedSeq[Routee]): Routee = diff --git a/akka-actor/src/main/scala/akka/routing/Broadcast.scala b/akka-actor/src/main/scala/akka/routing/Broadcast.scala index 891c06bb7a..4142d1dc21 100644 --- a/akka-actor/src/main/scala/akka/routing/Broadcast.scala +++ b/akka-actor/src/main/scala/akka/routing/Broadcast.scala @@ -10,6 +10,7 @@ import com.typesafe.config.Config import akka.actor.SupervisorStrategy import akka.japi.Util.immutableSeq import akka.actor.ActorSystem +import com.github.ghik.silencer.silent object BroadcastRoutingLogic { def apply(): BroadcastRoutingLogic = new BroadcastRoutingLogic @@ -18,6 +19,7 @@ object BroadcastRoutingLogic { /** * Broadcasts a message to all its routees. */ +@silent @SerialVersionUID(1L) final class BroadcastRoutingLogic extends RoutingLogic { override def select(message: Any, routees: immutable.IndexedSeq[Routee]): Routee = diff --git a/akka-actor/src/main/scala/akka/routing/MurmurHash.scala b/akka-actor/src/main/scala/akka/routing/MurmurHash.scala index 8838cd20ea..38ac4f7f13 100644 --- a/akka-actor/src/main/scala/akka/routing/MurmurHash.scala +++ b/akka-actor/src/main/scala/akka/routing/MurmurHash.scala @@ -20,7 +20,9 @@ package akka.routing import java.lang.Integer.{ rotateLeft => rotl } + import akka.util.ccompat._ +import com.github.ghik.silencer.silent /** * An object designed to generate well-distributed non-cryptographic @@ -31,6 +33,7 @@ import akka.util.ccompat._ * incorporate a new integer) to update the values. Only one method * needs to be called to finalize the hash. */ +@ccompatUsedUntil213 object MurmurHash { // Magic values used for MurmurHash's 32 bit hash. // Don't change these without consulting a hashing expert! @@ -129,6 +132,7 @@ object MurmurHash { * where the order of appearance of elements does not matter. * This is useful for hashing sets, for example. */ + @silent def symmetricHash[T](xs: IterableOnce[T], seed: Int): Int = { var a, b, n = 0 var c = 1 diff --git a/akka-actor/src/main/scala/akka/routing/Random.scala b/akka-actor/src/main/scala/akka/routing/Random.scala index 02d2109620..8e796a3f20 100644 --- a/akka-actor/src/main/scala/akka/routing/Random.scala +++ b/akka-actor/src/main/scala/akka/routing/Random.scala @@ -6,11 +6,13 @@ package akka.routing import scala.collection.immutable import java.util.concurrent.ThreadLocalRandom + import akka.dispatch.Dispatchers import com.typesafe.config.Config import akka.actor.SupervisorStrategy import akka.japi.Util.immutableSeq import akka.actor.ActorSystem +import com.github.ghik.silencer.silent object RandomRoutingLogic { def apply(): RandomRoutingLogic = new RandomRoutingLogic @@ -19,6 +21,7 @@ object RandomRoutingLogic { /** * Randomly selects one of the target routees to send a message to */ +@silent @SerialVersionUID(1L) final class RandomRoutingLogic extends RoutingLogic { override def select(message: Any, routees: immutable.IndexedSeq[Routee]): Routee = diff --git a/akka-actor/src/main/scala/akka/routing/RoundRobin.scala b/akka-actor/src/main/scala/akka/routing/RoundRobin.scala index e688d6712f..f7c706af52 100644 --- a/akka-actor/src/main/scala/akka/routing/RoundRobin.scala +++ b/akka-actor/src/main/scala/akka/routing/RoundRobin.scala @@ -5,12 +5,14 @@ package akka.routing import java.util.concurrent.atomic.AtomicLong + import scala.collection.immutable import akka.dispatch.Dispatchers import com.typesafe.config.Config import akka.actor.SupervisorStrategy import akka.japi.Util.immutableSeq import akka.actor.ActorSystem +import com.github.ghik.silencer.silent object RoundRobinRoutingLogic { def apply(): RoundRobinRoutingLogic = new RoundRobinRoutingLogic @@ -20,6 +22,7 @@ object RoundRobinRoutingLogic { * Uses round-robin to select a routee. For concurrent calls, * round robin is just a best effort. */ +@silent @SerialVersionUID(1L) final class RoundRobinRoutingLogic extends RoutingLogic { val next = new AtomicLong diff --git a/akka-actor/src/main/scala/akka/routing/RoutedActorCell.scala b/akka-actor/src/main/scala/akka/routing/RoutedActorCell.scala index 6748858670..76f7ad6f6f 100644 --- a/akka-actor/src/main/scala/akka/routing/RoutedActorCell.scala +++ b/akka-actor/src/main/scala/akka/routing/RoutedActorCell.scala @@ -36,6 +36,7 @@ private[akka] object RoutedActorCell { /** * INTERNAL API */ +@ccompatUsedUntil213 private[akka] class RoutedActorCell( _system: ActorSystemImpl, _ref: InternalActorRef, diff --git a/akka-actor/src/main/scala/akka/routing/RoutedActorRef.scala b/akka-actor/src/main/scala/akka/routing/RoutedActorRef.scala index bdef4e03e5..c8b9d1b132 100644 --- a/akka-actor/src/main/scala/akka/routing/RoutedActorRef.scala +++ b/akka-actor/src/main/scala/akka/routing/RoutedActorRef.scala @@ -15,6 +15,7 @@ import akka.actor.UnstartedCell import akka.dispatch.BalancingDispatcher import akka.dispatch.MailboxType import akka.dispatch.MessageDispatcher +import com.github.ghik.silencer.silent /** * INTERNAL API @@ -22,6 +23,7 @@ import akka.dispatch.MessageDispatcher * A RoutedActorRef is an ActorRef that has a set of connected ActorRef and it uses a Router to * send a message to one (or more) of these actors. */ +@silent private[akka] class RoutedActorRef( _system: ActorSystemImpl, _routerProps: Props, diff --git a/akka-actor/src/main/scala/akka/routing/RouterConfig.scala b/akka-actor/src/main/scala/akka/routing/RouterConfig.scala index dd1bda8877..6e7430a2d7 100644 --- a/akka-actor/src/main/scala/akka/routing/RouterConfig.scala +++ b/akka-actor/src/main/scala/akka/routing/RouterConfig.scala @@ -17,6 +17,7 @@ import akka.dispatch.Dispatchers import akka.actor.ActorSystem import akka.japi.Util.immutableSeq import akka.util.unused +import com.github.ghik.silencer.silent /** * This trait represents a router factory: it produces the actual router actor @@ -36,6 +37,7 @@ import akka.util.unused * someone tries sending a message to that reference before the constructor of * RoutedActorRef has returned, there will be a `NullPointerException`! */ +@silent @SerialVersionUID(1L) trait RouterConfig extends Serializable { @@ -372,14 +374,18 @@ case object NoRouter extends NoRouter { /** * INTERNAL API */ -@SerialVersionUID(1L) private[akka] trait RouterManagementMesssage +@silent +@SerialVersionUID(1L) +private[akka] trait RouterManagementMesssage /** * Sending this message to a router will make it send back its currently used routees. * A [[Routees]] message is sent asynchronously to the "requester" containing information * about what routees the router is routing over. */ -@SerialVersionUID(1L) abstract class GetRoutees extends RouterManagementMesssage +@silent +@SerialVersionUID(1L) +abstract class GetRoutees extends RouterManagementMesssage @SerialVersionUID(1L) case object GetRoutees extends GetRoutees { diff --git a/akka-actor/src/main/scala/akka/routing/ScatterGatherFirstCompleted.scala b/akka-actor/src/main/scala/akka/routing/ScatterGatherFirstCompleted.scala index a2b8aef36e..16967d4ecc 100644 --- a/akka-actor/src/main/scala/akka/routing/ScatterGatherFirstCompleted.scala +++ b/akka-actor/src/main/scala/akka/routing/ScatterGatherFirstCompleted.scala @@ -54,9 +54,9 @@ private[akka] final case class ScatterGatherFirstCompletedRoutees( val promise = Promise[Any]() routees.foreach { case ActorRefRoutee(ref) => - promise.tryCompleteWith(ref.ask(message)) + promise.completeWith(ref.ask(message)) case ActorSelectionRoutee(sel) => - promise.tryCompleteWith(sel.ask(message)) + promise.completeWith(sel.ask(message)) case _ => } diff --git a/akka-actor/src/main/scala/akka/routing/SmallestMailbox.scala b/akka-actor/src/main/scala/akka/routing/SmallestMailbox.scala index b87f570716..4e98f5e799 100644 --- a/akka-actor/src/main/scala/akka/routing/SmallestMailbox.scala +++ b/akka-actor/src/main/scala/akka/routing/SmallestMailbox.scala @@ -7,12 +7,14 @@ package akka.routing import scala.annotation.tailrec import scala.collection.immutable import java.util.concurrent.ThreadLocalRandom + import com.typesafe.config.Config import akka.actor.ActorCell import akka.actor.ActorRefWithCell import akka.actor.SupervisorStrategy import akka.dispatch.Dispatchers import akka.actor.ActorSystem +import com.github.ghik.silencer.silent object SmallestMailboxRoutingLogic { def apply(): SmallestMailboxRoutingLogic = new SmallestMailboxRoutingLogic @@ -29,6 +31,7 @@ object SmallestMailboxRoutingLogic { * since their mailbox size is unknown * */ +@silent @SerialVersionUID(1L) class SmallestMailboxRoutingLogic extends RoutingLogic { override def select(message: Any, routees: immutable.IndexedSeq[Routee]): Routee = @@ -77,6 +80,8 @@ class SmallestMailboxRoutingLogic extends RoutingLogic { } } + // TODO should we rewrite this not to use isTerminated? + @silent protected def isTerminated(a: Routee): Boolean = a match { case ActorRefRoutee(ref) => ref.isTerminated case _ => false @@ -174,6 +179,7 @@ class SmallestMailboxRoutingLogic extends RoutingLogic { * @param routerDispatcher dispatcher to use for the router head actor, which handles * supervision, death watch and router management messages */ +@silent @SerialVersionUID(1L) final case class SmallestMailboxPool( val nrOfInstances: Int, diff --git a/akka-actor/src/main/scala/akka/routing/TailChopping.scala b/akka-actor/src/main/scala/akka/routing/TailChopping.scala index c0327e2a86..6134cb0a4f 100644 --- a/akka-actor/src/main/scala/akka/routing/TailChopping.scala +++ b/akka-actor/src/main/scala/akka/routing/TailChopping.scala @@ -82,9 +82,9 @@ private[akka] final case class TailChoppingRoutees( if (idx < size) { shuffled(idx) match { case ActorRefRoutee(ref) => - promise.tryCompleteWith(ref.ask(message)) + promise.completeWith(ref.ask(message)) case ActorSelectionRoutee(sel) => - promise.tryCompleteWith(sel.ask(message)) + promise.completeWith(sel.ask(message)) case _ => } } diff --git a/akka-actor/src/main/scala/akka/serialization/Serialization.scala b/akka-actor/src/main/scala/akka/serialization/Serialization.scala index 06ee8f2c0f..0f089266fa 100644 --- a/akka-actor/src/main/scala/akka/serialization/Serialization.scala +++ b/akka-actor/src/main/scala/akka/serialization/Serialization.scala @@ -24,6 +24,7 @@ import java.util.NoSuchElementException import akka.annotation.InternalApi import akka.util.ccompat._ +@ccompatUsedUntil213 object Serialization { /** diff --git a/akka-actor/src/main/scala/akka/util/ManifestInfo.scala b/akka-actor/src/main/scala/akka/util/ManifestInfo.scala index 86abb82cf0..b376b3ee51 100644 --- a/akka-actor/src/main/scala/akka/util/ManifestInfo.scala +++ b/akka-actor/src/main/scala/akka/util/ManifestInfo.scala @@ -16,6 +16,7 @@ import akka.actor.Extension import akka.actor.ExtensionId import akka.actor.ExtensionIdProvider import akka.event.Logging +import com.github.ghik.silencer.silent /** * Akka extension that extracts [[ManifestInfo.Version]] information from META-INF/MANIFEST.MF in jar files @@ -162,6 +163,7 @@ final class ManifestInfo(val system: ExtendedActorSystem) extends Extension { * Verify that the version is the same for all given artifacts. */ def checkSameVersion(productName: String, dependencies: immutable.Seq[String], logWarning: Boolean): Boolean = { + @silent val filteredVersions = versions.filterKeys(dependencies.toSet) val values = filteredVersions.values.toSet if (values.size > 1) { diff --git a/akka-actor/src/main/scala/akka/util/SubclassifiedIndex.scala b/akka-actor/src/main/scala/akka/util/SubclassifiedIndex.scala index 8f8778985b..38d8d0e53b 100644 --- a/akka-actor/src/main/scala/akka/util/SubclassifiedIndex.scala +++ b/akka-actor/src/main/scala/akka/util/SubclassifiedIndex.scala @@ -78,6 +78,7 @@ private[akka] object SubclassifiedIndex { * cache, e.g. HashMap, is faster than tree traversal which must use linear * scan at each level. Therefore, no value traversals are published. */ +@ccompatUsedUntil213 private[akka] class SubclassifiedIndex[K, V] private (protected var values: Set[V])(implicit sc: Subclassification[K]) { import SubclassifiedIndex._ diff --git a/akka-cluster-metrics/src/main/scala/akka/cluster/metrics/ClusterMetricsRouting.scala b/akka-cluster-metrics/src/main/scala/akka/cluster/metrics/ClusterMetricsRouting.scala index fcfa6ef5d3..24661e4a53 100644 --- a/akka-cluster-metrics/src/main/scala/akka/cluster/metrics/ClusterMetricsRouting.scala +++ b/akka-cluster-metrics/src/main/scala/akka/cluster/metrics/ClusterMetricsRouting.scala @@ -6,9 +6,11 @@ package akka.cluster.metrics import java.util.Arrays import java.util.concurrent.atomic.AtomicReference + import scala.annotation.tailrec import scala.collection.immutable import java.util.concurrent.ThreadLocalRandom + import com.typesafe.config.Config import akka.actor.Actor import akka.actor.ActorSystem @@ -22,6 +24,7 @@ import akka.dispatch.Dispatchers import akka.japi.Util.immutableSeq import akka.routing._ import akka.cluster.routing.ClusterRouterSettingsBase +import com.github.ghik.silencer.silent /** * Load balancing of messages to cluster nodes based on cluster metric data. @@ -416,6 +419,7 @@ object MetricsSelector { /** * A MetricsSelector is responsible for producing weights from the node metrics. */ +@silent @SerialVersionUID(1L) trait MetricsSelector extends Serializable { @@ -429,6 +433,7 @@ trait MetricsSelector extends Serializable { * A MetricsSelector producing weights from remaining capacity. * The weights are typically proportional to the remaining capacity. */ +@silent @SerialVersionUID(1L) abstract class CapacityMetricsSelector extends MetricsSelector { diff --git a/akka-remote/src/main/scala/akka/remote/transport/AbstractTransportAdapter.scala b/akka-remote/src/main/scala/akka/remote/transport/AbstractTransportAdapter.scala index 1b9a6109bb..313b2a9605 100644 --- a/akka-remote/src/main/scala/akka/remote/transport/AbstractTransportAdapter.scala +++ b/akka-remote/src/main/scala/akka/remote/transport/AbstractTransportAdapter.scala @@ -94,7 +94,7 @@ abstract class AbstractTransportAdapter(protected val wrappedTransport: Transpor (listenAddress, listenerPromise) <- wrappedTransport.listen // Enforce ordering between the signalling of "listen ready" to upstream // and initialization happening in interceptListen - _ <- listenerPromise.tryCompleteWith(interceptListen(listenAddress, upstreamListenerPromise.future)).future + _ <- listenerPromise.completeWith(interceptListen(listenAddress, upstreamListenerPromise.future)).future } yield (augmentScheme(listenAddress), upstreamListenerPromise) } diff --git a/project/AkkaDisciplinePlugin.scala b/project/AkkaDisciplinePlugin.scala index 63fd941da4..cc6873177f 100644 --- a/project/AkkaDisciplinePlugin.scala +++ b/project/AkkaDisciplinePlugin.scala @@ -8,10 +8,6 @@ import sbt._ import Keys.{scalacOptions, _} import sbt.plugins.JvmPlugin -/** - * Initial tests found: - * `akka-actor` 151 errors with `-Xfatal-warnings`, 6 without the flag - */ object AkkaDisciplinePlugin extends AutoPlugin with ScalafixSupport { import scoverage.ScoverageKeys._ @@ -22,6 +18,7 @@ object AkkaDisciplinePlugin extends AutoPlugin with ScalafixSupport { override lazy val projectSettings = disciplineSettings val fatalWarningsFor = Set( + "akka-actor", "akka-discovery", "akka-distributed-data", "akka-coordination", @@ -58,24 +55,14 @@ object AkkaDisciplinePlugin extends AutoPlugin with ScalafixSupport { scalaFixSettings ++ silencerSettings ++ scoverageSettings ++ Seq( - Compile / scalacOptions ++= (if (strictProjects.contains(name.value)) { - disciplineScalacOptions - } else { - disciplineScalacOptions -- undisciplineScalacOptions - }).toSeq, Compile / scalacOptions ++= ( if (fatalWarningsFor(name.value)) Seq("-Xfatal-warnings") else Seq.empty ), Compile / console / scalacOptions --= Seq("-deprecation", "-Xfatal-warnings", "-Xlint", "-Ywarn-unused:imports"), - // Discipline is not needed for the docs compilation run (which uses - // different compiler phases from the regular run), and in particular - // '-Ywarn-unused:explicits' breaks 'sbt ++2.13.0-M5 akka-actor/doc' - // https://github.com/akka/akka/issues/26119 - Compile / doc / scalacOptions --= disciplineScalacOptions.toSeq, - Compile / scalacOptions --= (CrossVersion.partialVersion(scalaVersion.value) match { + Compile / scalacOptions ++= (CrossVersion.partialVersion(scalaVersion.value) match { case Some((2, 13)) => - Seq( + disciplineScalacOptions -- Set( "-Ywarn-inaccessible", "-Ywarn-infer-any", "-Ywarn-nullary-override", @@ -84,19 +71,31 @@ object AkkaDisciplinePlugin extends AutoPlugin with ScalafixSupport { "-Yno-adapted-args", ) case Some((2, 12)) => - Nil + disciplineScalacOptions case Some((2, 11)) => - Seq("-Ywarn-extra-implicit", "-Ywarn-unused:_") + disciplineScalacOptions ++ Set("-language:existentials") -- Set( + "-Ywarn-extra-implicit", + "-Ywarn-unused:_", + "-Ypartial-unification", + ) case _ => Nil - }), + }).toSeq, Compile / doc / scalacOptions ++= (CrossVersion.partialVersion(scalaVersion.value) match { case Some((2, 11)) => Seq("-no-link-warnings") case _ => Seq.empty }), - ) + Compile / scalacOptions --= + (if (strictProjects.contains(name.value)) Seq.empty + else undisciplineScalacOptions.toSeq), + // Discipline is not needed for the docs compilation run (which uses + // different compiler phases from the regular run), and in particular + // '-Ywarn-unused:explicits' breaks 'sbt ++2.13.0-M5 akka-actor/doc' + // https://github.com/akka/akka/issues/26119 + Compile / doc / scalacOptions --= disciplineScalacOptions.toSeq :+ "-Xfatal-warnings", + ) /** * Remain visibly filtered for future code quality work and removing.