Sbt-compatible implementation of `isPastXXXPhase`

sbt's [API extraction phase](https://github.com/sbt/sbt/blob/0.13/compile/interface/src/main/scala/xsbt/API.scala#L25)
extends `scala.reflect.internal.Phase`, which implements a bunch of methods,
such as `erasedTypes` as `false`, which are then overridden by scalac
in `GlobalPhase` (nested in scala.tools.nsc.Global).
(`erasedTypes` in particular is again overridden in the back-end -- for performance?)

However, since sbt's compiler phases extend `reflect.internal.Phase`,
the logic for detecting the current phase does not work,
as the default implementation is called (simply returning `false`),
when chasing the `prev` pointers hits an sbt-injected phase,
as its implementation is `reflect.internal`'s constant `false`.

2 files changed, 8 insertions, 13 deletions

diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala
index 70582c82c8..26e2b75c2a 100644
--- a/src/compiler/scala/tools/nsc/Global.scala
+++ b/src/compiler/scala/tools/nsc/Global.scala
@@ -384,15 +384,6 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
 
     def apply(unit: CompilationUnit): Unit
 
-    private val isErased = prev.name == "erasure" || prev.erasedTypes
-    override def erasedTypes: Boolean = isErased
-    private val isFlat = prev.name == "flatten" || prev.flatClasses
-    override def flatClasses: Boolean = isFlat
-    private val isSpecialized = prev.name == "specialize" || prev.specialized
-    override def specialized: Boolean = isSpecialized
-    private val isRefChecked = prev.name == "refchecks" || prev.refChecked
-    override def refChecked: Boolean = isRefChecked
-
     /** Is current phase cancelled on this unit? */
     def cancelled(unit: CompilationUnit) = {
       // run the typer only if in `createJavadoc` mode
diff --git a/src/reflect/scala/reflect/internal/Phase.scala b/src/reflect/scala/reflect/internal/Phase.scala
index 1ecc202a07..a761f686e6 100644
--- a/src/reflect/scala/reflect/internal/Phase.scala
+++ b/src/reflect/scala/reflect/internal/Phase.scala
@@ -39,10 +39,14 @@ abstract class Phase(val prev: Phase) {
   def description: String = name
   // Will running with -Ycheck:name work?
   def checkable: Boolean = true
-  def specialized: Boolean = false
-  def erasedTypes: Boolean = false
-  def flatClasses: Boolean = false
-  def refChecked: Boolean = false
+
+  // NOTE: sbt injects its own phases which extend this class, and not GlobalPhase, so we must implement this logic here
+  private val _erasedTypes = ((prev ne null) && (prev ne NoPhase)) && (prev.name == "erasure" || prev.erasedTypes)
+  def erasedTypes: Boolean = _erasedTypes // overridden in back-end
+  final val flatClasses: Boolean   = ((prev ne null) && (prev ne NoPhase)) && (prev.name == "flatten"    || prev.flatClasses)
+  final val specialized: Boolean   = ((prev ne null) && (prev ne NoPhase)) && (prev.name == "specialize" || prev.specialized)
+  final val refChecked: Boolean    = ((prev ne null) && (prev ne NoPhase)) && (prev.name == "refchecks"  || prev.refChecked)
+
 
   /** This is used only in unsafeTypeParams, and at this writing is
    *  overridden to false in parser, namer, typer, and erasure. (And NoPhase.)