Removed devirtualize.

It was time. Removed unused flags and devirtualize detritus. Cleaned up
flags a bit further. Fixed the contents of phaseNewFlags in those places
where it was inaccurate. No review.

17 files changed, 69 insertions, 735 deletions

diff --git a/src/compiler/scala/reflect/internal/Flags.scala b/src/compiler/scala/reflect/internal/Flags.scala
index de3607ffe9..13feff36b9 100644
--- a/src/compiler/scala/reflect/internal/Flags.scala
+++ b/src/compiler/scala/reflect/internal/Flags.scala
@@ -63,8 +63,8 @@ import api.Modifier
 // 46:
 // 47:
 // 48:
-// 49:     latePRIVATE
-// 50:    lateABSTRACT
+// 49:     latePRIVATE    (eliminated)
+// 50:    lateABSTRACT    (eliminated)
 // 51:    lateDEFERRED
 // 52:       lateFINAL
 // 53:      lateMETHOD
@@ -73,10 +73,10 @@ import api.Modifier
 // 56:    notPROTECTED
 // 57:     notOVERRIDE
 // 58:      notPRIVATE
-// 59:     notABSTRACT
-// 60:     notDEFERRED
-// 61:        notFINAL
-// 62:       notMETHOD
+// 59:     notABSTRACT    (eliminated)
+// 60:     notDEFERRED    (eliminated)
+// 61:        notFINAL    (eliminated)
+// 62:       notMETHOD    (eliminated)
 // 63:
 
 /** Flags set on Modifiers instances in the parsing stage.
@@ -118,6 +118,10 @@ class ModifierFlags {
 
   // Overridden.
   def flagToString(flag: Long): String = ""
+
+  final val PrivateLocal: Long   = PRIVATE | LOCAL
+  final val ProtectedLocal: Long = PROTECTED | LOCAL
+  final val AccessFlags: Long    = PRIVATE | PROTECTED | LOCAL
 }
 object ModifierFlags extends ModifierFlags
 
@@ -169,49 +173,30 @@ class Flags extends ModifierFlags {
 
   // ------- late flags (set by a transformer phase) ---------------------------------
   //
-  // Summary of how these are actually used, if at all.  You can
-  // get this output with scalac -Xshow-phases -Ydebug.  Only these
-  // flags are admitted to by the phases:
+  // Summary of when these are claimed to be first used.
+  // You can get this output with scalac -Xshow-phases -Ydebug.
   //
   //     refchecks   7  [START] <latemethod>
-  // explicitouter  14  [START] <latefinal> <notprotected> <notprivate>
+  //    specialize  13  [START] <latefinal> <notprivate>
+  // explicitouter  14  [START] <notprotected>
   //       erasure  15  [START] <latedeferred> <lateinterface>
-  //         mixin  20  [START] <latemodule> <notabstract>
+  //         mixin  20  [START] <latemodule> <notoverride>
   //
-  // lateDEFERRED set in AddInterfaces, Mixin, etc.
-  // lateFINAL set in Symbols#makeNotPrivate.
-  // lateINTERFACE set in AddInterfaces#transformMixinInfo.
   // lateMETHOD set in RefChecks#transformInfo.
-  // lateMODULE set in Mixin#transformInfo.
-  // notABSTRACT never set.
+  // lateFINAL set in Symbols#makeNotPrivate.
   // notPRIVATE set in Symbols#makeNotPrivate, IExplicitOuter#transform, Inliners.
   // notPROTECTED set in ExplicitOuter#transform.
-  //
-  // Of the flags never mentioned in a phase's newFlags or nextFlags:
-  //
-  // lateABSTRACT only set in devirtualize.
-  // latePRIVATE never set.
-  // notDEFERRED only set in devirtualize.
-  // notFINAL only set in devirtualize.
-  // notMETHOD never set.
-  // notOVERRIDE set in mixin, not declared.
-  //
-  // Summary of redundant and/or incorrect late/antiflags:
-  //   Never used: notABSTRACT, notDEFERRED, notFINAL, notMETHOD, latePRIVATE, lateABSTRACT
-  //   Used without being declared: notOVERRIDE
+  // lateDEFERRED set in AddInterfaces, Mixin, etc.
+  // lateINTERFACE set in AddInterfaces#transformMixinInfo.
+  // lateMODULE set in Mixin#transformInfo.
+  // notOVERRIDE set in Mixin#preTransform.
 
-  final val lateABSTRACT  = (ABSTRACT: Long) << LateShift
   final val lateDEFERRED  = (DEFERRED: Long) << LateShift
   final val lateFINAL     = (FINAL: Long) << LateShift
   final val lateINTERFACE = (INTERFACE: Long) << LateShift
   final val lateMETHOD    = (METHOD: Long) << LateShift
   final val lateMODULE    = (MODULE: Long) << LateShift
-  final val latePRIVATE   = (PRIVATE: Long) << LateShift
 
-  final val notABSTRACT   = (ABSTRACT: Long) << AntiShift
-  final val notDEFERRED   = (DEFERRED: Long) << AntiShift
-  final val notFINAL      = (FINAL: Long) << AntiShift
-  final val notMETHOD     = (METHOD: Long) << AntiShift
   final val notOVERRIDE   = (OVERRIDE: Long) << AntiShift
   final val notPRIVATE    = (PRIVATE: Long) << AntiShift
   final val notPROTECTED  = (PROTECTED: Long) << AntiShift
@@ -238,7 +223,6 @@ class Flags extends ModifierFlags {
   final val FieldFlags: Long =
     MUTABLE | CASEACCESSOR | PARAMACCESSOR | STATIC | FINAL | PRESUPER | LAZY
 
-  final val AccessFlags: Long   = PRIVATE | PROTECTED | LOCAL
   final val VarianceFlags       = COVARIANT | CONTRAVARIANT
   final val ConstrFlags: Long   = JAVA
 
@@ -368,8 +352,8 @@ class Flags extends ModifierFlags {
     case     0x400000000000L => ""                                    // (1L << 46)
     case     0x800000000000L => ""                                    // (1L << 47)
     case    0x1000000000000L => ""                                    // (1L << 48)
-    case       `latePRIVATE` => "<lateprivate>"                       // (1L << 49)
-    case      `lateABSTRACT` => "<lateabstract>"                      // (1L << 50)
+    // case       `latePRIVATE` => "<lateprivate>"                       // (1L << 49)
+    // case      `lateABSTRACT` => "<lateabstract>"                      // (1L << 50)
     case      `lateDEFERRED` => "<latedeferred>"                      // (1L << 51)
     case         `lateFINAL` => "<latefinal>"                         // (1L << 52)
     case        `lateMETHOD` => "<latemethod>"                        // (1L << 53)
@@ -378,10 +362,10 @@ class Flags extends ModifierFlags {
     case      `notPROTECTED` => "<notprotected>"                      // (1L << 56)
     case       `notOVERRIDE` => "<notoverride>"                       // (1L << 57)
     case        `notPRIVATE` => "<notprivate>"                        // (1L << 58)
-    case       `notABSTRACT` => "<notabstract>"                       // (1L << 59)
-    case       `notDEFERRED` => "<notdeferred>"                       // (1L << 60)
-    case          `notFINAL` => "<notfinal>"                          // (1L << 61)
-    case         `notMETHOD` => "<notmethod>"                         // (1L << 62)
+    // case       `notABSTRACT` => "<notabstract>"                       // (1L << 59)
+    // case       `notDEFERRED` => "<notdeferred>"                       // (1L << 60)
+    // case          `notFINAL` => "<notfinal>"                          // (1L << 61)
+    // case         `notMETHOD` => "<notmethod>"                         // (1L << 62)
     case 0x8000000000000000L => ""                                    // (1L << 63)
     case _ => ""
   }
@@ -390,17 +374,17 @@ class Flags extends ModifierFlags {
     var f = flags
     val pw =
       if (privateWithin == "") {
-        if ((flags & (PRIVATE | LOCAL)) == (PRIVATE | LOCAL).toLong) {
-          f = f & ~(PRIVATE | LOCAL)
+        if ((flags & PrivateLocal) == PrivateLocal) {
+          f &= ~PrivateLocal
           "private[this]"
-        } else if ((flags & (PROTECTED | LOCAL)) == (PROTECTED | LOCAL).toLong) {
-          f = f & ~(PROTECTED | LOCAL)
+        } else if ((flags & ProtectedLocal) == ProtectedLocal) {
+          f &= ~ProtectedLocal
           "protected[this]"
         } else {
           ""
         }
       } else if ((f & PROTECTED) != 0L) {
-        f = f & ~PROTECTED
+        f &= ~PROTECTED
         "protected[" + privateWithin + "]"
       } else {
         "private[" + privateWithin + "]"
diff --git a/src/compiler/scala/reflect/internal/HasFlags.scala b/src/compiler/scala/reflect/internal/HasFlags.scala
index 4c03c43c2c..46dca0940a 100644
--- a/src/compiler/scala/reflect/internal/HasFlags.scala
+++ b/src/compiler/scala/reflect/internal/HasFlags.scala
@@ -151,8 +151,8 @@ trait HasFlags {
   def isInterface = hasFlag(INTERFACE)
 
   // Newly introduced based on having a reasonably obvious clean translation.
-  def isPrivateLocal   = hasAllFlags(PRIVATE | LOCAL)
-  def isProtectedLocal = hasAllFlags(PROTECTED | LOCAL)
+  def isPrivateLocal   = hasAllFlags(PrivateLocal)
+  def isProtectedLocal = hasAllFlags(ProtectedLocal)
   def isParamAccessor  = hasFlag(PARAMACCESSOR)
   def isCaseAccessor   = hasFlag(CASEACCESSOR)
   def isSuperAccessor  = hasFlag(SUPERACCESSOR)
@@ -174,7 +174,7 @@ trait HasFlags {
 
   // Dropped isTerm condition because flag isn't overloaded.
   def isAbstractOverride = hasFlag(ABSOVERRIDE)
-
+  def isAnyOverride = hasFlag(OVERRIDE | ABSOVERRIDE)
   def isDefaultInit = hasFlag(DEFAULTINIT)
 
   // Disambiguating: DEFAULTPARAM, TRAIT
diff --git a/src/compiler/scala/reflect/internal/Phase.scala b/src/compiler/scala/reflect/internal/Phase.scala
index 996fd423d0..5637a86de3 100644
--- a/src/compiler/scala/reflect/internal/Phase.scala
+++ b/src/compiler/scala/reflect/internal/Phase.scala
@@ -31,7 +31,6 @@ abstract class Phase(val prev: Phase) {
   def description: String = name
   // Will running with -Ycheck:name work?
   def checkable: Boolean = true
-  // def devirtualized: Boolean = false
   def specialized: Boolean = false
   def erasedTypes: Boolean = false
   def flatClasses: Boolean = false
diff --git a/src/compiler/scala/reflect/internal/Symbols.scala b/src/compiler/scala/reflect/internal/Symbols.scala
index 7127e989fb..b459c64978 100644
--- a/src/compiler/scala/reflect/internal/Symbols.scala
+++ b/src/compiler/scala/reflect/internal/Symbols.scala
@@ -773,13 +773,9 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
      *  be set if PRIVATE is currently set.
      */
     final def setNotFlag(flag: Int) = if (hasFlag(flag)) setFlag((flag: @annotation.switch) match {
-      case FINAL     => notFINAL
       case PRIVATE   => notPRIVATE
-      case DEFERRED  => notDEFERRED
       case PROTECTED => notPROTECTED
-      case ABSTRACT  => notABSTRACT
       case OVERRIDE  => notOVERRIDE
-      case METHOD    => notMETHOD
       case _         => abort("setNotFlag on invalid flag: " + flag)
     })
 
diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala
index 8ebab43b10..ca50979e9c 100644
--- a/src/compiler/scala/tools/nsc/Global.scala
+++ b/src/compiler/scala/tools/nsc/Global.scala
@@ -340,8 +340,6 @@ class Global(var currentSettings: Settings, var reporter: Reporter) extends Symb
     override def erasedTypes: Boolean = isErased
     private val isFlat = prev.name == "flatten" || prev.flatClasses
     override def flatClasses: Boolean = isFlat
-    // private val isDevirtualized = prev.name == "devirtualize" || prev.devirtualized
-    // override def devirtualized: Boolean = isDevirtualized  // (part of DEVIRTUALIZE)
     private val isSpecialized = prev.name == "specialize" || prev.specialized
     override def specialized: Boolean = isSpecialized
     private val isRefChecked = prev.name == "refchecks" || prev.refChecked
diff --git a/src/compiler/scala/tools/nsc/ast/TreeGen.scala b/src/compiler/scala/tools/nsc/ast/TreeGen.scala
index ee0b28b02f..2b6f5c241f 100644
--- a/src/compiler/scala/tools/nsc/ast/TreeGen.scala
+++ b/src/compiler/scala/tools/nsc/ast/TreeGen.scala
@@ -73,7 +73,7 @@ abstract class TreeGen extends reflect.internal.TreeGen {
 
     mval.addAnnotation(AnnotationInfo(VolatileAttr.tpe, Nil, Nil))
     if (mval.owner.isClass) {
-      mval setFlag (PRIVATE | LOCAL | SYNTHETIC)
+      mval setFlag (PrivateLocal | SYNTHETIC)
       mval.owner.info.decls.enter(mval)
     }
     ValDef(mval)
diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
index 07aebb6f32..17688d42d8 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
@@ -2021,7 +2021,7 @@ self =>
               in.nextToken()
             case _ =>
               if (mods.flags != Flags.PARAMACCESSOR) accept(VAL)
-              if (!caseParam) mods |= Flags.PRIVATE | Flags.LOCAL
+              if (!caseParam) mods |= Flags.PrivateLocal
           }
           if (caseParam) mods |= Flags.CASEACCESSOR
         }
diff --git a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala
index 724b30ef44..94d3e3e640 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala
@@ -530,7 +530,7 @@ abstract class TreeBuilder {
     require(cases.nonEmpty)
 
     val selectorName = freshTermName()
-    val valdef = atPos(selector.pos)(ValDef(Modifiers(PRIVATE | LOCAL | SYNTHETIC), selectorName, TypeTree(), selector))
+    val valdef = atPos(selector.pos)(ValDef(Modifiers(PrivateLocal | SYNTHETIC), selectorName, TypeTree(), selector))
     val nselector = Ident(selectorName)
 
     def loop(cds: List[CaseDef]): Match = {
@@ -579,7 +579,7 @@ abstract class TreeBuilder {
           val tmp = freshTermName()
           val firstDef =
             atPos(matchExpr.pos) {
-              ValDef(Modifiers(PRIVATE | LOCAL | SYNTHETIC | (mods.flags & LAZY)),
+              ValDef(Modifiers(PrivateLocal | SYNTHETIC | (mods.flags & LAZY)),
                      tmp, TypeTree(), matchExpr)
             }
           var cnt = 0
diff --git a/src/compiler/scala/tools/nsc/transform/Constructors.scala b/src/compiler/scala/tools/nsc/transform/Constructors.scala
index dc8585e8cb..f364c75a21 100644
--- a/src/compiler/scala/tools/nsc/transform/Constructors.scala
+++ b/src/compiler/scala/tools/nsc/transform/Constructors.scala
@@ -466,7 +466,7 @@ abstract class Constructors extends Transform with ast.TreeDSL {
             closureClass.setInfo(new ClassInfoType(closureParents, new Scope, closureClass))
 
             val outerField = closureClass.newValue(impl.pos, nme.OUTER)
-              .setFlag(PRIVATE | LOCAL | PARAMACCESSOR)
+              .setFlag(PrivateLocal | PARAMACCESSOR)
               .setInfo(clazz.tpe)
 
             val applyMethod = closureClass.newMethod(impl.pos, nme.apply)
diff --git a/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala b/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala
index 8db759266b..809dbe7695 100644
--- a/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala
+++ b/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala
@@ -28,7 +28,7 @@ abstract class ExplicitOuter extends InfoTransform
   import Debug.TRACE
 
   /** The following flags may be set by this phase: */
-  override def phaseNewFlags: Long = notPRIVATE | notPROTECTED | lateFINAL
+  override def phaseNewFlags: Long = notPROTECTED
 
   /** the name of the phase: */
   val phaseName: String = "explicitouter"
@@ -150,7 +150,7 @@ abstract class ExplicitOuter extends InfoTransform
         val restpe = if (clazz.isTrait) clazz.outerClass.tpe else clazz.outerClass.thisType
         decls1 enter (clazz.newOuterAccessor(clazz.pos) setInfo MethodType(Nil, restpe))
         if (hasOuterField(clazz)) { //2
-          val access = if (clazz.isEffectivelyFinal) PRIVATE | LOCAL else PROTECTED
+          val access = if (clazz.isEffectivelyFinal) PrivateLocal else PROTECTED
           decls1 enter (
             clazz.newValue(clazz.pos, nme.OUTER_LOCAL)
             setFlag (SYNTHETIC | PARAMACCESSOR | access)
diff --git a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
index d5d7bdd1e9..ad4b1f2429 100644
--- a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
+++ b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
@@ -154,7 +154,7 @@ abstract class LambdaLift extends InfoTransform {
           case DefDef(_, _, _, _, _, _) =>
             if (sym.isLocal) {
               renamable addEntry sym
-              sym setFlag (PRIVATE | LOCAL | FINAL)
+              sym setFlag (PrivateLocal | FINAL)
             } else if (sym.isPrimaryConstructor) {
               symSet(called, sym) addEntry sym.owner
             }
@@ -216,7 +216,7 @@ abstract class LambdaLift extends InfoTransform {
             proxies(owner) =
               for (fv <- freeValues.toList) yield {
                 val proxy = owner.newValue(owner.pos, fv.name)
-                  .setFlag(if (owner.isClass) PARAMACCESSOR | PRIVATE | LOCAL else PARAM)
+                  .setFlag(if (owner.isClass) PARAMACCESSOR | PrivateLocal else PARAM)
                   .setFlag(SYNTHETIC)
                   .setInfo(fv.info);
                 if (owner.isClass) owner.info.decls enter proxy;
diff --git a/src/compiler/scala/tools/nsc/transform/Mixin.scala b/src/compiler/scala/tools/nsc/transform/Mixin.scala
index db39eda3b6..885a15c419 100644
--- a/src/compiler/scala/tools/nsc/transform/Mixin.scala
+++ b/src/compiler/scala/tools/nsc/transform/Mixin.scala
@@ -20,7 +20,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
   val phaseName: String = "mixin"
 
   /** The phase might set the following new flags: */
-  override def phaseNewFlags: Long = lateMODULE | notABSTRACT
+  override def phaseNewFlags: Long = lateMODULE | notOVERRIDE
 
   /** This map contains a binding (class -> info) if
    *  the class with this info at phase mixinPhase has been treated for mixin composition
@@ -160,7 +160,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
         //   println("before erasure: "+ (field.info))
         // }
         clazz.newMethod(field.pos, nme.getterName(field.name))
-          .setFlag(field.flags & ~(PRIVATE | LOCAL) | ACCESSOR | lateDEFERRED |
+          .setFlag(field.flags & ~PrivateLocal | ACCESSOR | lateDEFERRED |
                      (if (field.isMutable) 0 else STABLE))
           .setInfo(MethodType(List(), field.info)) // TODO preserve pre-erasure info?
       }
@@ -171,7 +171,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
         //println("creating new setter for "+field+field.locationString+(field hasFlag MUTABLE))
         val setterName = nme.getterToSetter(nme.getterName(field.name))
         val setter = clazz.newMethod(field.pos, setterName)
-          .setFlag(field.flags & ~(PRIVATE | LOCAL) | ACCESSOR | lateDEFERRED)
+          .setFlag(field.flags & ~PrivateLocal | ACCESSOR | lateDEFERRED)
         setter.setInfo(MethodType(setter.newSyntheticValueParams(List(field.info)), UnitClass.tpe))  // TODO preserve pre-erasure info?
         if (needsExpandedSetterName(field)) {
           //println("creating expanded setter from "+field)
@@ -320,7 +320,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
                     sym.updateInfo(member.tpe.resultType) // info at current phase
                     addMember(clazz,
                               sym
-                                setFlag (LOCAL | PRIVATE | member.getFlag(MUTABLE | LAZY))
+                                setFlag (PrivateLocal | member.getFlag(MUTABLE | LAZY))
                                 setFlag (if (!member.hasStableFlag) MUTABLE else 0)
                                 setAnnotations accessed.annotations)
                 }
@@ -708,10 +708,13 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
             sym addAnnotation AnnotationInfo(VolatileAttr.tpe, Nil, Nil)
           }
 
-          bitmapOperation(field,
-            {sym.addAnnotation(AnnotationInfo(TransientAttr.tpe, Nil, Nil)); sym.setFlag(PRIVATE | LOCAL)},
-            sym.setFlag(PRIVATE | LOCAL),
-            sym.setFlag(if (checkinitField) (PRIVATE | LOCAL) else PROTECTED))
+          // What's going on here, why is setFlag called three times?
+          bitmapOperation(
+            field,
+            { sym.addAnnotation(AnnotationInfo(TransientAttr.tpe, Nil, Nil)); sym.setFlag(PrivateLocal) },
+            sym setFlag PrivateLocal,
+            sym setFlag (if (checkinitField) PrivateLocal else PROTECTED)
+          )
 
           clazz0.info.decls.enter(sym)
           if (clazz0 == clazz)
diff --git a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
index 89d50f4cc3..bdb76181a5 100644
--- a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
+++ b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
@@ -17,6 +17,9 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
   /** the name of the phase: */
   val phaseName: String = "specialize"
 
+  /** The following flags may be set by this phase: */
+  override def phaseNewFlags: Long = notPRIVATE | lateFINAL
+
   /** This phase changes base classes. */
   override def changesBaseClasses = true
   override def keepsTypeParams = true
diff --git a/src/compiler/scala/tools/nsc/typechecker/DeVirtualize.scala b/src/compiler/scala/tools/nsc/typechecker/DeVirtualize.scala
deleted file mode 100644
index ab32a425c7..0000000000
--- a/src/compiler/scala/tools/nsc/typechecker/DeVirtualize.scala
+++ /dev/null
@@ -1,645 +0,0 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2011 LAMP/EPFL
- * @author  Martin Odersky
- */
-
-package scala.tools.nsc
-package typechecker
-
-import symtab.Flags._
-import transform.{ InfoTransform, TypingTransformers }
-import scala.collection.mutable.ListBuffer
-
-abstract class DeVirtualize /* extends InfoTransform with TypingTransformers {
-
-  import global._
-  import definitions._
-  import typer.{typed, typedOperator, atOwner}
-
-  /** the following two members override abstract members in Transform */
-  val phaseName: String = "devirtualize"
-
-  /** The phase might set the following new flags: */
-  override def phaseNextFlags: Long = notDEFERRED | notOVERRIDE | notFINAL | lateABSTRACT
-
-  def newTransformer(unit: CompilationUnit): DeVirtualizeTransformer =
-    new DeVirtualizeTransformer(unit)
-
-  /** The class does not change base-classes of existing classes */
-  override def changesBaseClasses = false
-
-  def transformInfo(sym: Symbol, tp: Type): Type =
-    if (sym.isThisSym && sym.owner.isVirtualClass) {
-      val clazz = sym.owner
-      intersectionType(
-        List(
-          appliedType(abstractType(clazz).typeConstructor, clazz.typeParams map (_.tpe)),
-          clazz.tpe))
-    } else devirtualizeMap(tp)
-
-  /* todo:
-     handle constructor arguments
-     check: overriding classes must have same type params
-     virtual classes cannot have self types
-   */
-
-  /** Do the following transformations everywhere in a type:
-   *
-   * 1. Replace a virtual class
-   *
-   *  attrs mods class VC[Ts] <: Ps { decls }
-   *
-   * by the following symbols
-   *
-   *  attrs mods1 type VC[Ts] <: dvm(Ps) with VC$trait[Ts]
-   *  attrs mods2 trait VC$trait[Ts] extends AnyRef with ScalaObject {
-   *    this: VC[Ts] with VC$trait[Ts] => decls1
-   *  }
-   *
-   * The class symbol VC becomes the symbol of the workertrait.
-   *
-   *  dvm    is the devirtalization mapping which converts refs to
-   *         virtual classes to refs to their abstract types (@see devirtualize)
-   *  mods1  are the modifiers inherited to abstract types
-   *  mods2  are the modifiers inherited to worker traits
-   *  decls1 is decls but members that have an override modifier
-   *         lose it and any final modifier as well.
-   *
-   * 2. For all virtual member classes VC which
-   *    are not abstract and which are or inherit from a virtual class defined in current class
-   *    add a factory (@see mkFactory)
-   * 3. Convert TypeRef's to VC where VC is a virtual class to TypeRef's to AT, where AT
-   *    is the abstract type corresponding to VC.
-   *
-   *  Note: If a class inherits vc's from two different paths, a vc in the
-   *  inheriting class has to be created beforehand. This is done in phase ??? (NOT YET DONE!)
-   *
-   *  Note: subclasses of virtual classes are treated as if they are virtual.
-   *  isVirtualClass returns true for them also.
-   */
-  object devirtualizeMap extends TypeMap {
-    def apply(tp: Type): Type = mapOver(tp) match {
-      case tp1 @ ClassInfoType(parents, decls0, clazz) =>
-        var decls = decls0
-        def enter(sym: Symbol) = // at next phase because names of worker traits change
-          atPhase(ownPhase.next) { decls.enter(sym) }
-        if (containsVirtuals(clazz)) {
-          decls = new Scope
-          for (m <- decls0.toList) {
-            if (m.isVirtualClass) {
-              m.setFlag(notDEFERRED | notFINAL | lateABSTRACT)
-              enter(mkAbstractType(m))
-            }
-            enter(m)
-          }
-          for (m <- classesInNeedOfFactories(clazz))
-            enter(mkFactory(m, clazz))
-        }
-        if (clazz.isVirtualClass) {
-          println("virtual class: "+clazz+clazz.locationString)
-          transformOwnerInfo(clazz)
-          decls = new Scope
-
-          // add virtual fields for all primary constructor parameters
-          for (row <- paramTypesAndIndices(clazz.primaryConstructor.tpe, 0))
-            for ((pt, i) <- row)
-              enter(mkParamField(clazz, i, devirtualizeMap(pt)))
-
-          // remove OVERRIDE from all workertrait members, except if they override a member in Object
-          for (m <- decls0.toList) {
-            if (!m.isConstructor) {
-              if ((m hasFlag OVERRIDE) && m.overriddenSymbol(ObjectClass) == NoSymbol)
-                m setFlag (notOVERRIDE | notFINAL)
-              enter(m)
-            }
-          }
-          if (clazz.thisSym == clazz) clazz.typeOfThis = clazz.thisType
-            // ... to give a hook on which we can hang selftype transformers
-          ClassInfoType(List(ObjectClass.tpe, ScalaObjectClass.tpe), decls, clazz)
-        } else {
-          ClassInfoType(parents map this, decls, clazz)
-        }
-      case tp1 @ TypeRef(pre, clazz, args) if clazz.isVirtualClass =>
-        TypeRef(pre, abstractType(clazz), args)
-      case tp1 =>
-        tp1
-    }
-  }
-
-  /** Transform owner of given clazz symbol */
-  protected def transformOwnerInfo(clazz: Symbol) { atPhase(ownPhase.next) { clazz.owner.info } }
-
-  /** Names of derived classes and factories */
-  protected def concreteClassName(clazz: Symbol) =
-    atPhase(ownPhase) { newTypeName(clazz.name+"$fix") }
-  protected def factoryName(clazz: Symbol) =
-    atPhase(ownPhase) { newTermName("new$"+clazz.name) }
-
-  /** Does `clazz` contain virtual classes? */
-  protected def containsVirtuals(clazz: Symbol) = clazz.info.decls exists (_.isVirtualClass)
-
-  /** The inner classes that need factory methods in `clazz`
-   *  This is intended to catch situations like the following
-   *
-   *  abstract class C {
-   *    class V <: {...}
-   *    class W extends V
-   *  }
-   *  class D extends C {
-   *    class V <: {...}
-   *    // factories needed for V and W!
-   *  }
-   */
-  protected def classesInNeedOfFactories(clazz: Symbol) = atPhase(ownPhase) {
-    def isOverriddenVirtual(c: Symbol) =
-      c.isVirtualClass && clazz.info.decl(c.name).isVirtualClass
-    val xs = clazz.info.members.toList filter (x => x.isVirtualClass && !x.hasFlag(ABSTRACT))
-    for (m <- clazz.info.members.toList;
-         if (m.isVirtualClass && !(m hasFlag ABSTRACT) &&
-             (m.info.baseClasses exists isOverriddenVirtual))) yield m
-  }
-
-  /** The abstract type corresponding to a virtual class. */
-  protected def abstractType(clazz: Symbol): Symbol =  atPhase(ownPhase.next) {
-    val abstpe = clazz.owner.info.decl(atPhase(ownPhase) { clazz.name })
-    assert(abstpe.isAbstractType)
-    abstpe
-  }
-
-  /** The factory corresponding to a virtual class. */
-  protected def factory(clazz: Symbol, owner: Symbol) = atPhase(ownPhase.next) {
-    val fsym = owner.info.member(factoryName(clazz))
-    assert(fsym.isMethod, clazz)
-    fsym
-  }
-
-  /** The name of the field representing a constructor parameter of a virtual class */
-  protected def paramFieldName(clazz: Symbol, index: Int) = atPhase(ownPhase) {
-    nme.expandedName(newTermName("param$"+index), clazz)
-  }
-
-  /** The name of the field representing a constructor parameter of a virtual class */
-  protected def fixParamName(index: Int) = newTermName("fix$"+index)
-
-  /** The field representing a constructor parameter of a virtual class */
-  protected def paramField(clazz: Symbol, index: Int) = atPhase(ownPhase.next) {
-    clazz.info.decl(paramFieldName(clazz, index))
-  }
-
-  /** The flags that an abstract type can inherit from its virtual class */
-  protected val absTypeFlagMask = AccessFlags | DEFERRED
-
-  /** The flags that a factory method can inherit from its virtual class */
-  protected val factoryFlagMask = AccessFlags
-
-  /** Create a polytype with given type parameters and given type, or return just the type
-   *  if type params is empty. */
-  protected def mkPolyType(tparams: List[Symbol], tp: Type) =
-    if (tparams.isEmpty) tp else PolyType(tparams, tp)
-
-  /** A lazy type to complete `sym`, which is is generated for virtual class
-   *  `clazz`.
-   *  The info of the symbol is computed by method `getInfo`.
-   *  It is wrapped in copies of the type parameters of `clazz`.
-   */
-  abstract class PolyTypeCompleter(sym: Symbol, clazz: Symbol) extends LazyType {
-    def getInfo: Type
-    override val typeParams = cloneSymbols(clazz.typeParams, sym)
-    override def complete(sym: Symbol) {
-      sym.setInfo(
-        mkPolyType(typeParams, getInfo.substSym(clazz.typeParams, typeParams)))
-    }
-  }
-
-  protected def wasVirtualClass(sym: Symbol) = {
-    sym.isVirtualClass || {
-      sym.info
-      sym hasFlag notDEFERRED
-    }
-  }
-
-  protected def addOverriddenVirtuals(clazz: Symbol) = {
-    (clazz.allOverriddenSymbols filter wasVirtualClass) ::: List(clazz)
-  }
-
-  protected def addOverriddenVirtuals(tpe: Type) = tpe match {
-    case TypeRef(pre, sym, args) =>
-      { for (vc <- sym.allOverriddenSymbols if wasVirtualClass(vc))
-        yield typeRef(pre, vc, args) }.reverse ::: List(tpe)
-  }
-
-  protected def mkParamField(clazz: Symbol, index: Int, tpe: Type): Symbol = {
-    val param = clazz.newMethod(clazz.pos, paramFieldName(clazz, index))
-      .setFlag(PROTECTED | LOCAL | DEFERRED | EXPANDEDNAME | SYNTHETIC | STABLE)
-    atPhase(ownPhase.next) {
-      param.setInfo(NullaryMethodType(tpe))
-    }
-    param
-  }
-
-  protected def mkAbstractType(clazz: Symbol): Symbol = {
-    val cabstype = clazz.owner.newAbstractType(clazz.pos, clazz.name)
-      .setFlag(clazz.flags & absTypeFlagMask | SYNTHETIC)
-      .setAnnotations(clazz.annotations)
-    atPhase(ownPhase.next) {
-      cabstype setInfo new PolyTypeCompleter(cabstype, clazz) {
-        def getInfo = {
-          val parents1 = clazz.info.parents map {
-            p => devirtualizeMap(p.substSym(clazz.typeParams, typeParams))
-          }
-          val parents2 = addOverriddenVirtuals(clazz) map {
-            c => typeRef(clazz.owner.thisType, c, typeParams map (_.tpe))
-          }
-          TypeBounds(NothingClass.tpe, intersectionType(parents1 ::: parents2))
-        }
-      }
-    }
-  }
-
-  protected def paramTypesAndIndices(tpe: Type, start: Int): List[List[(Type, Int)]] = tpe match {
-    case PolyType(_, restpe) => paramTypesAndIndices(restpe, start)
-    case MethodType(params, restpe) =>
-      val end = start + params.length
-      (tpe.paramTypes zip List.range(start, end)) :: paramTypesAndIndices(restpe, end)
-    case _ =>
-      List()
-  }
-
-  /* Add a factory symbol for a virtual class
-   *
-   *  attrs mods class VC[Ts] <: Ps { decls }
-   *  with base classes BC[Us]'s
-   *
-   * which corresponds to the following definition :
-   *
-   *  attrs mods3 def new$VC[Ts](): VC[Ts] = {
-   *    class VC$fix extends v2w(BC's[Ts]) with VC$trait[Ts] { ... }
-   *    new VC$fix
-   *  }
-   *
-   * where
-   *
-   *  mods3  are the modifiers inherited to factories
-   *  v2w maps every virtual class to its workertrait and leaves other types alone.
-   *
-   *  @param  clazz    The virtual class for which factory is added
-   *  @param  owner    The owner for which factory is added as a member
-   *  @param  scope    The scope into which factory is entered
-   */
-  def mkFactory(clazz: Symbol, owner: Symbol): Symbol = {
-    val pos = if (clazz.owner == owner) clazz.pos else owner.pos
-    val factory = owner.newMethod(pos, factoryName(clazz))
-      .setFlag(clazz.flags & factoryFlagMask | SYNTHETIC)
-      .setAnnotations(clazz.annotations)
-    factory setInfo new PolyTypeCompleter(factory, clazz) {
-      private def copyType(tpe: Type): Type = tpe match {
-        case MethodType(formals, restpe) => MethodType(formals, copyType(restpe))
-        case NullaryMethodType(restpe) => NullaryMethodType(copyType(restpe))
-        case PolyType(_, _) => abort("bad case: "+tpe)
-        case _ => owner.thisType.memberType(abstractType(clazz))
-      }
-      def getInfo = copyType(clazz.primaryConstructor.tpe)
-    }
-    factory
-  }
-
-  def distinct(ts: List[Type]): List[Type] = ts match {
-    case List() => List()
-    case t :: ts1 => t :: distinct(ts1 filter (_.typeSymbol != t.typeSymbol))
-  }
-
-  /** The concrete class symbol VC$fix in the factory symbol (@see mkFactory)
-   *  @param clazz    the virtual class
-   *  @param factory  the factory which returns an instance of this class
-   */
-  protected def mkConcreteClass(clazz: Symbol, factory: Symbol) = {
-    val cclazz = factory.newClass(clazz.pos, concreteClassName(clazz))
-      .setFlag(FINAL | SYNTHETIC)
-      .setAnnotations(clazz.annotations)
-
-    cclazz setInfo new LazyType {
-      override def complete(sym: Symbol) {
-        val parents1 = atPhase(ownPhase) {
-          var superclazz = clazz
-          do {
-            superclazz = superclazz.info.parents.head.typeSymbol
-          } while (wasVirtualClass(superclazz))
-          val bcs = superclazz :: (clazz.info.baseClasses takeWhile (superclazz != )).reverse
-          println("MKConcrete1 "+cclazz+factory.locationString+" "+bcs+" from "+clazz+clazz.locationString)
-          println("MKConcrete2 "+cclazz+factory.locationString+" "+(bcs map factory.owner.thisType.memberType))
-          bcs map factory.owner.thisType.memberType
-        }
-        atPhase(ownPhase.next) {
-          val parents2 =
-            distinct(parents1.flatMap(addOverriddenVirtuals))
-            .map(_.substSym(clazz.typeParams, factory.typeParams))
-          sym setInfo ClassInfoType(parents2, new Scope, cclazz)
-        }
-      }
-    }
-
-    cclazz
-  }
-
-  /** Perform the following tree transformations:
-   *
-   *  1. Add trees for abstract types (@see devirtualize),
-   *     worker traits (@see devirtualize)
-   *     and factories (@see mkFactory)
-   *
-   *  2. Replace a new VC().init(...) where VC is a virtual class with new$VC(...)
-   *
-   *  3. Replace references to VC.this and VC.super where VC is a virtual class
-   *     with VC$trait.this and VC$trait.super
-   *
-   *  4. Transform type references to virtual classes to type references of corresponding
-   *     abstract types.
-   */
-  class DeVirtualizeTransformer(unit: CompilationUnit) extends TypingTransformer(unit) {
-    // all code is executed at phase ownPhase.next
-
-    /** Add trees for abstract types, worker traits, and factories (@see mkFactory)
-     *  to template body `stats`
-     */
-    override def transformStats(stats: List[Tree], exprOwner: Symbol): List[Tree] = {
-      val stats1 = stats flatMap transformStat
-      val fclasses = atPhase(ownPhase) {
-        if (currentOwner.isClass && containsVirtuals(currentOwner)) classesInNeedOfFactories(currentOwner)
-        else List()
-      }
-      val newDefs = fclasses map factoryDef
-      if (newDefs.isEmpty) stats1 else stats1 ::: newDefs
-    }
-
-    def fixClassDef(clazz: Symbol, factory: Symbol): Tree = {
-      val cclazz = mkConcreteClass(clazz, factory)
-      val overrideBridges =
-        for (m <- clazz.info.decls.toList if m hasFlag notOVERRIDE)
-        yield overrideBridge(m, cclazz)
-
-      val vparamss: List[List[ValDef]] = atPhase(ownPhase) {
-        paramTypesAndIndices(clazz.primaryConstructor.tpe, 0) map {
-          _ map {
-          case (pt, i) =>
-            atPos(factory.pos) {
-              ValDef(Modifiers(PARAMACCESSOR | PRIVATE | LOCAL), fixParamName(i),
-                     TypeTree(devirtualizeMap(pt)), EmptyTree)
-            }
-          }
-        }
-      }
-      val pfields: List[DefDef] = atPhase(ownPhase) {
-        paramTypesAndIndices(clazz.primaryConstructor.tpe, 0) flatMap {
-          _ map {
-          case (pt, i) =>
-            val pfield = cclazz.newMethod(cclazz.pos, paramFieldName(clazz, i))
-              .setFlag(PROTECTED | LOCAL | EXPANDEDNAME | SYNTHETIC | STABLE)
-              .setInfo(NullaryMethodType(pt))
-            cclazz.info.decls enter pfield
-            atPos(factory.pos) {
-              DefDef(pfield, Ident(fixParamName(i)))
-            }
-          }
-        }
-      }
-      atPos(clazz.pos) {
-        ClassDef(cclazz, Modifiers(0), vparamss, List(List()), pfields ::: overrideBridges, clazz.pos.focus)
-      }
-    }
-
-
-    /** The factory definition for virtual class `clazz` (@see mkFactory)
-     *  For a virtual class
-     *
-     *  attrs mods class VC[Ts] <: Ps { decls }
-     *  with overridden classes _VC[Us]'s
-     *
-     * we need the following factory:
-     *
-     *  attrs mods3 def new$VC[Ts](): VC[Ts] = {
-     *    class VC$fix extends _VC$trait's[Ts] with VC$trait[Ts] {
-     *      override-bridges
-     *    }
-     *    new VC$fix.asInstanceOf[VC[Ts]]
-     *  }
-     *
-     * where
-     *
-     *  mods3  are the modifiers inherited to factories
-     *  override-bridges are definitions that link every symbol in a worker trait
-     *                   that was overriding something to the overridden symbol
-     *                   //todo: not sure what happens with abstract override?
-     */
-    def factoryDef(clazz: Symbol): Tree = {
-      val factorySym = factory(clazz, currentOwner)
-      val cclazzDef = fixClassDef(clazz, factorySym)
-      println("Concrete: "+cclazzDef)
-      val abstpeSym = abstractType(clazz)
-      localTyper.typed {
-        atPos(factorySym.pos) {
-          DefDef(factorySym,
-            Block(
-              List(cclazzDef),
-              TypeApply(
-                Select(
-                  gen.mkForwarder(
-                    Select(New(TypeTree(cclazzDef.symbol.tpe)), nme.CONSTRUCTOR),
-                    factorySym.paramss),
-                  Any_asInstanceOf),
-             List(
-               TypeTree(
-                 currentOwner.thisType.memberType(abstpeSym)
-                 .substSym(abstpeSym.typeParams, factorySym.typeParams))))))
-        }
-      }
-    }
-
-    /** Create an override bridge for method `meth` in concrete class `cclazz`.
-     *  An override bridge has the form
-     *
-     *   override f(xs1)...(xsN) = super.f(xs)...(xsN)
-     */
-    def overrideBridge(meth: Symbol, cclazz: Symbol) = atPos(meth.pos) {
-      val bridge = meth.cloneSymbol(cclazz)
-        .resetFlag(notOVERRIDE | notFINAL)
-      cclazz.info.decls.enter(bridge)
-      val superRef: Tree = Select(Super(cclazz, tpnme.EMPTY), meth)
-      DefDef(bridge, gen.mkForwarder(superRef, bridge.paramss))
-    }
-
-    /** Replace definitions of virtual classes by definitions of corresponding
-     *  abstract type and worker traits.
-     *  Eliminate constructors of former virtual classes because these are now traits.
-     */
-    protected def transformStat(tree: Tree): List[Tree] = {
-      val sym = tree.symbol
-      tree match {
-        case ClassDef(mods, name, tparams, templ)
-        if (wasVirtualClass(sym)) =>
-          val clazz = sym
-          val absTypeSym = abstractType(clazz)
-          val abstypeDef = TypeDef(absTypeSym)
-          List(localTyper.typed(abstypeDef), transform(tree))
-        case DefDef(_, nme.CONSTRUCTOR, _, _, _, _)
-        if (wasVirtualClass(sym.owner)) =>
-          if (atPhase(ownPhase)(sym != sym.owner.primaryConstructor))
-            unit.error(tree.pos, "virtual classes cannot have auxiliary constructors")
-          List()
-        case _ =>
-          List(transform(tree))
-      }
-    }
-
-    override def transform(tree0: Tree): Tree = {
-      val tree = super.transform(tree0)
-      val sym = tree.symbol
-      tree match {
-        // Replace a new VC().init() where VC is a virtual class with new$VC
-        case Apply(Select(New(tpt), name), args) if (sym.isConstructor && wasVirtualClass(sym.owner)) =>
-          val clazz = sym.owner
-          val fn =
-            Select(
-              gen.mkAttributedQualifier(tpt.tpe.prefix),
-              factory(clazz, clazz.owner).name)
-          println("fac "+factory(clazz, clazz.owner).tpe)
-          val targs = tpt.tpe.typeArgs
-          atPos(tree.pos) {
-            localTyper.typed {
-              val res =
-                Apply(if (targs.isEmpty) fn else TypeApply(fn, targs map TypeTree), args)
-                println("typing "+res+" from "+args)
-                res
-              }
-            }
-
-        case Template(parents, self, body) if (wasVirtualClass(sym.owner)) =>
-          // add param field accessors
-          val paramFieldAccessors = new ListBuffer[Tree]
-          val paramFields = new ListBuffer[Tree]
-          val presupers = new ListBuffer[Tree]
-          val others = new ListBuffer[Tree]
-          var paramFieldCount = 0
-          for (stat <- body) {
-            if (stat.symbol != null && (stat.symbol hasFlag PARAMACCESSOR))
-              stat match {
-                case pacc @ ValDef(mods, name, tpt, rhs) =>
-                  pacc.symbol resetFlag PARAMACCESSOR setFlag PRESUPER
-                  val pfield = paramField(sym.owner, paramFieldCount)
-                  paramFieldCount += 1
-                  pfield setPos pacc.pos
-                  paramFields += localTyper.typed(DefDef(pfield, EmptyTree))
-                  val pfieldRef = localTyper.typed {
-                    atPos(pacc.pos) {
-                      Select(This(sym.owner), pfield)
-                    }
-                  }
-                  paramFieldAccessors += treeCopy.ValDef(pacc, mods, name, tpt, pfieldRef)
-                case _ =>
-                  stat.symbol resetFlag PARAMACCESSOR // ??? can we do this
-                  others += stat
-              }
-            else
-              (if (stat.symbol != null && (stat.symbol hasFlag PRESUPER)) presupers else others) += stat
-          }
-          treeCopy.Template(tree, parents, self,
-                            paramFieldAccessors.toList :::
-                            presupers.toList :::
-                            paramFields.toList :::
-                            others.toList)
-        case _ =>
-          tree setType atPhase(ownPhase)(devirtualizeMap(tree.tpe))
-      }
-    }
-    override def transformUnit(unit: CompilationUnit) = atPhase(ownPhase.next) {
-      super.transformUnit(unit)
-    }
-  }
-}
-
-
-
-/*
-    class A {
-      trait C[X, Y] <: {
-        var x: X
-        def f(y: Y): X = { println("A.T"); x }
-      }
-      class D[X](xp: X) extends C[X, Int] {
-        var x: X = xp
-        override def f(y: Int) = { println(y); super.f(y) }
-      }
-    }
-    class B extends A {
-      override trait C[X, Y] <: {
-        override def f(y: Y): X = { println("B.T"); super.f(y) }
-        def g: X = x
-      }
-    }
-    object Test extends B {
-      val c = new D[String]("OK")
-      println(c.g)
-      println(c.f(42))
-    }
-
-maps to:
-
-  class A {
-    type C[X, Y] <: C$trait[X, Y]
-
-    trait C$trait[X, Y] { this: C with C$trait =>
-      var x: X
-      def f(y: Y): X = { println("A.T"); x }
-    }
-
-    class D[X](xp: X) extends C[X, Int] {
-      var x: X = xp
-      override def f(y: Int) = { println(y); super.f(y) }
-    }
-
-      protected[this] val x: Int; val y = x; def f(z:Int) = z + 1 }
-
-    type D <: C with DT
-
-    trait DT extends { self: D => def f(z:Int) = z + 2 }
-
-    trait preDT extends { self: D => val z: Int; val x = f(z) }
-
-    def newC(x: Int): C
-    def newD(x: Int): D
-
-    //type C = CT
-    //type D = C with DT
-
-    class CC(_x:Int) extends { val x = _x } with CT
-
-    def newC[X, Y](x:Int): C =
-      new CC(x).asInstanceOf[C]
-
-    class DC(_z:Int) extends { val z = _z } with preDT with CT with DT {
-      override def f(z:Int) = super.f(z)
-    }
-
-    def newD(z:Int):D = new DC(z).asInstanceOf[D]
-  }
-
-  class B extends A {
-    type C <: CT with CT2
-
-    trait CT2 { self : C => def g = 2 }
-
-    //type C = CT with CT2
-    //type D = C with DT
-
-    class CC2(_x:Int) extends { val x = _x } with CT with CT2
-
-    def newC(x:Int): C = new CC2(x).asInstanceOf[C]
-
-    class DC2(_z:Int) extends { val z = _z } with preDT with CT with CT2
-      with DT { override def f(z:Int) = super.f(z) }
-
-    def newD(z:Int): D = new DC2(z).asInstanceOf[D]
-  }
-
-*/
-
-*/
\ No newline at end of file
diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
index 6ce76d03c8..e41bb737f2 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
@@ -1409,7 +1409,7 @@ trait Namers { self: Analyzer =>
       }
 
       if (sym.isConstructor) {
-        if (sym.hasFlag(OVERRIDE | ABSOVERRIDE))
+        if (sym.isAnyOverride)
           context.error(sym.pos, "`override' modifier not allowed for constructors")
         if (sym.isImplicit)
           context.error(sym.pos, "`implicit' modifier not allowed for constructors")
@@ -1424,9 +1424,9 @@ trait Namers { self: Analyzer =>
       if (sym.hasFlag(ABSTRACT) && !sym.isClass)
         context.error(sym.pos, "`abstract' modifier can be used only for classes; " +
           "\nit should be omitted for abstract members")
-      if (sym.hasFlag(OVERRIDE | ABSOVERRIDE) && !sym.hasFlag(TRAIT) && sym.isClass)
+      if (sym.isAnyOverride && !sym.hasFlag(TRAIT) && sym.isClass)
         context.error(sym.pos, "`override' modifier not allowed for classes")
-      if (sym.hasFlag(ABSOVERRIDE) && !sym.owner.isTrait)
+      if (sym.isAbstractOverride && !sym.owner.isTrait)
         context.error(sym.pos, "`abstract override' modifier only allowed for members of traits")
       if (sym.isLazy && sym.hasFlag(PRESUPER))
         context.error(sym.pos, "`lazy' definitions may not be initialized early")
diff --git a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
index e2fb367d20..fda6a6f12e 100644
--- a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
@@ -249,9 +249,6 @@ abstract class RefChecks extends InfoTransform with reflect.internal.transform.R
         }
       }
 
-      def isAbstractTypeWithoutFBound(sym: Symbol) = // (part of DEVIRTUALIZE)
-        sym.isAbstractType && !sym.isFBounded
-
       def infoString(sym: Symbol) = infoString0(sym, sym.owner != clazz)
       def infoStringWithLocation(sym: Symbol) = infoString0(sym, true)
 
@@ -371,14 +368,13 @@ abstract class RefChecks extends InfoTransform with reflect.internal.transform.R
             overrideError("cannot be used here - classes can only override abstract types");
           } else if (other.isFinal) { // (1.2)
             overrideError("cannot override final member");
-          } else if (!other.isDeferred && !(member hasFlag (OVERRIDE | ABSOVERRIDE | SYNTHETIC))) { // (1.3), SYNTHETIC because of DEVIRTUALIZE
+          } else if (!other.isDeferred && !member.isAnyOverride) {
             overrideError("needs `override' modifier");
-          } else if ((other hasFlag ABSOVERRIDE) && other.isIncompleteIn(clazz) && !(member hasFlag ABSOVERRIDE)) {
+          } else if (other.isAbstractOverride && other.isIncompleteIn(clazz) && !member.isAbstractOverride) {
             overrideError("needs `abstract override' modifiers")
-          } else if ((member hasFlag (OVERRIDE | ABSOVERRIDE)) &&
-                     (other hasFlag ACCESSOR) && other.accessed.isVariable && !other.accessed.isLazy) {
+          } else if (member.isAnyOverride && (other hasFlag ACCESSOR) && other.accessed.isVariable && !other.accessed.isLazy) {
             overrideError("cannot override a mutable variable")
-          } else if ((member hasFlag (OVERRIDE | ABSOVERRIDE)) &&
+          } else if (member.isAnyOverride &&
                      !(member.owner.thisType.baseClasses exists (_ isSubClass other.owner)) &&
                      !member.isDeferred && !other.isDeferred &&
                      intersectionIsEmpty(member.extendedOverriddenSymbols, other.extendedOverriddenSymbols)) {
@@ -386,11 +382,11 @@ abstract class RefChecks extends InfoTransform with reflect.internal.transform.R
                           "(this rule is designed to prevent ``accidental overrides'')")
           } else if (other.isStable && !member.isStable) { // (1.4)
             overrideError("needs to be a stable, immutable value")
-          } else if (member.isValue && (member hasFlag LAZY) &&
-                     other.isValue && !other.isSourceMethod && !other.isDeferred && !(other hasFlag LAZY)) {
+          } else if (member.isValue && member.isLazy &&
+                     other.isValue && !other.isSourceMethod && !other.isDeferred && !other.isLazy) {
             overrideError("cannot override a concrete non-lazy value")
-          } else if (other.isValue && (other hasFlag LAZY) && !other.isSourceMethod && !other.isDeferred &&
-                     member.isValue && !(member hasFlag LAZY)) {
+          } else if (other.isValue && other.isLazy && !other.isSourceMethod && !other.isDeferred &&
+                     member.isValue && !member.isLazy) {
             overrideError("must be declared lazy to override a concrete lazy value")
           } else {
             checkOverrideTypes()
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 37652a1790..893384ece3 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -1442,7 +1442,7 @@ trait Typers extends Modes with Adaptations {
 
         if (value.isLazy) List(stat)
         else {
-          val vdef = treeCopy.ValDef(stat, mods | PRIVATE | LOCAL, nme.getterToLocal(name), tpt, rhs)
+          val vdef = treeCopy.ValDef(stat, mods | PrivateLocal, nme.getterToLocal(name), tpt, rhs)
           val getterDef = atPos(vdef.pos.focus) {
             if (isDeferred) {
               val r = DefDef(getter, EmptyTree)