SI-8362: AbstractPromise extends AtomicReference

mchv · adriaanm · commit 034f1b172077 · 2015-04-09T18:05:08.000-07:00
To avoid sun.misc.Unsafe, which is not supported on Google App Engine.
Deprecate AbstractPromise -- extend j.u.c.atomic.AtomicReference directly.

AtomicReference.compareAndSet() should also provide better performance on
HotSpot, which compiles it down to the machine's CAS instruction.

The binary incompatible change is ok because it's in an internal package.
I can't think of any real issue with adding a superclass (which contributes
only final methods) to a class in an implementation package (as long as
those methods were not introduced in any illicit subclasses of said class).

Instead of changing DefaultPromise's super class, let's be more
conservative, and do it closest to the source. This is both clearer and more
focussed, leaving those subclasses of AbstractPromise we never heard of
unaffected.

Genesis of the commit: since the work on Future performance, AbstractPromise
is using Unsafe breaking the ability for Future to be executed on GAE. At
that time, viktorklang suggested to implement a fallback in case Unsafe is
not available. carey proposed an implementation, and mchv submitted a patch,
which was refined by adriaanm.

Oh, implement AbstractPromise in Scala while we're at it.
diff --git a/bincompat-backward.whitelist.conf b/bincompat-backward.whitelist.conf
@@ -208,6 +208,11 @@ filter {
     {
         matchName="scala.reflect.io.ZipArchive.scala$reflect$io$ZipArchive$$walkIterator"
         problemName=MissingMethodProblem
+    },
+    // SI-8362 - package-protected class in an impl package
+    {
+        matchName="scala.concurrent.impl.Promise$DefaultPromise"
+        problemName=MissingTypesProblem
     }
   ]
 }
diff --git a/bincompat-forward.whitelist.conf b/bincompat-forward.whitelist.conf
@@ -319,6 +319,11 @@ filter {
     {
         matchName="scala.util.Random.scala$util$Random$$nextAlphaNum$1"
         problemName=MissingMethodProblem
+    },
+    // see SI-8362 - package-protected class in an impl package
+    {
+        matchName="scala.concurrent.impl.Promise$DefaultPromise"
+        problemName=MissingTypesProblem
     }
   ]
 }
diff --git a/src/library/scala/concurrent/impl/AbstractPromise.java b/src/library/scala/concurrent/impl/AbstractPromise.java
diff --git a/src/library/scala/concurrent/impl/AbstractPromise.scala b/src/library/scala/concurrent/impl/AbstractPromise.scala
@@ -0,0 +1,17 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003-2015, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
+package scala.concurrent.impl
+
+import java.util.concurrent.atomic.AtomicReference
+
+@deprecated("Extend java.util.concurrent.atomic.AtomicReference instead.", "2.11.7")
+private[impl] abstract class AbstractPromise extends AtomicReference[AnyRef] {
+  protected final def updateState(oldState: AnyRef, newState: AnyRef): Boolean = compareAndSet(oldState, newState)
+  protected final def getState(): AnyRef = get()
+}

Original file line number	Diff line number	Diff line change
`@@ -208,6 +208,11 @@ filter {`
`208`	`208`	`{`
`209`	`209`	`matchName="scala.reflect.io.ZipArchive.scala$reflect$io$ZipArchive$$walkIterator"`
`210`	`210`	`problemName=MissingMethodProblem`
	`211`	`+ },`
	`212`	`+ // SI-8362 - package-protected class in an impl package`
	`213`	`+ {`
	`214`	`+ matchName="scala.concurrent.impl.Promise$DefaultPromise"`
	`215`	`+ problemName=MissingTypesProblem`
`211`	`216`	`}`
`212`	`217`	`]`
`213`	`218`	`}`
Original file line number	Diff line number	Diff line change
`@@ -319,6 +319,11 @@ filter {`
`319`	`319`	`{`
`320`	`320`	`matchName="scala.util.Random.scala$util$Random$$nextAlphaNum$1"`
`321`	`321`	`problemName=MissingMethodProblem`
	`322`	`+ },`
	`323`	`+ // see SI-8362 - package-protected class in an impl package`
	`324`	`+ {`
	`325`	`+ matchName="scala.concurrent.impl.Promise$DefaultPromise"`
	`326`	`+ problemName=MissingTypesProblem`
`322`	`327`	`}`
`323`	`328`	`]`
`324`	`329`	`}`