Further work on binary compatibility

akka-actor/src/main/scala/akka/pattern/AskSupport.scala

@@ -157,6 +157,8 @@ trait AskSupport {
 /**
  * Akka private optimized representation of the temporary actor spawned to
  * receive the reply to an "ask" operation.
+ *
+ * INTERNAL API
  */
 private[akka] final class PromiseActorRef private (val provider: ActorRefProvider, val result: Promise[Any])
   extends MinimalActorRef {
@@ -182,14 +184,12 @@ private[akka] final class PromiseActorRef private (val provider: ActorRefProvide
   private def state: AnyRef = Unsafe.instance.getObjectVolatile(this, stateOffset)
 
   @inline
-  private def updateState(oldState: AnyRef, newState: AnyRef): Boolean =
-    Unsafe.instance.compareAndSwapObject(this, stateOffset, oldState, newState)
+  private def updateState(oldState: AnyRef, newState: AnyRef): Boolean = Unsafe.instance.compareAndSwapObject(this, stateOffset, oldState, newState)
 
   @inline
-  private def setState(newState: AnyRef): Unit =
-    Unsafe.instance.putObjectVolatile(this, stateOffset, newState)
+  private def setState(newState: AnyRef): Unit = Unsafe.instance.putObjectVolatile(this, stateOffset, newState)
 
-  override def getParent = provider.tempContainer
+  override def getParent: InternalActorRef = provider.tempContainer
 
   /**
    * Contract of this method:
@@ -234,7 +234,7 @@ private[akka] final class PromiseActorRef private (val provider: ActorRefProvide
     case _            ⇒
   }
 
-  override def isTerminated = state match {
+  override def isTerminated: Boolean = state match {
     case Stopped | _: StoppedWithPath ⇒ true
     case _                            ⇒ false
   }
@@ -263,6 +263,9 @@ private[akka] final class PromiseActorRef private (val provider: ActorRefProvide
   }
 }
 
+/**
+ * INTERNAL API
+ */
 private[akka] object PromiseActorRef {
   private case object Registering
   private case object Stopped

akka-actor/src/main/scala/akka/routing/ConnectionManager.scala

@@ -10,10 +10,8 @@ import akka.actor._
  * An Iterable that also contains a version.
  */
 trait VersionedIterable[A] {
-  val version: Long
-
+  def version: Long
   def iterable: Iterable[A]
-
   def apply(): Iterable[A] = iterable
 }
 
@@ -42,7 +40,7 @@ trait ConnectionManager {
   /**
    * Shuts the connection manager down, which stops all managed actors
    */
-  def shutdown()
+  def shutdown(): Unit
 
   /**
    * Returns a VersionedIterator containing all connected ActorRefs at some moment in time. Since there is
@@ -59,5 +57,5 @@ trait ConnectionManager {
    *
    * @param ref the dead
    */
-  def remove(deadRef: ActorRef)
+  def remove(deadRef: ActorRef): Unit
 }

akka-actor/src/main/scala/akka/routing/ConsistentHash.scala

@@ -23,7 +23,7 @@ class ConsistentHash[T](nodes: Seq[T], replicas: Int) {
 
   nodes.foreach(this += _)
 
-  def +=(node: T) {
+  def +=(node: T): Unit = {
     cluster += node
     (1 to replicas) foreach { replica ⇒
       val key = hashFor((node + ":" + replica).getBytes("UTF-8"))
@@ -32,7 +32,7 @@ class ConsistentHash[T](nodes: Seq[T], replicas: Int) {
     }
   }
 
-  def -=(node: T) {
+  def -=(node: T): Unit = {
     cluster -= node
     (1 to replicas) foreach { replica ⇒
       val key = hashFor((node + ":" + replica).getBytes("UTF-8"))
@@ -96,7 +96,7 @@ class MurmurHash[@specialized(Int, Long, Float, Double) T](seed: Int) extends (T
   private var hashvalue = h
 
   /** Begin a new hash using the same seed. */
-  def reset() {
+  def reset(): Unit = {
     h = startHash(seed)
     c = hiddenMagicA
     k = hiddenMagicB
@@ -104,7 +104,7 @@ class MurmurHash[@specialized(Int, Long, Float, Double) T](seed: Int) extends (T
   }
 
   /** Incorporate the hash value of one item. */
-  def apply(t: T) {
+  def apply(t: T): Unit = {
     h = extendHash(h, t.##, c, k)
     c = nextMagicA(c)
     k = nextMagicB(k)
@@ -112,7 +112,7 @@ class MurmurHash[@specialized(Int, Long, Float, Double) T](seed: Int) extends (T
   }
 
   /** Incorporate a known hash value. */
-  def append(i: Int) {
+  def append(i: Int): Unit = {
     h = extendHash(h, i, c, k)
     c = nextMagicA(c)
     k = nextMagicB(k)
@@ -120,14 +120,15 @@ class MurmurHash[@specialized(Int, Long, Float, Double) T](seed: Int) extends (T
   }
 
   /** Retrieve the hash value */
-  def hash = {
+  def hash: Int = {
     if (!hashed) {
       hashvalue = finalizeHash(h)
       hashed = true
     }
     hashvalue
   }
-  override def hashCode = hash
+
+  override def hashCode: Int = hash
 }
 
 /**
@@ -143,35 +144,35 @@ class MurmurHash[@specialized(Int, Long, Float, Double) T](seed: Int) extends (T
 object MurmurHash {
   // Magic values used for MurmurHash's 32 bit hash.
   // Don't change these without consulting a hashing expert!
-  final private val visibleMagic = 0x971e137b
-  final private val hiddenMagicA = 0x95543787
-  final private val hiddenMagicB = 0x2ad7eb25
-  final private val visibleMixer = 0x52dce729
-  final private val hiddenMixerA = 0x7b7d159c
-  final private val hiddenMixerB = 0x6bce6396
-  final private val finalMixer1 = 0x85ebca6b
-  final private val finalMixer2 = 0xc2b2ae35
+  final private val visibleMagic: Int = 0x971e137b
+  final private val hiddenMagicA: Int = 0x95543787
+  final private val hiddenMagicB: Int = 0x2ad7eb25
+  final private val visibleMixer: Int = 0x52dce729
+  final private val hiddenMixerA: Int = 0x7b7d159c
+  final private val hiddenMixerB: Int = 0x6bce6396
+  final private val finalMixer1: Int = 0x85ebca6b
+  final private val finalMixer2: Int = 0xc2b2ae35
 
   // Arbitrary values used for hashing certain classes
-  final private val seedString = 0xf7ca7fd2
-  final private val seedArray = 0x3c074a61
+  final private val seedString: Int = 0xf7ca7fd2
+  final private val seedArray: Int = 0x3c074a61
 
   /** The first 23 magic integers from the first stream are stored here */
-  val storedMagicA =
+  val storedMagicA: Array[Int] =
     Iterator.iterate(hiddenMagicA)(nextMagicA).take(23).toArray
 
   /** The first 23 magic integers from the second stream are stored here */
-  val storedMagicB =
+  val storedMagicB: Array[Int] =
     Iterator.iterate(hiddenMagicB)(nextMagicB).take(23).toArray
 
   /** Begin a new hash with a seed value. */
-  def startHash(seed: Int) = seed ^ visibleMagic
+  def startHash(seed: Int): Int = seed ^ visibleMagic
 
   /** The initial magic integers in the first stream. */
-  def startMagicA = hiddenMagicA
+  def startMagicA: Int = hiddenMagicA
 
   /** The initial magic integer in the second stream. */
-  def startMagicB = hiddenMagicB
+  def startMagicB: Int = hiddenMagicB
 
   /**
    * Incorporates a new value into an existing hash.
@@ -182,18 +183,17 @@ object MurmurHash {
    *  @param magicB    a magic integer from a different stream
    *  @return          the updated hash value
    */
-  def extendHash(hash: Int, value: Int, magicA: Int, magicB: Int) = {
+  def extendHash(hash: Int, value: Int, magicA: Int, magicB: Int): Int =
     (hash ^ rotl(value * magicA, 11) * magicB) * 3 + visibleMixer
-  }
 
   /** Given a magic integer from the first stream, compute the next */
-  def nextMagicA(magicA: Int) = magicA * 5 + hiddenMixerA
+  def nextMagicA(magicA: Int): Int = magicA * 5 + hiddenMixerA
 
   /** Given a magic integer from the second stream, compute the next */
-  def nextMagicB(magicB: Int) = magicB * 5 + hiddenMixerB
+  def nextMagicB(magicB: Int): Int = magicB * 5 + hiddenMixerB
 
   /** Once all hashes have been incorporated, this performs a final mixing */
-  def finalizeHash(hash: Int) = {
+  def finalizeHash(hash: Int): Int = {
     var i = (hash ^ (hash >>> 16))
     i *= finalMixer1
     i ^= (i >>> 13)
@@ -203,7 +203,7 @@ object MurmurHash {
   }
 
   /** Compute a high-quality hash of an array */
-  def arrayHash[@specialized T](a: Array[T]) = {
+  def arrayHash[@specialized T](a: Array[T]): Int = {
     var h = startHash(a.length * seedArray)
     var c = hiddenMagicA
     var k = hiddenMagicB
@@ -218,7 +218,7 @@ object MurmurHash {
   }
 
   /** Compute a high-quality hash of a string */
-  def stringHash(s: String) = {
+  def stringHash(s: String): Int = {
     var h = startHash(s.length * seedString)
     var c = hiddenMagicA
     var k = hiddenMagicB
@@ -239,7 +239,7 @@ object MurmurHash {
    *  where the order of appearance of elements does not matter.
    *  This is useful for hashing sets, for example.
    */
-  def symmetricHash[T](xs: TraversableOnce[T], seed: Int) = {
+  def symmetricHash[T](xs: TraversableOnce[T], seed: Int): Int = {
     var a, b, n = 0
     var c = 1
     xs.foreach(i ⇒ {

akka-actor/src/main/scala/akka/routing/Routing.scala

@@ -8,12 +8,10 @@ import akka.util.Duration
 import akka.util.duration._
 import akka.ConfigurationException
 import akka.pattern.pipe
-import akka.pattern.AskSupport
 import com.typesafe.config.Config
 import scala.collection.JavaConversions.iterableAsScalaIterable
 import java.util.concurrent.atomic.{ AtomicLong, AtomicBoolean }
 import java.util.concurrent.TimeUnit
-import java.util.concurrent.locks.ReentrantLock
 import akka.jsr166y.ThreadLocalRandom
 import akka.util.Unsafe
 import akka.dispatch.Dispatchers