Adding the Actor Migration Kit.

  Kit consists of:
    1) The StashingActor which adopts an interface similar to Akka.
    2) Props mockup for creating Akka like code
    3) Pattern mockup
    4) Test cases for every step in the migration.
    5) MigrationSystem which will paired on the Akka side.

  Review of the code : @phaller
  Review of the build: @jsuereth

21 files changed, 660 insertions, 15 deletions

diff --git a/src/actors-migration/scala/actors/MigrationSystem.scala b/src/actors-migration/scala/actors/MigrationSystem.scala
new file mode 100644
index 0000000000..ffc93d9c6f
--- /dev/null
+++ b/src/actors-migration/scala/actors/MigrationSystem.scala
@@ -0,0 +1,36 @@
+package scala.actors
+
+import scala.collection._
+
+object MigrationSystem {
+
+  private[actors] val contextStack = new ThreadLocal[immutable.Stack[Boolean]] {
+    override def initialValue() = immutable.Stack[Boolean]()
+  }
+
+  private[this] def withCleanContext(block: => ActorRef): ActorRef = {
+    // push clean marker
+    val old = contextStack.get
+    contextStack.set(old.push(true))
+    try {
+      val instance = block
+
+      if (instance eq null)
+        throw new Exception("Actor instance passed to actorOf can't be 'null'")
+
+      instance
+    } finally {
+      val stackAfter = contextStack.get
+      if (stackAfter.nonEmpty)
+        contextStack.set(if (!stackAfter.head) stackAfter.pop.pop else stackAfter.pop)
+    }
+  }
+
+  def actorOf(props: Props): ActorRef = withCleanContext {
+    val creator = props.creator()
+    val r = new InternalActorRef(creator)
+    creator.start()
+    r
+  }
+
+}
\ No newline at end of file
diff --git a/src/actors-migration/scala/actors/Pattern.scala b/src/actors-migration/scala/actors/Pattern.scala
new file mode 100644
index 0000000000..97dbd2cccd
--- /dev/null
+++ b/src/actors-migration/scala/actors/Pattern.scala
@@ -0,0 +1,25 @@
+package scala.actors
+
+import scala.concurrent.util.Duration
+
+object pattern {
+
+  implicit def askSupport(ar: ActorRef): AskableActorRef =
+    new AskableActorRef(ar)
+}
+
+/**
+ * ActorRef with support for ask(?) operation.
+ */
+class AskableActorRef(val ar: ActorRef) extends ActorRef {
+
+  def !(message: Any)(implicit sender: ActorRef = null): Unit = ar.!(message)(sender)
+
+  def ?(message: Any)(timeout: Timeout): Future[Any] = ar.?(message, timeout.duration)
+
+  private[actors] def ?(message: Any, timeout: Duration): Future[Any] = ar.?(message, timeout)
+
+  def forward(message: Any) = ar.forward(message)
+
+  private[actors] def localActor: AbstractActor = ar.localActor
+}
\ No newline at end of file
diff --git a/src/actors-migration/scala/actors/Props.scala b/src/actors-migration/scala/actors/Props.scala
new file mode 100644
index 0000000000..b4d18d5fad
--- /dev/null
+++ b/src/actors-migration/scala/actors/Props.scala
@@ -0,0 +1,14 @@
+package scala.actors
+
+/**
+ * ActorRef configuration object. It represents the minimal subset of Akka Props class.
+ */
+case class Props(creator: () ⇒ InternalActor, dispatcher: String) {
+
+  /**
+   * Returns a new Props with the specified creator set
+   *  Scala API
+   */
+  def withCreator(c: ⇒ InternalActor) = copy(creator = () ⇒ c)
+
+}
\ No newline at end of file
diff --git a/src/actors-migration/scala/actors/StashingActor.scala b/src/actors-migration/scala/actors/StashingActor.scala
new file mode 100644
index 0000000000..4bca879d9f
--- /dev/null
+++ b/src/actors-migration/scala/actors/StashingActor.scala
@@ -0,0 +1,261 @@
+package scala.actors
+
+import scala.collection._
+import scala.concurrent.util.Duration
+import java.util.concurrent.TimeUnit
+
+object StashingActor extends Combinators {
+  implicit def mkBody[A](body: => A) = new InternalActor.Body[A] {
+    def andThen[B](other: => B): Unit = Actor.rawSelf.seq(body, other)
+  }
+}
+
+@deprecated("Scala Actors are beeing removed from the standard library. Please refer to the migration guide.", "2.10")
+trait StashingActor extends InternalActor {
+  type Receive = PartialFunction[Any, Unit]
+
+  // checks if StashingActor is created within the actorOf block
+  creationCheck;
+
+  private[actors] val ref = new InternalActorRef(this)
+
+  val self: ActorRef = ref
+
+  protected[this] val context: ActorContext = new ActorContext(this)
+
+  @volatile
+  private var myTimeout: Option[Long] = None
+
+  private val stash = new MQueue[Any]("Stash")
+
+  /**
+   * Migration notes:
+   *   this method replaces receiveWithin, receive and react methods from Scala Actors.
+   */
+  def receive: Receive
+
+  /**
+   * User overridable callback.
+   * <p/>
+   * Is called when an Actor is started by invoking 'actor'.
+   */
+  def preStart() {}
+
+  /**
+   * User overridable callback.
+   * <p/>
+   * Is called when 'actor.stop()' is invoked.
+   */
+  def postStop() {}
+
+  /**
+   * User overridable callback.
+   * <p/>
+   * Is called on a crashed Actor right BEFORE it is restarted to allow clean
+   * up of resources before Actor is terminated.
+   * By default it calls postStop()
+   */
+  def preRestart(reason: Throwable, message: Option[Any]) { postStop() }
+
+  /**
+   * Changes the Actor's behavior to become the new 'Receive' (PartialFunction[Any, Unit]) handler.
+   * Puts the behavior on top of the hotswap stack.
+   * If "discardOld" is true, an unbecome will be issued prior to pushing the new behavior to the stack
+   */
+  private def become(behavior: Receive, discardOld: Boolean = true) {
+    if (discardOld) unbecome()
+    behaviorStack = behaviorStack.push(wrapWithSystemMessageHandling(behavior))
+  }
+
+  /**
+   * Reverts the Actor behavior to the previous one in the hotswap stack.
+   */
+  private def unbecome() {
+    // never unbecome the initial behavior
+    if (behaviorStack.size > 1)
+      behaviorStack = behaviorStack.pop
+  }
+
+  /**
+   * User overridable callback.
+   * <p/>
+   * Is called when a message isn't handled by the current behavior of the actor
+   * by default it does: EventHandler.warning(self, message)
+   */
+  def unhandled(message: Any) {
+    println("unhandeld")
+    message match {
+      case _ => throw new UnhandledMessageException(message, self)
+    }
+  }
+
+  protected def sender: ActorRef = new OutputChannelRef(internalSender)
+
+  override def act(): Unit = internalAct()
+
+  override def start(): StashingActor = {
+    super.start()
+    this
+  }
+
+  override def receive[R](f: PartialFunction[Any, R]): R
+
+  /*
+   * Internal implementation.
+   */
+
+  private[actors] var behaviorStack = immutable.Stack[PartialFunction[Any, Unit]]()
+
+  /*
+   * Checks that StashingActor can be created only by MigrationSystem.actorOf method.
+   */
+  private[this] def creationCheck = {
+
+    // creation check (see ActorRef)
+    val context = MigrationSystem.contextStack.get
+    if (context.isEmpty)
+      throw new RuntimeException("In order to create StashingActor one must use actorOf.")
+    else {
+      if (!context.head)
+        throw new RuntimeException("Only one actor can be created per actorOf call.")
+      else
+        MigrationSystem.contextStack.set(context.push(false))
+    }
+
+  }
+
+  private[actors] override def preAct() {
+    preStart()
+  }
+
+  /**
+   * Adds message to a stash, to be processed later. Stashed messages can be fed back into the $actor's
+   *  mailbox using <code>unstashAll()</code>.
+   *
+   *  Temporarily stashing away messages that the $actor does not (yet) handle simplifies implementing
+   *  certain messaging protocols.
+   */
+  final def stash(msg: Any): Unit = {
+    stash.append(msg, null)
+  }
+
+  final def unstashAll(): Unit = {
+    mailbox.prepend(stash)
+    stash.clear()
+  }
+
+  /**
+   * Wraps any partial function with Exit message handling.
+   */
+  private[actors] def wrapWithSystemMessageHandling(pf: PartialFunction[Any, Unit]): PartialFunction[Any, Unit] = {
+
+    def swapExitHandler(pf: PartialFunction[Any, Unit]) = new PartialFunction[Any, Unit] {
+      def swapExit(v: Any) = v match {
+        case Exit(from, reason) =>
+
+          Terminated(new InternalActorRef(from.asInstanceOf[InternalActor]))
+        case v => v
+      }
+
+      def isDefinedAt(v: Any) = pf.isDefinedAt(swapExit(v))
+      def apply(v: Any) = pf(swapExit(v))
+    }
+
+    swapExitHandler(pf orElse {
+      case m => unhandled(m)
+    })
+  }
+
+  /**
+   * Method that models the behavior of Akka actors.
+   */
+  private[actors] def internalAct() {
+    trapExit = true
+    behaviorStack = behaviorStack.push(wrapWithSystemMessageHandling(receive))
+    loop {
+      if (myTimeout.isDefined)
+        reactWithin(myTimeout.get)(behaviorStack.top)
+      else
+        react(behaviorStack.top)
+    }
+  }
+
+  private[actors] override def internalPostStop() = postStop()
+
+  // Used for pattern matching statement similar to Akka
+  lazy val ReceiveTimeout = TIMEOUT
+
+  /**
+   * Used to simulate Akka context behavior. Should be used only for migration purposes.
+   */
+  protected[actors] class ActorContext(val actr: StashingActor) {
+
+    /**
+     * Changes the Actor's behavior to become the new 'Receive' (PartialFunction[Any, Unit]) handler.
+     * Puts the behavior on top of the hotswap stack.
+     * If "discardOld" is true, an unbecome will be issued prior to pushing the new behavior to the stack
+     */
+    def become(behavior: Receive, discardOld: Boolean = true) = actr.become(behavior, discardOld)
+
+    /**
+     * Reverts the Actor behavior to the previous one in the hotswap stack.
+     */
+    def unbecome() = actr.unbecome()
+
+    /**
+     * Shuts down the actor its dispatcher and message queue.
+     */
+    def stop(subject: ActorRef): Nothing = if (subject != ref)
+      throw new RuntimeException("Only stoping of self is allowed during migration.")
+    else
+      actr.exit()
+
+    /**
+     * Registers this actor as a Monitor for the provided ActorRef.
+     * @return the provided ActorRef
+     */
+    def watch(subject: ActorRef): ActorRef = {
+      actr.watch(subject)
+      subject
+    }
+
+    /**
+     * Unregisters this actor as Monitor for the provided ActorRef.
+     * @return the provided ActorRef
+     */
+    def unwatch(subject: ActorRef): ActorRef = {
+      actr unwatch subject
+      subject
+    }
+
+    /**
+     * Defines the receiver timeout value.
+     */
+    final def setReceiveTimeout(timeout: Duration): Unit =
+      actr.myTimeout = Some(timeout.toMillis)
+
+    /**
+     * Gets the current receiveTimeout
+     */
+    final def receiveTimeout: Option[Duration] =
+      actr.myTimeout.map(Duration(_, TimeUnit.MILLISECONDS))
+
+  }
+}
+
+/**
+ * This message is thrown by default when an Actors behavior doesn't match a message
+ */
+case class UnhandledMessageException(msg: Any, ref: ActorRef = null) extends Exception {
+
+  def this(msg: String) = this(msg, null)
+
+  // constructor with 'null' ActorRef needed to work with client instantiation of remote exception
+  override def getMessage =
+    if (ref ne null) "Actor %s does not handle [%s]".format(ref, msg)
+    else "Actor does not handle [%s]".format(msg)
+
+  override def fillInStackTrace() = this //Don't waste cycles generating stack trace
+}
+
+case class Terminated(actor: ActorRef)
diff --git a/src/actors-migration/scala/actors/Timeout.scala b/src/actors-migration/scala/actors/Timeout.scala
new file mode 100644
index 0000000000..bb3c8c0476
--- /dev/null
+++ b/src/actors-migration/scala/actors/Timeout.scala
@@ -0,0 +1,34 @@
+/**
+ * Copyright (C) 2009-2011 Typesafe Inc. <http://www.typesafe.com>
+ */
+package scala.actors
+
+import scala.concurrent.util.Duration
+import java.util.concurrent.TimeUnit
+
+case class Timeout(duration: Duration) {
+  def this(timeout: Long) = this(Duration(timeout, TimeUnit.MILLISECONDS))
+  def this(length: Long, unit: TimeUnit) = this(Duration(length, unit))
+}
+
+object Timeout {
+
+  /**
+   * A timeout with zero duration, will cause most requests to always timeout.
+   */
+  val zero = new Timeout(Duration.Zero)
+
+  /**
+   * A Timeout with infinite duration. Will never timeout. Use extreme caution with this
+   * as it may cause memory leaks, blocked threads, or may not even be supported by
+   * the receiver, which would result in an exception.
+   */
+  val never = new Timeout(Duration.Inf)
+
+  def apply(timeout: Long) = new Timeout(timeout)
+  def apply(length: Long, unit: TimeUnit) = new Timeout(length, unit)
+
+  implicit def durationToTimeout(duration: Duration) = new Timeout(duration)
+  implicit def intToTimeout(timeout: Int) = new Timeout(timeout)
+  implicit def longToTimeout(timeout: Long) = new Timeout(timeout)
+}
diff --git a/src/actors/scala/actors/ActorRef.scala b/src/actors/scala/actors/ActorRef.scala
new file mode 100644
index 0000000000..8f70b13e01
--- /dev/null
+++ b/src/actors/scala/actors/ActorRef.scala
@@ -0,0 +1,119 @@
+package scala.actors
+
+import java.util.concurrent.TimeoutException
+import scala.concurrent.util.Duration
+
+/**
+ * Trait used for migration of Scala actors to Akka.
+ */
+@deprecated("ActorRef ought to be used only with the Actor Migration Kit.")
+trait ActorRef {
+
+  /**
+   * Sends a one-way asynchronous message. E.g. fire-and-forget semantics.
+   * <p/>
+   *
+   * If invoked from within an actor then the actor reference is implicitly passed on as the implicit 'sender' argument.
+   * <p/>
+   *
+   * This actor 'sender' reference is then available in the receiving actor in the 'sender' member variable,
+   * if invoked from within an Actor. If not then no sender is available.
+   * <pre>
+   *   actor ! message
+   * </pre>
+   * <p/>
+   */
+  def !(message: Any)(implicit sender: ActorRef = null): Unit
+
+  /**
+   * Sends a message asynchronously, returning a future which may eventually hold the reply.
+   */
+  private[actors] def ?(message: Any, timeout: Duration): Future[Any]
+
+  /**
+   * Forwards the message and passes the original sender actor as the sender.
+   * <p/>
+   * Works with '!' and '?'.
+   */
+  def forward(message: Any)
+
+  private[actors] def localActor: AbstractActor
+
+}
+
+private[actors] class OutputChannelRef(val actor: OutputChannel[Any]) extends ActorRef {
+
+  override private[actors] def ?(message: Any, timeout: Duration): Future[Any] =
+    throw new UnsupportedOperationException("Output channel does not support ?")
+
+  /**
+   * Sends a one-way asynchronous message. E.g. fire-and-forget semantics.
+   * <p/>
+   *
+   * <p/>
+   * <pre>
+   *   actor ! message
+   * </pre>
+   * <p/>
+   */
+  def !(message: Any)(implicit sender: ActorRef = null): Unit =
+    if (sender != null)
+      actor.send(message, sender.localActor)
+    else
+      actor ! message
+
+  override def equals(that: Any) =
+    that.isInstanceOf[OutputChannelRef] && that.asInstanceOf[OutputChannelRef].actor == this.actor
+
+  private[actors] override def localActor: AbstractActor =
+    throw new UnsupportedOperationException("Output channel does not have an instance of the actor")
+
+  def forward(message: Any): Unit = throw new UnsupportedOperationException("OutputChannel does not support forward.")
+
+}
+
+private[actors] class ReactorRef(override val actor: Reactor[Any]) extends OutputChannelRef(actor) {
+
+  /**
+   * Forwards the message and passes the original sender actor as the sender.
+   * <p/>
+   * Works with '!' and '?'.
+   */
+  override def forward(message: Any) = actor.forward(message)
+
+}
+
+private[actors] final class InternalActorRef(override val actor: InternalActor) extends ReactorRef(actor) {
+
+  /**
+   * Sends a message asynchronously, returning a future which may eventually hold the reply.
+   */
+  override private[actors] def ?(message: Any, timeout: Duration): Future[Any] =
+    Futures.future {
+      val dur = if (timeout.isFinite()) timeout.toMillis else (java.lang.Long.MAX_VALUE >> 2)
+      actor !? (dur, message) match {
+        case Some(x) => x
+        case None => new AskTimeoutException("? operation timed out.")
+      }
+    }
+
+  override def !(message: Any)(implicit sender: ActorRef = null): Unit =
+    if (message == PoisonPill)
+      actor.stop('normal)
+    else if (sender != null)
+      actor.send(message, sender.localActor)
+    else
+      actor ! message
+
+  private[actors] override def localActor: InternalActor = this.actor
+}
+
+/**
+ * This is what is used to complete a Future that is returned from an ask/? call,
+ * when it times out.
+ */
+class AskTimeoutException(message: String, cause: Throwable) extends TimeoutException {
+  def this(message: String) = this(message, null: Throwable)
+}
+
+object PoisonPill
diff --git a/src/actors/scala/actors/ActorTask.scala b/src/actors/scala/actors/ActorTask.scala
index bb04302238..045b00f5f2 100644
--- a/src/actors/scala/actors/ActorTask.scala
+++ b/src/actors/scala/actors/ActorTask.scala
@@ -51,7 +51,6 @@ private[actors] class ActorTask(actor: InternalActor,
         super.terminateExecution(e)
         () => {}
       }
-      actor.internalPostStop
       res
     }
 
diff --git a/src/actors/scala/actors/InternalActor.scala b/src/actors/scala/actors/InternalActor.scala
index c94da5b9fd..cb66021d1c 100644
--- a/src/actors/scala/actors/InternalActor.scala
+++ b/src/actors/scala/actors/InternalActor.scala
@@ -153,7 +153,7 @@ private[actors] trait InternalActor extends AbstractActor with InternalReplyReac
         val matches = f.isDefinedAt(m)
         senders = senders.tail
         matches
-      }) 
+      })
       if (null eq qel) {
         val todo = synchronized {
           // in mean time new stuff might have arrived
@@ -317,6 +317,35 @@ private[actors] trait InternalActor extends AbstractActor with InternalReplyReac
   }
 
   /**
+   * Links <code>self</code> to actor <code>to</code>.
+   *
+   * @param to the actor to link to
+   * @return   the parameter actor
+   */
+  def link(to: ActorRef): ActorRef = {
+    this.link(to.localActor)
+    to
+  }
+
+  /**
+   *  Unidirectional linking. For migration purposes only
+   */
+  private[actors] def watch(subject: ActorRef): ActorRef = {
+    assert(Actor.self(scheduler) == this, "link called on actor different from self")
+    subject.localActor linkTo this
+    subject
+  }
+
+  /**
+   *  Unidirectional linking. For migration purposes only
+   */
+  private[actors] def unwatch(subject: ActorRef): ActorRef = {
+    assert(Actor.self(scheduler) == this, "link called on actor different from self")
+    subject.localActor unlinkFrom this
+    subject
+  }
+
+  /**
    * Links <code>self</code> to the actor defined by <code>body</code>.
    *
    * @param body the body of the actor to link to
@@ -346,17 +375,24 @@ private[actors] trait InternalActor extends AbstractActor with InternalReplyReac
     from unlinkFrom this
   }
 
+  /**
+   * Unlinks <code>self</code> from actor <code>from</code>.
+   */
+  def unlink(from: ActorRef) {
+    unlink(from.localActor)
+  }
+
   private[actors] def unlinkFrom(from: AbstractActor) = synchronized {
     links = links.filterNot(from.==)
   }
 
-  @volatile  
+  @volatile
   private[actors] var _trapExit = false
-  
+
   def trapExit = _trapExit
-  
+
   def trapExit_=(value: Boolean) = _trapExit = value
-  
+
   // guarded by this
   private var exitReason: AnyRef = 'normal
   // guarded by this
@@ -445,12 +481,11 @@ private[actors] trait InternalActor extends AbstractActor with InternalReplyReac
     scheduler.onTerminate(this) { f }
   }
 
-  private[actors] def internalPostStop() = {}
 
-  private[actors] def stop(reason: AnyRef): Unit = {    
+  private[actors] def stop(reason: AnyRef): Unit = {
     synchronized {
       shouldExit = true
-      exitReason = reason      
+      exitReason = reason
       // resume this Actor in a way that
       // causes it to exit
       // (because shouldExit == true)
@@ -464,7 +499,7 @@ private[actors] trait InternalActor extends AbstractActor with InternalReplyReac
         /* Here we should not throw a SuspendActorControl,
            since the current method is called from an actor that
            is in the process of exiting.
-           
+
            Therefore, the contract for scheduleActor is that
            it never throws a SuspendActorControl.
          */
diff --git a/src/actors/scala/actors/MQueue.scala b/src/actors/scala/actors/MQueue.scala
index 65427d68c5..4a148d2cb3 100644
--- a/src/actors/scala/actors/MQueue.scala
+++ b/src/actors/scala/actors/MQueue.scala
@@ -25,6 +25,20 @@ private[actors] class MQueue[Msg >: Null](protected val label: String) {
     _size += diff
   }
 
+  def prepend(other: MQueue[Msg]) {
+    if (!other.isEmpty) {
+      other.last.next = first
+      first = other.first
+    }
+  }
+
+  def clear() {
+    first = null
+    last = null
+    _size = 0
+  }
+
+
   def append(msg: Msg, session: OutputChannel[Any]) {
     changeSize(1) // size always increases by 1
     val el = new MQueueElement(msg, session)
diff --git a/src/actors/scala/actors/Reactor.scala b/src/actors/scala/actors/Reactor.scala
index 206a97d97c..7a8d738758 100644
--- a/src/actors/scala/actors/Reactor.scala
+++ b/src/actors/scala/actors/Reactor.scala
@@ -214,11 +214,16 @@ trait Reactor[Msg >: Null] extends OutputChannel[Msg] with Combinators {
     scheduler executeFromActor makeReaction(null, handler, msg)
   }
 
+  private[actors] def preAct() = {}
+
   // guarded by this
   private[actors] def dostart() {
     _state = Actor.State.Runnable
     scheduler newActor this
-    scheduler execute makeReaction(() => act(), null, null)
+    scheduler execute makeReaction(() => {
+      preAct()
+      act()
+    }, null, null)
   }
 
   /**
@@ -285,12 +290,15 @@ trait Reactor[Msg >: Null] extends OutputChannel[Msg] with Combinators {
     throw Actor.suspendException
   }
 
+  private[actors] def internalPostStop() = {}
+
   private[actors] def terminated() {
     synchronized {
       _state = Actor.State.Terminated
       // reset waitingFor, otherwise getState returns Suspended
       waitingFor = Reactor.waitingForNone
     }
+    internalPostStop()
     scheduler.terminated(this)
   }
 
diff --git a/src/build/maven/maven-deploy.xml b/src/build/maven/maven-deploy.xml
index ac0f8f745b..7ab54f81c3 100644
--- a/src/build/maven/maven-deploy.xml
+++ b/src/build/maven/maven-deploy.xml
@@ -112,6 +112,7 @@
         <deploy-local name="scala-compiler" version="@{version}" repository="@{repository}" />
         <deploy-local-plugin name="continuations" version="@{version}" repository="@{repository}"/>
         <deploy-local name="scala-actors" version="@{version}" repository="@{repository}" />
+        <deploy-local name="scala-actors-migration" version="@{version}" repository="@{repository}" />
         <deploy-local name="scala-swing" version="@{version}" repository="@{repository}"/>
         <deploy-local name="scalap" version="@{version}" repository="@{repository}"/>
         <deploy-local name="scala-partest" version="@{version}" repository="@{repository}"/>
@@ -172,6 +173,7 @@
         <deploy-remote name="scala-compiler" version="@{version}" repository="@{repository}" />
         <deploy-remote name="scala-swing" version="@{version}" repository="@{repository}"/>
         <deploy-remote name="scala-actors" version="@{version}" repository="@{repository}"/>
+        <deploy-remote name="scala-actors-migration" version="@{version}" repository="@{repository}"/>
         <deploy-remote name="scalap" version="@{version}" repository="@{repository}"/>
         <deploy-remote name="scala-partest" version="@{version}" repository="@{repository}"/>
         <deploy-remote-plugin name="continuations" version="@{version}" repository="@{repository}"/> 
@@ -239,6 +241,7 @@
         <deploy-remote-signed name="scala-compiler" version="@{version}" repository="@{repository}" />
         <deploy-remote-signed name="scala-swing" version="@{version}" repository="@{repository}"/>
         <deploy-remote-signed name="scala-actors" version="@{version}" repository="@{repository}"/>
+        <deploy-remote-signed name="scala-actors-migration" version="@{version}" repository="@{repository}"/>
         <deploy-remote-signed name="scalap" version="@{version}" repository="@{repository}"/>
         <deploy-remote-signed name="scala-partest" version="@{version}" repository="@{repository}"/>
       </sequential>
diff --git a/src/build/maven/scala-actors-migration.pom b/src/build/maven/scala-actors-migration.pom
new file mode 100644
index 0000000000..93fc34ece9
--- /dev/null
+++ b/src/build/maven/scala-actors-migration.pom
@@ -0,0 +1,66 @@
+<project
+        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+        <modelVersion>4.0.0</modelVersion>
+        <groupId>org.scala-lang</groupId>
+        <artifactId>scala-actors-migration</artifactId>
+        <packaging>jar</packaging>
+        <version>@VERSION@</version>
+  <name>Scala Migration Kit</name>
+  <description>Migration kit that enables easy transition from the Scala Actors to Akka.</description>
+  <url>http://www.scala-lang.org/</url>
+  <inceptionYear>2012</inceptionYear>
+  <organization>
+      <name>LAMP/EPFL</name>
+      <url>http://lamp.epfl.ch/</url>
+   </organization>
+   <licenses>
+      <license>
+         <name>BSD-like</name>
+         <url>http://www.scala-lang.org/downloads/license.html
+         </url>
+         <distribution>repo</distribution>
+      </license>
+   </licenses>
+   <scm>
+      <connection>scm:git:git://github.com/scala/scala.git</connection>
+      <url>https://github.com/scala/scala.git</url>
+   </scm>
+   <issueManagement>
+      <system>JIRA</system>
+      <url>https://issues.scala-lang.org/</url>
+   </issueManagement>
+        <dependencies>
+                <dependency>
+                        <groupId>org.scala-lang</groupId>
+                        <artifactId>scala-library</artifactId>
+                        <version>@VERSION@</version>
+                </dependency>
+                <dependency>
+                        <groupId>org.scala-lang</groupId>
+                        <artifactId>scala-actors</artifactId>
+                        <version>@VERSION@</version>
+                </dependency>
+        </dependencies>
+        <distributionManagement>
+                <repository>
+                        <id>scala-tools.org</id>
+                        <url>@RELEASE_REPOSITORY@</url>
+                </repository>
+                <snapshotRepository>
+                        <id>scala-tools.org</id>
+                        <url>@SNAPSHOT_REPOSITORY@</url>
+                        <uniqueVersion>false</uniqueVersion>
+                </snapshotRepository>
+        </distributionManagement>
+  <developers>
+    <developer>
+      <id>lamp</id>
+      <name>EPFL LAMP</name>
+    </developer>
+    <developer>
+      <id>Typesafe</id>
+      <name>Typesafe, Inc.</name>
+    </developer>
+  </developers>
+</project>
diff --git a/src/build/pack.xml b/src/build/pack.xml
index f96c6b9799..956beaef88 100644
--- a/src/build/pack.xml
+++ b/src/build/pack.xml
@@ -139,6 +139,7 @@ MAIN DISTRIBUTION PACKAGING
     <mvn-copy-lib mvn.artifact.name="scala-compiler"/>
     <mvn-copy-lib mvn.artifact.name="scala-swing"/>
     <mvn-copy-lib mvn.artifact.name="scala-actors"/>
+    <mvn-copy-lib mvn.artifact.name="scala-actors-migration"/>
     <mvn-copy-lib mvn.artifact.name="scala-partest"/>
     <mvn-copy-lib mvn.artifact.name="scalap"/>
   </target>
@@ -201,6 +202,11 @@ MAIN DISTRIBUTION PACKAGING
          basedir="${build-docs.dir}/continuations-plugin">
       <include name="**/*"/>
     </jar>
+    <jar destfile="${dists.dir}/maven/${version.number}/scala-actors-migration/scala-actors-migration-docs.jar"
+           basedir="${build-docs.dir}/actors-migration">
+        <include name="**/*"/>
+    </jar>
+
     <!-- TODO - Scala swing and actors should maybe have thier own jar, but creating it is SLOW. -->
     <copy tofile="${dists.dir}/maven/${version.number}/scala-swing/scala-swing-docs.jar"
           file="${dists.dir}/maven/${version.number}/scala-library/scala-library-docs.jar"/>
diff --git a/src/partest/scala/tools/partest/PartestTask.scala b/src/partest/scala/tools/partest/PartestTask.scala
index ad2e155182..67b38d2e24 100644
--- a/src/partest/scala/tools/partest/PartestTask.scala
+++ b/src/partest/scala/tools/partest/PartestTask.scala
@@ -309,6 +309,16 @@ class PartestTask extends Task with CompilationPathProperty {
       }
     } getOrElse sys.error("Provided classpath does not contain a Scala actors.")
 
+    val scalaActorsMigration = {
+      (classpath.list map { fs => new File(fs) }) find { f =>
+        f.getName match {
+          case "scala-actors-migration.jar" => true
+          case "actors-migration" if (f.getParentFile.getName == "classes") => true
+          case _ => false
+        }
+      }
+    } getOrElse sys.error("Provided classpath does not contain a Scala actors.")
+
     def scalacArgsFlat: Option[Seq[String]] = scalacArgs map (_ flatMap { a =>
       val parts = a.getParts
       if(parts eq null) Seq[String]() else parts.toSeq
@@ -335,6 +345,7 @@ class PartestTask extends Task with CompilationPathProperty {
     antFileManager.LATEST_COMP = scalaCompiler.getAbsolutePath
     antFileManager.LATEST_PARTEST = scalaPartest.getAbsolutePath
     antFileManager.LATEST_ACTORS = scalaActors.getAbsolutePath
+    antFileManager.LATEST_ACTORS_MIGRATION = scalaActorsMigration.getAbsolutePath
 
     javacmd foreach (x => antFileManager.JAVACMD = x.getAbsolutePath)
     javaccmd foreach (x => antFileManager.JAVAC_CMD = x.getAbsolutePath)
diff --git a/src/partest/scala/tools/partest/nest/AntRunner.scala b/src/partest/scala/tools/partest/nest/AntRunner.scala
index e77385d6e9..dc83e4ea66 100644
--- a/src/partest/scala/tools/partest/nest/AntRunner.scala
+++ b/src/partest/scala/tools/partest/nest/AntRunner.scala
@@ -23,6 +23,7 @@ class AntRunner extends DirectRunner {
     var LATEST_COMP: String = _
     var LATEST_PARTEST: String = _
     var LATEST_ACTORS: String = _
+    var LATEST_ACTORS_MIGRATION: String = _
     val testRootPath: String = "test"
     val testRootDir: Directory = Directory(testRootPath)
   }
diff --git a/src/partest/scala/tools/partest/nest/ConsoleFileManager.scala b/src/partest/scala/tools/partest/nest/ConsoleFileManager.scala
index 8d239a84bd..b270a6b65a 100644
--- a/src/partest/scala/tools/partest/nest/ConsoleFileManager.scala
+++ b/src/partest/scala/tools/partest/nest/ConsoleFileManager.scala
@@ -84,6 +84,7 @@ class ConsoleFileManager extends FileManager {
       latestFile        = testClassesDir.parent / "bin"
       latestLibFile     = testClassesDir / "library"
       latestActorsFile  = testClassesDir / "library" / "actors"
+      latestActMigFile  = testClassesDir / "actors-migration"
       latestCompFile    = testClassesDir / "compiler"
       latestPartestFile = testClassesDir / "partest"
       latestFjbgFile    = testParent / "lib" / "fjbg.jar"
@@ -94,6 +95,7 @@ class ConsoleFileManager extends FileManager {
       latestFile        = dir / "bin"
       latestLibFile     = dir / "lib/scala-library.jar"
       latestActorsFile  = dir / "lib/scala-actors.jar"
+      latestActMigFile  = dir / "lib/scala-actors-migration.jar"
       latestCompFile    = dir / "lib/scala-compiler.jar"
       latestPartestFile = dir / "lib/scala-partest.jar"
       latestFjbgFile    = testParent / "lib" / "fjbg.jar"
@@ -104,6 +106,7 @@ class ConsoleFileManager extends FileManager {
         latestFile        = prefixFile("build/quick/bin")
         latestLibFile     = prefixFile("build/quick/classes/library")
         latestActorsFile  = prefixFile("build/quick/classes/library/actors")
+        latestActMigFile  = prefixFile("build/quick/classes/actors-migration")
         latestCompFile    = prefixFile("build/quick/classes/compiler")
         latestPartestFile = prefixFile("build/quick/classes/partest")
       }
@@ -114,6 +117,7 @@ class ConsoleFileManager extends FileManager {
         latestFile        = prefixFileWith(p, "bin")
         latestLibFile     = prefixFileWith(p, "lib/scala-library.jar")
         latestActorsFile  = prefixFileWith(p, "lib/scala-actors.jar")
+        latestActMigFile  = prefixFileWith(p, "lib/scala-actors-migration.jar")
         latestCompFile    = prefixFileWith(p, "lib/scala-compiler.jar")
         latestPartestFile = prefixFileWith(p, "lib/scala-partest.jar")
       }
@@ -123,6 +127,7 @@ class ConsoleFileManager extends FileManager {
         latestFile        = prefixFile("dists/latest/bin")
         latestLibFile     = prefixFile("dists/latest/lib/scala-library.jar")
         latestActorsFile  = prefixFile("dists/latest/lib/scala-actors.jar")
+        latestActMigFile  = prefixFile("dists/latest/lib/scala-actors-migration.jar")
         latestCompFile    = prefixFile("dists/latest/lib/scala-compiler.jar")
         latestPartestFile = prefixFile("dists/latest/lib/scala-partest.jar")
       }
@@ -132,6 +137,7 @@ class ConsoleFileManager extends FileManager {
         latestFile        = prefixFile("build/pack/bin")
         latestLibFile     = prefixFile("build/pack/lib/scala-library.jar")
         latestActorsFile  = prefixFile("build/pack/lib/scala-actors.jar")
+        latestActMigFile  = prefixFile("build/pack/lib/scala-actors-migration.jar")
         latestCompFile    = prefixFile("build/pack/lib/scala-compiler.jar")
         latestPartestFile = prefixFile("build/pack/lib/scala-partest.jar")
       }
@@ -167,16 +173,19 @@ class ConsoleFileManager extends FileManager {
     LATEST_COMP = latestCompFile.getAbsolutePath
     LATEST_PARTEST = latestPartestFile.getAbsolutePath
     LATEST_ACTORS = latestActorsFile.getAbsolutePath
+    LATEST_ACTORS_MIGRATION = latestActMigFile.getAbsolutePath
   }
 
   var LATEST_LIB: String = ""
   var LATEST_COMP: String = ""
   var LATEST_PARTEST: String = ""
   var LATEST_ACTORS: String = ""
+  var LATEST_ACTORS_MIGRATION: String = ""
 
   var latestFile: File = _
   var latestLibFile: File = _
   var latestActorsFile: File = _
+  var latestActMigFile: File = _
   var latestCompFile: File = _
   var latestPartestFile: File = _
   var latestFjbgFile: File = _
diff --git a/src/partest/scala/tools/partest/nest/DirectRunner.scala b/src/partest/scala/tools/partest/nest/DirectRunner.scala
index 20f435cfbb..815c27f567 100644
--- a/src/partest/scala/tools/partest/nest/DirectRunner.scala
+++ b/src/partest/scala/tools/partest/nest/DirectRunner.scala
@@ -61,10 +61,10 @@ trait DirectRunner {
     val latestLibFile = new File(fileManager.LATEST_LIB)
     val latestPartestFile = new File(fileManager.LATEST_PARTEST)
     val latestActorsFile = new File(fileManager.LATEST_ACTORS)
-
+    val latestActMigFile = new File(fileManager.LATEST_ACTORS_MIGRATION)
     val scalacheckURL = PathSettings.scalaCheck.toURL
     val scalaCheckParentClassLoader = ScalaClassLoader.fromURLs(
-      scalacheckURL :: (List(latestCompFile, latestLibFile, latestActorsFile, latestPartestFile).map(_.toURI.toURL))
+      scalacheckURL :: (List(latestCompFile, latestLibFile, latestActorsFile, latestActMigFile, latestPartestFile).map(_.toURI.toURL))
     )
     Output.init()
 
diff --git a/src/partest/scala/tools/partest/nest/FileManager.scala b/src/partest/scala/tools/partest/nest/FileManager.scala
index 6d9e64730f..cf7160f521 100644
--- a/src/partest/scala/tools/partest/nest/FileManager.scala
+++ b/src/partest/scala/tools/partest/nest/FileManager.scala
@@ -63,6 +63,7 @@ trait FileManager extends FileUtil {
   var LATEST_COMP: String
   var LATEST_PARTEST: String
   var LATEST_ACTORS: String
+  var LATEST_ACTORS_MIGRATION: String
 
   var showDiff = false
   var updateCheck = false
diff --git a/src/partest/scala/tools/partest/nest/ReflectiveRunner.scala b/src/partest/scala/tools/partest/nest/ReflectiveRunner.scala
index a0511774a9..a5d5952ff7 100644
--- a/src/partest/scala/tools/partest/nest/ReflectiveRunner.scala
+++ b/src/partest/scala/tools/partest/nest/ReflectiveRunner.scala
@@ -48,9 +48,9 @@ class ReflectiveRunner {
         new ConsoleFileManager
 
     import fileManager.
-      { latestCompFile, latestLibFile, latestPartestFile, latestFjbgFile, latestScalapFile, latestActorsFile }
+      { latestCompFile, latestLibFile, latestPartestFile, latestFjbgFile, latestScalapFile, latestActorsFile, latestActMigFile }
     val files =
-      Array(latestCompFile, latestLibFile, latestPartestFile, latestFjbgFile, latestScalapFile, latestActorsFile) map (x => io.File(x))
+      Array(latestCompFile, latestLibFile, latestPartestFile, latestFjbgFile, latestScalapFile, latestActorsFile, latestActMigFile) map (x => io.File(x))
 
     val sepUrls   = files map (_.toURL)
     var sepLoader = new URLClassLoader(sepUrls, null)
diff --git a/src/partest/scala/tools/partest/nest/SBTRunner.scala b/src/partest/scala/tools/partest/nest/SBTRunner.scala
index 5d994eeb37..14e2dc3df9 100644
--- a/src/partest/scala/tools/partest/nest/SBTRunner.scala
+++ b/src/partest/scala/tools/partest/nest/SBTRunner.scala
@@ -16,6 +16,7 @@ object SBTRunner extends DirectRunner {
     var LATEST_COMP: String     = _
     var LATEST_PARTEST: String     = _
     var LATEST_ACTORS: String     = _
+    var LATEST_ACTORS_MIGRATION: String     = _
     val testRootPath: String   = "test"
     val testRootDir: Directory = Directory(testRootPath)
   }
@@ -65,6 +66,7 @@ object SBTRunner extends DirectRunner {
     fileManager.LATEST_COMP = findClasspath("scala-compiler", "scala-compiler") getOrElse sys.error("No scala-compiler found! Classpath = " + fileManager.CLASSPATH)
     fileManager.LATEST_PARTEST = findClasspath("scala-partest", "partest") getOrElse sys.error("No scala-partest found! Classpath = " + fileManager.CLASSPATH)
     fileManager.LATEST_ACTORS = findClasspath("scala-actors", "actors") getOrElse sys.error("No scala-actors found! Classpath = " + fileManager.CLASSPATH)
+    fileManager.LATEST_ACTORS_MIGRATION = findClasspath("scala-actors-migration", "actors-migration") getOrElse sys.error("No scala-actors-migration found! Classpath = " + fileManager.CLASSPATH)
 
     // TODO - Do something useful here!!!
     fileManager.JAVAC_CMD = "javac"
diff --git a/src/partest/scala/tools/partest/nest/Worker.scala b/src/partest/scala/tools/partest/nest/Worker.scala
index 9326a8b232..40325c6375 100644
--- a/src/partest/scala/tools/partest/nest/Worker.scala
+++ b/src/partest/scala/tools/partest/nest/Worker.scala
@@ -56,6 +56,7 @@ class ScalaCheckFileManager(val origmanager: FileManager) extends FileManager {
   var LATEST_COMP: String = origmanager.LATEST_COMP
   var LATEST_PARTEST: String = origmanager.LATEST_PARTEST
   var LATEST_ACTORS: String = origmanager.LATEST_ACTORS
+  var LATEST_ACTORS_MIGRATION: String = origmanager.LATEST_ACTORS_MIGRATION
 }
 
 object Output {