diff options
author | Martin Odersky <odersky@gmail.com> | 2012-07-11 19:03:35 +0200 |
---|---|---|
committer | Martin Odersky <odersky@gmail.com> | 2012-07-11 19:35:55 +0200 |
commit | a9b85dbaad568b5c709a5eb6ab23907cdf4ee29e (patch) | |
tree | 56180948d8986aafa37e93e837db70c9106c2f6b /src | |
parent | 026a70d55591c3b5ee157e22998b62168afee686 (diff) | |
download | scala-a9b85dbaad568b5c709a5eb6ab23907cdf4ee29e.tar.gz scala-a9b85dbaad568b5c709a5eb6ab23907cdf4ee29e.tar.bz2 scala-a9b85dbaad568b5c709a5eb6ab23907cdf4ee29e.zip |
Pickled flag reorg
Cleaned up and optimized code that maps between raw and pickled flags. Avoids mystery constants. Makes a whole bunch of new flags be pickled which were not pickled before (more precisely: Everything in InitialFlags with value greater than 1 << 31 which is not in FlagsNotPickled now gets pickled whereas before it wasn't. Among these: VARARGS, IMPLCLASS, SPECIALZED, DEFAULTINIT, SYNCHRONIZED. I am curious how many tickets will get fixed by this change.
The first one I noted is t5504, which previously enforced the buggy behavior through a neg check!
There are also some build manager check file changes that have to do with the fact that flags now print in a different order for performance reasons.
Diffstat (limited to 'src')
-rw-r--r-- | src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala | 4 | ||||
-rw-r--r-- | src/reflect/scala/reflect/internal/Flags.scala | 81 |
2 files changed, 42 insertions, 43 deletions
diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala index 192cc94b90..cc5ed0f129 100644 --- a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala +++ b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala @@ -503,7 +503,7 @@ abstract class Pickler extends SubComponent { private def writeSymInfo(sym: Symbol) { writeRef(sym.name) writeRef(localizedOwner(sym)) - writeLongNat((rawFlagsToPickled(sym.flags & PickledFlags))) + writeLongNat((rawToPickledFlags(sym.flags & PickledFlags))) if (sym.hasAccessBoundary) writeRef(sym.privateWithin) writeRef(sym.info) } @@ -966,7 +966,7 @@ abstract class Pickler extends SubComponent { TREE case Modifiers(flags, privateWithin, _) => - val pflags = rawFlagsToPickled(flags) + val pflags = rawToPickledFlags(flags) writeNat((pflags >> 32).toInt) writeNat((pflags & 0xFFFFFFFF).toInt) writeRef(privateWithin) diff --git a/src/reflect/scala/reflect/internal/Flags.scala b/src/reflect/scala/reflect/internal/Flags.scala index 37e5a23819..c17600ec41 100644 --- a/src/reflect/scala/reflect/internal/Flags.scala +++ b/src/reflect/scala/reflect/internal/Flags.scala @@ -165,6 +165,7 @@ class Flags extends ModifierFlags { // A Java method's type is ``cooked'' by transforming raw types to existentials final val SYNCHRONIZED = 1L << 45 // symbol is a method which should be marked ACC_SYNCHRONIZED + // ------- shift definitions ------------------------------------------------------- final val InitialFlags = 0x0001FFFFFFFFFFFFL // flags that are enabled from phase 1. @@ -211,7 +212,7 @@ class Flags extends ModifierFlags { /** To be a little clearer to people who aren't habitual bit twiddlers. */ final val AllFlags = -1L - + /** These flags can be set when class or module symbol is first created. * They are the only flags to survive a call to resetFlags(). */ @@ -279,6 +280,12 @@ class Flags extends ModifierFlags { /** Module flags inherited by their module-class */ final val ModuleToClassFlags = AccessFlags | TopLevelCreationFlags | CASE | SYNTHETIC + /** These flags are not pickled */ + final val FlagsNotPickled = IS_ERROR | OVERLOADED | LIFTED | TRANS_FLAG | LOCKED | TRIEDCOOKING + + /** These flags are pickled */ + final val PickledFlags = InitialFlags & ~FlagsNotPickled + def getterFlags(fieldFlags: Long): Long = ACCESSOR + ( if ((fieldFlags & MUTABLE) != 0) fieldFlags & ~MUTABLE & ~PRESUPER else fieldFlags & ~PRESUPER | STABLE @@ -307,47 +314,45 @@ class Flags extends ModifierFlags { private final val PKL_MASK = 0x00000FFF - final val PickledFlags = 0xFFFFFFFFL - - private def rawPickledCorrespondence = Array( - (IMPLICIT, IMPLICIT_PKL), - (FINAL, FINAL_PKL), + /** Pickler correspondence, ordered roughly by frequency of occurrence */ + private def rawPickledCorrespondence = Array[(Long, Long)]( + (METHOD, METHOD_PKL), (PRIVATE, PRIVATE_PKL), + (FINAL, FINAL_PKL), (PROTECTED, PROTECTED_PKL), - (SEALED, SEALED_PKL), - (OVERRIDE, OVERRIDE_PKL), (CASE, CASE_PKL), - (ABSTRACT, ABSTRACT_PKL), (DEFERRED, DEFERRED_PKL), - (METHOD, METHOD_PKL), (MODULE, MODULE_PKL), - (INTERFACE, INTERFACE_PKL) + (OVERRIDE, OVERRIDE_PKL), + (INTERFACE, INTERFACE_PKL), + (IMPLICIT, IMPLICIT_PKL), + (SEALED, SEALED_PKL), + (ABSTRACT, ABSTRACT_PKL) ) - private val rawFlags: Array[Int] = rawPickledCorrespondence map (_._1) - private val pickledFlags: Array[Int] = rawPickledCorrespondence map (_._2) - - private def r2p(flags: Int): Int = { - var result = 0 - var i = 0 - while (i < rawFlags.length) { - if ((flags & rawFlags(i)) != 0) - result |= pickledFlags(i) - - i += 1 - } - result - } - private def p2r(flags: Int): Int = { - var result = 0 - var i = 0 - while (i < rawFlags.length) { - if ((flags & pickledFlags(i)) != 0) - result |= rawFlags(i) - - i += 1 + + private val mappedRawFlags = rawPickledCorrespondence map (_._1) + private val mappedPickledFlags = rawPickledCorrespondence map (_._2) + + private class MapFlags(from: Array[Long], to: Array[Long]) extends (Long => Long) { + val fromSet = (0L /: from) (_ | _) + + def apply(flags: Long): Long = { + var result = flags & ~fromSet + var tobeMapped = flags & fromSet + var i = 0 + while (tobeMapped != 0) { + if ((tobeMapped & from(i)) != 0) { + result |= to(i) + tobeMapped &= ~from(i) + } + i += 1 + } + result } - result } + + val rawToPickledFlags: Long => Long = new MapFlags(mappedRawFlags, mappedPickledFlags) + val pickledToRawFlags: Long => Long = new MapFlags(mappedPickledFlags, mappedRawFlags) // ------ displaying flags -------------------------------------------------------- @@ -462,18 +467,12 @@ class Flags extends ModifierFlags { } } - def rawFlagsToPickled(flags: Long): Long = - (flags & ~PKL_MASK) | r2p(flags.toInt & PKL_MASK) - - def pickledToRawFlags(pflags: Long): Long = - (pflags & ~PKL_MASK) | p2r(pflags.toInt & PKL_MASK) - // List of the raw flags, in pickled order final val MaxBitPosition = 62 final val pickledListOrder: List[Long] = { val all = 0 to MaxBitPosition map (1L << _) - val front = rawFlags map (_.toLong) + val front = mappedRawFlags map (_.toLong) front.toList ++ (all filterNot (front contains _)) } |