← Back to branch summary

~ubuntu-branches/debian/sid/scala/sid

« back to all changes in this revision

Viewing changes to src/reflect/scala/reflect/internal/Flags.scala

  • Committer: Package Import Robot
  • Author(s): Emmanuel Bourg, Mehdi Dogguy, Lucas Satabin, Frank S. Thomas, Emmanuel Bourg
  • Date: 2015-06-05 23:52:59 UTC
  • mfrom: (1.2.11)
  • Revision ID: package-import@ubuntu.com-20150605235259-wk00vgk83dh8o19g
Tags: 2.10.5-1
http://bugs.debian.org/744278
http://bugs.debian.org/754935
http://bugs.debian.org/724704
* Team upload.

[ Mehdi Dogguy ]
* New upstream release (Closes: #744278).

[ Lucas Satabin ]
* Update patches
* Update the clean target
* Update paths of elements to install
* Update watch file

[ Frank S. Thomas ]
* Remove myself from Uploaders.

[ Emmanuel Bourg ]
* The package has been adopted by the Java Team (Closes: #754935)
* Patched the build to avoid downloading libraries from the Internet
* Replaced the minified JavaScript files with unobfuscated ones
* No longer build scala-partest.jar until diffutils is packaged or replaced
* debian/watch: Fixed the versions matched (x.y.z instead of x.y.z..z)
* debian/rules:
  - Added the missing get-orig-source target (Closes: #724704)
  - Improved the clean target
* debian/control:
  - Build depend on scala (>= 2.10) and bnd
  - Use canonical URLs for the Vcs-* fields
  - Standards-Version updated to 3.9.6 (no changes)
* Switch to debhelper level 9

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/reflect/scala/reflect/internal/Flags.scala
 
1
/* NSC -- new Scala compiler
 
2
 * Copyright 2005-2013 LAMP/EPFL
 
3
 * @author  Martin Odersky
 
4
 */
 
5
 
 
6
package scala.reflect
 
7
package internal
 
8
 
 
9
import scala.collection.{ mutable, immutable }
 
10
 
 
11
// Flags at each index of a flags Long.  Those marked with /M are used in
 
12
// Parsers/JavaParsers and therefore definitely appear on Modifiers; but the
 
13
// absence of /M on the other flags does not imply they aren't.
 
14
//
 
15
// Generated by mkFlagsTable() at Thu Feb 02 20:31:52 PST 2012
 
16
//
 
17
//  0:     PROTECTED/M
 
18
//  1:      OVERRIDE/M
 
19
//  2:       PRIVATE/M
 
20
//  3:      ABSTRACT/M
 
21
//  4:      DEFERRED/M
 
22
//  5:         FINAL/M
 
23
//  6:          METHOD
 
24
//  7:     INTERFACE/M
 
25
//  8:          MODULE
 
26
//  9:      IMPLICIT/M
 
27
// 10:        SEALED/M
 
28
// 11:          CASE/M
 
29
// 12:       MUTABLE/M
 
30
// 13:         PARAM/M
 
31
// 14:         PACKAGE
 
32
// 15:         MACRO/M
 
33
// 16:   BYNAMEPARAM/M      CAPTURED COVARIANT/M
 
34
// 17: CONTRAVARIANT/M INCONSTRUCTOR       LABEL
 
35
// 18:   ABSOVERRIDE/M
 
36
// 19:         LOCAL/M
 
37
// 20:          JAVA/M
 
38
// 21:       SYNTHETIC
 
39
// 22:          STABLE
 
40
// 23:        STATIC/M
 
41
// 24:  CASEACCESSOR/M
 
42
// 25:  DEFAULTPARAM/M       TRAIT/M
 
43
// 26:          BRIDGE
 
44
// 27:        ACCESSOR
 
45
// 28:   SUPERACCESSOR
 
46
// 29: PARAMACCESSOR/M
 
47
// 30:       MODULEVAR
 
48
// 31:          LAZY/M
 
49
// 32:        IS_ERROR
 
50
// 33:      OVERLOADED
 
51
// 34:          LIFTED
 
52
// 35:     EXISTENTIAL       MIXEDIN
 
53
// 36:    EXPANDEDNAME
 
54
// 37:       IMPLCLASS    PRESUPER/M
 
55
// 38:      TRANS_FLAG
 
56
// 39:          LOCKED
 
57
// 40:     SPECIALIZED
 
58
// 41:   DEFAULTINIT/M
 
59
// 42:         VBRIDGE
 
60
// 43:         VARARGS
 
61
// 44:    TRIEDCOOKING
 
62
// 45:  SYNCHRONIZED/M
 
63
// 46:        ARTIFACT
 
64
// 47: DEFAULTMETHOD/M
 
65
// 48:
 
66
// 49:
 
67
// 50:
 
68
// 51:    lateDEFERRED
 
69
// 52:       lateFINAL
 
70
// 53:      lateMETHOD
 
71
// 54:   lateINTERFACE
 
72
// 55:      lateMODULE
 
73
// 56:    notPROTECTED
 
74
// 57:     notOVERRIDE
 
75
// 58:      notPRIVATE
 
76
// 59:
 
77
// 60:
 
78
// 61:
 
79
// 62:
 
80
// 63:
 
81
 
 
82
/** Flags set on Modifiers instances in the parsing stage.
 
83
 */
 
84
class ModifierFlags {
 
85
  final val IMPLICIT      = 1 << 9
 
86
  final val FINAL         = 1 << 5    // May not be overridden. Note that java final implies much more than scala final.
 
87
  final val PRIVATE       = 1 << 2
 
88
  final val PROTECTED     = 1 << 0
 
89
 
 
90
  final val SEALED        = 1 << 10
 
91
  final val OVERRIDE      = 1 << 1
 
92
  final val CASE          = 1 << 11
 
93
  final val ABSTRACT      = 1 << 3        // abstract class, or used in conjunction with abstract override.
 
94
                                          // Note difference to DEFERRED!
 
95
  final val DEFERRED      = 1 << 4        // was `abstract' for members | trait is virtual
 
96
  final val INTERFACE     = 1 << 7        // symbol is an interface (i.e. a trait which defines only abstract methods)
 
97
  final val MUTABLE       = 1 << 12       // symbol is a mutable variable.
 
98
  final val PARAM         = 1 << 13       // symbol is a (value or type) parameter to a method
 
99
  final val MACRO         = 1 << 15       // symbol is a macro definition
 
100
 
 
101
  final val COVARIANT     = 1 << 16       // symbol is a covariant type variable
 
102
  final val BYNAMEPARAM   = 1 << 16       // parameter is by name
 
103
  final val CONTRAVARIANT = 1 << 17       // symbol is a contravariant type variable
 
104
  final val ABSOVERRIDE   = 1 << 18       // combination of abstract & override
 
105
  final val LOCAL         = 1 << 19       // symbol is local to current class (i.e. private[this] or protected[this]
 
106
                                          // pre: PRIVATE or PROTECTED are also set
 
107
  final val JAVA          = 1 << 20       // symbol was defined by a Java class
 
108
  final val STATIC        = 1 << 23       // static field, method or class
 
109
  final val CASEACCESSOR  = 1 << 24       // symbol is a case parameter (or its accessor, or a GADT skolem)
 
110
  final val TRAIT         = 1 << 25       // symbol is a trait
 
111
  final val DEFAULTPARAM  = 1 << 25       // the parameter has a default value
 
112
  final val PARAMACCESSOR = 1 << 29       // for field definitions generated for primary constructor
 
113
                                          //   parameters (no matter if it's a 'val' parameter or not)
 
114
                                          // for parameters of a primary constructor ('val' or not)
 
115
                                          // for the accessor methods generated for 'val' or 'var' parameters
 
116
  final val LAZY          = 1L << 31      // symbol is a lazy val. can't have MUTABLE unless transformed by typer
 
117
  final val PRESUPER      = 1L << 37      // value is evaluated before super call
 
118
  final val DEFAULTINIT   = 1L << 41      // symbol is initialized to the default value: used by -Xcheckinit
 
119
  // ARTIFACT at #46 in 2.11+
 
120
  final val DEFAULTMETHOD = 1L << 47      // symbol is a java default method
 
121
 
 
122
  // Overridden.
 
123
  def flagToString(flag: Long): String = ""
 
124
 
 
125
  final val PrivateLocal   = PRIVATE | LOCAL
 
126
  final val ProtectedLocal = PROTECTED | LOCAL
 
127
  final val AccessFlags    = PRIVATE | PROTECTED | LOCAL
 
128
}
 
129
object ModifierFlags extends ModifierFlags
 
130
 
 
131
/** All flags and associated operatins */
 
132
class Flags extends ModifierFlags {
 
133
  final val METHOD        = 1 << 6        // a method
 
134
  final val MODULE        = 1 << 8        // symbol is module or class implementing a module
 
135
  final val PACKAGE       = 1 << 14       // symbol is a java package
 
136
 
 
137
  final val CAPTURED      = 1 << 16       // variable is accessed from nested function.  Set by LambdaLift.
 
138
  final val LABEL         = 1 << 17       // method symbol is a label. Set by TailCall
 
139
  final val INCONSTRUCTOR = 1 << 17       // class symbol is defined in this/superclass constructor.
 
140
  final val SYNTHETIC     = 1 << 21       // symbol is compiler-generated (compare with ARTIFACT)
 
141
  final val STABLE        = 1 << 22       // functions that are assumed to be stable
 
142
                                          // (typically, access methods for valdefs)
 
143
                                          // or classes that do not contain abstract types.
 
144
  final val BRIDGE        = 1 << 26       // function is a bridge method. Set by Erasure
 
145
  final val ACCESSOR      = 1 << 27       // a value or variable accessor (getter or setter)
 
146
 
 
147
  final val SUPERACCESSOR = 1 << 28       // a super accessor
 
148
  final val MODULEVAR     = 1 << 30       // for variables: is the variable caching a module value
 
149
 
 
150
  final val IS_ERROR      = 1L << 32      // symbol is an error symbol
 
151
  final val OVERLOADED    = 1L << 33      // symbol is overloaded
 
152
  final val LIFTED        = 1L << 34      // class has been lifted out to package level
 
153
                                          // local value has been lifted out to class level
 
154
                                          // todo: make LIFTED = latePRIVATE?
 
155
  final val MIXEDIN       = 1L << 35      // term member has been mixed in
 
156
  final val EXISTENTIAL   = 1L << 35      // type is an existential parameter or skolem
 
157
  final val EXPANDEDNAME  = 1L << 36      // name has been expanded with class suffix
 
158
  final val IMPLCLASS     = 1L << 37      // symbol is an implementation class
 
159
  final val TRANS_FLAG    = 1L << 38      // transient flag guaranteed to be reset after each phase.
 
160
 
 
161
  final val LOCKED        = 1L << 39      // temporary flag to catch cyclic dependencies
 
162
  final val SPECIALIZED   = 1L << 40      // symbol is a generated specialized member
 
163
  final val VBRIDGE       = 1L << 42      // symbol is a varargs bridge
 
164
 
 
165
  final val VARARGS       = 1L << 43      // symbol is a Java-style varargs method
 
166
  final val TRIEDCOOKING  = 1L << 44      // ``Cooking'' has been tried on this symbol
 
167
                                          // A Java method's type is ``cooked'' by transforming raw types to existentials
 
168
 
 
169
  final val SYNCHRONIZED  = 1L << 45      // symbol is a method which should be marked ACC_SYNCHRONIZED
 
170
  final val ARTIFACT      = 1L << 46      // symbol should be ignored when typechecking; will be marked ACC_SYNTHETIC in bytecode
 
171
 
 
172
  // ------- shift definitions -------------------------------------------------------
 
173
 
 
174
  final val InitialFlags  = 0x0001FFFFFFFFFFFFL // flags that are enabled from phase 1.
 
175
  final val LateFlags     = 0x00FE000000000000L // flags that override flags in 0x1FC.
 
176
  final val AntiFlags     = 0x7F00000000000000L // flags that cancel flags in 0x07F
 
177
  final val LateShift     = 47L
 
178
  final val AntiShift     = 56L
 
179
 
 
180
  // Flags which sketchily share the same slot
 
181
  // 16:   BYNAMEPARAM/M      CAPTURED COVARIANT/M
 
182
  // 17: CONTRAVARIANT/M INCONSTRUCTOR       LABEL
 
183
  // 25:  DEFAULTPARAM/M       TRAIT/M
 
184
  // 35:     EXISTENTIAL       MIXEDIN
 
185
  // 37:       IMPLCLASS    PRESUPER/M
 
186
  val OverloadedFlagsMask = 0L | BYNAMEPARAM | CONTRAVARIANT | DEFAULTPARAM | EXISTENTIAL | IMPLCLASS
 
187
 
 
188
  // ------- late flags (set by a transformer phase) ---------------------------------
 
189
  //
 
190
  // Summary of when these are claimed to be first used.
 
191
  // You can get this output with scalac -Xshow-phases -Ydebug.
 
192
  //
 
193
  //     refchecks   7  [START] <latemethod>
 
194
  //    specialize  13  [START] <latefinal> <notprivate>
 
195
  // explicitouter  14  [START] <notprotected>
 
196
  //       erasure  15  [START] <latedeferred> <lateinterface>
 
197
  //         mixin  20  [START] <latemodule> <notoverride>
 
198
  //
 
199
  // lateMETHOD set in RefChecks#transformInfo.
 
200
  // lateFINAL set in Symbols#makeNotPrivate.
 
201
  // notPRIVATE set in Symbols#makeNotPrivate, IExplicitOuter#transform, Inliners.
 
202
  // notPROTECTED set in ExplicitOuter#transform.
 
203
  // lateDEFERRED set in AddInterfaces, Mixin, etc.
 
204
  // lateINTERFACE set in AddInterfaces#transformMixinInfo.
 
205
  // lateMODULE set in Mixin#transformInfo.
 
206
  // notOVERRIDE set in Mixin#preTransform.
 
207
 
 
208
  final val lateDEFERRED  = (DEFERRED: Long) << LateShift
 
209
  final val lateFINAL     = (FINAL: Long) << LateShift
 
210
  final val lateINTERFACE = (INTERFACE: Long) << LateShift
 
211
  final val lateMETHOD    = (METHOD: Long) << LateShift
 
212
  final val lateMODULE    = (MODULE: Long) << LateShift
 
213
 
 
214
  final val notOVERRIDE   = (OVERRIDE: Long) << AntiShift
 
215
  final val notPRIVATE    = (PRIVATE: Long) << AntiShift
 
216
  final val notPROTECTED  = (PROTECTED: Long) << AntiShift
 
217
 
 
218
  // ------- masks -----------------------------------------------------------------------
 
219
 
 
220
  /** To be a little clearer to people who aren't habitual bit twiddlers.
 
221
   */
 
222
  final val AllFlags = -1L
 
223
 
 
224
  /** These flags can be set when class or module symbol is first created.
 
225
   *  They are the only flags to survive a call to resetFlags().
 
226
   */
 
227
  final val TopLevelCreationFlags =
 
228
    MODULE | PACKAGE | FINAL | JAVA
 
229
 
 
230
  // TODO - there's no call to slap four flags onto every package.
 
231
  final val PackageFlags = TopLevelCreationFlags
 
232
 
 
233
  // FINAL not included here due to possibility of object overriding.
 
234
  // In fact, FINAL should not be attached regardless.  We should be able
 
235
  // to reconstruct whether an object was marked final in source.
 
236
  final val ModuleFlags = MODULE
 
237
 
 
238
  /** These modifiers can be set explicitly in source programs.  This is
 
239
   *  used only as the basis for the default flag mask (which ones to display
 
240
   *  when printing a normal message.)
 
241
   */
 
242
  final val ExplicitFlags =
 
243
    PRIVATE | PROTECTED | ABSTRACT | FINAL | SEALED |
 
244
    OVERRIDE | CASE | IMPLICIT | ABSOVERRIDE | LAZY | DEFAULTMETHOD
 
245
 
 
246
  /** The two bridge flags */
 
247
  final val BridgeFlags = BRIDGE | VBRIDGE
 
248
  final val BridgeAndPrivateFlags = BridgeFlags | PRIVATE
 
249
 
 
250
  /** These modifiers appear in TreePrinter output. */
 
251
  final val PrintableFlags =
 
252
    ExplicitFlags | BridgeFlags | LOCAL | SYNTHETIC | STABLE | CASEACCESSOR | MACRO |
 
253
    ACCESSOR | SUPERACCESSOR | PARAMACCESSOR | STATIC | SPECIALIZED | SYNCHRONIZED
 
254
 
 
255
  /** When a symbol for a field is created, only these flags survive
 
256
   *  from Modifiers.  Others which may be applied at creation time are:
 
257
   *  PRIVATE, LOCAL.
 
258
   */
 
259
  final val FieldFlags =
 
260
    MUTABLE | CASEACCESSOR | PARAMACCESSOR | STATIC | FINAL | PRESUPER | LAZY
 
261
 
 
262
  /** Masks for getters and setters, where the flags are derived from those
 
263
   *  on the field's modifiers.  Both getters and setters get the ACCESSOR flag.
 
264
   *  Getters of immutable values also get STABLE.
 
265
   */
 
266
  final val GetterFlags = ~(PRESUPER | MUTABLE)
 
267
  final val SetterFlags = ~(PRESUPER | MUTABLE | STABLE | CASEACCESSOR | IMPLICIT)
 
268
 
 
269
  /** When a symbol for a default getter is created, it inherits these
 
270
   *  flags from the method with the default.  Other flags applied at creation
 
271
   *  time are SYNTHETIC, DEFAULTPARAM, and possibly OVERRIDE, and maybe PRESUPER.
 
272
   */
 
273
  final val DefaultGetterFlags = PRIVATE | PROTECTED | FINAL
 
274
 
 
275
  /** When a symbol for a method parameter is created, only these flags survive
 
276
   *  from Modifiers.  Others which may be applied at creation time are:
 
277
   *  SYNTHETIC.
 
278
   */
 
279
  final val ValueParameterFlags = BYNAMEPARAM | IMPLICIT | DEFAULTPARAM | STABLE | SYNTHETIC
 
280
  final val BeanPropertyFlags   = DEFERRED | OVERRIDE | STATIC
 
281
  final val VarianceFlags       = COVARIANT | CONTRAVARIANT
 
282
 
 
283
  /** These appear to be flags which should be transferred from owner symbol
 
284
   *  to a newly created constructor symbol.
 
285
   */
 
286
  final val ConstrFlags = JAVA
 
287
 
 
288
  /** Module flags inherited by their module-class */
 
289
  final val ModuleToClassFlags = AccessFlags | TopLevelCreationFlags | CASE | SYNTHETIC
 
290
 
 
291
  /** These flags are not pickled */
 
292
  final val FlagsNotPickled = IS_ERROR | OVERLOADED | LIFTED | TRANS_FLAG | LOCKED | TRIEDCOOKING
 
293
 
 
294
  // A precaution against future additions to FlagsNotPickled turning out
 
295
  // to be overloaded flags thus not-pickling more than intended.
 
296
  assert((OverloadedFlagsMask & FlagsNotPickled) == 0, flagsToString(OverloadedFlagsMask & FlagsNotPickled))
 
297
 
 
298
  /** These flags are pickled */
 
299
  final val PickledFlags  = InitialFlags & ~FlagsNotPickled
 
300
 
 
301
  /** If we have a top-level class or module
 
302
   *  and someone asks us for a flag not in TopLevelPickledFlags,
 
303
   *  then we don't need unpickling to give a definite answer.
 
304
   */
 
305
  final val TopLevelPickledFlags = PickledFlags & ~(MODULE | METHOD | PACKAGE | PARAM | EXISTENTIAL)
 
306
 
 
307
  def getterFlags(fieldFlags: Long): Long = ACCESSOR + (
 
308
    if ((fieldFlags & MUTABLE) != 0) fieldFlags & ~MUTABLE & ~PRESUPER
 
309
    else fieldFlags & ~PRESUPER | STABLE
 
310
  )
 
311
 
 
312
  def setterFlags(fieldFlags: Long): Long =
 
313
    getterFlags(fieldFlags) & ~STABLE & ~CASEACCESSOR
 
314
 
 
315
 // ------- pickling and unpickling of flags -----------------------------------------------
 
316
 
 
317
  // The flags from 0x001 to 0x800 are different in the raw flags
 
318
  // and in the pickled format.
 
319
 
 
320
  private final val IMPLICIT_PKL   = (1 << 0)
 
321
  private final val FINAL_PKL      = (1 << 1)
 
322
  private final val PRIVATE_PKL    = (1 << 2)
 
323
  private final val PROTECTED_PKL  = (1 << 3)
 
324
  private final val SEALED_PKL     = (1 << 4)
 
325
  private final val OVERRIDE_PKL   = (1 << 5)
 
326
  private final val CASE_PKL       = (1 << 6)
 
327
  private final val ABSTRACT_PKL   = (1 << 7)
 
328
  private final val DEFERRED_PKL   = (1 << 8)
 
329
  private final val METHOD_PKL     = (1 << 9)
 
330
  private final val MODULE_PKL     = (1 << 10)
 
331
  private final val INTERFACE_PKL  = (1 << 11)
 
332
 
 
333
  private final val PKL_MASK       = 0x00000FFF
 
334
 
 
335
  /** Pickler correspondence, ordered roughly by frequency of occurrence */
 
336
  private def rawPickledCorrespondence = Array[(Long, Long)](
 
337
    (METHOD, METHOD_PKL),
 
338
    (PRIVATE, PRIVATE_PKL),
 
339
    (FINAL, FINAL_PKL),
 
340
    (PROTECTED, PROTECTED_PKL),
 
341
    (CASE, CASE_PKL),
 
342
    (DEFERRED, DEFERRED_PKL),
 
343
    (MODULE, MODULE_PKL),
 
344
    (OVERRIDE, OVERRIDE_PKL),
 
345
    (INTERFACE, INTERFACE_PKL),
 
346
    (IMPLICIT, IMPLICIT_PKL),
 
347
    (SEALED, SEALED_PKL),
 
348
    (ABSTRACT, ABSTRACT_PKL)
 
349
  )
 
350
 
 
351
  private val mappedRawFlags = rawPickledCorrespondence map (_._1)
 
352
  private val mappedPickledFlags = rawPickledCorrespondence map (_._2)
 
353
 
 
354
  private class MapFlags(from: Array[Long], to: Array[Long]) extends (Long => Long) {
 
355
    val fromSet = (0L /: from) (_ | _)
 
356
 
 
357
    def apply(flags: Long): Long = {
 
358
      var result = flags & ~fromSet
 
359
      var tobeMapped = flags & fromSet
 
360
      var i = 0
 
361
      while (tobeMapped != 0) {
 
362
        if ((tobeMapped & from(i)) != 0) {
 
363
          result |= to(i)
 
364
          tobeMapped &= ~from(i)
 
365
        }
 
366
        i += 1
 
367
      }
 
368
      result
 
369
    }
 
370
  }
 
371
 
 
372
  val rawToPickledFlags: Long => Long = new MapFlags(mappedRawFlags, mappedPickledFlags)
 
373
  val pickledToRawFlags: Long => Long = new MapFlags(mappedPickledFlags, mappedRawFlags)
 
374
 
 
375
  // ------ displaying flags --------------------------------------------------------
 
376
 
 
377
  // Generated by mkFlagToStringMethod() at Thu Feb 02 20:31:52 PST 2012
 
378
  @annotation.switch override def flagToString(flag: Long): String = flag match {
 
379
    case           PROTECTED => "protected"                           // (1L << 0)
 
380
    case            OVERRIDE => "override"                            // (1L << 1)
 
381
    case             PRIVATE => "private"                             // (1L << 2)
 
382
    case            ABSTRACT => "abstract"                            // (1L << 3)
 
383
    case            DEFERRED => "<deferred>"                          // (1L << 4)
 
384
    case               FINAL => "final"                               // (1L << 5)
 
385
    case              METHOD => "<method>"                            // (1L << 6)
 
386
    case           INTERFACE => "<interface>"                         // (1L << 7)
 
387
    case              MODULE => "<module>"                            // (1L << 8)
 
388
    case            IMPLICIT => "implicit"                            // (1L << 9)
 
389
    case              SEALED => "sealed"                              // (1L << 10)
 
390
    case                CASE => "case"                                // (1L << 11)
 
391
    case             MUTABLE => "<mutable>"                           // (1L << 12)
 
392
    case               PARAM => "<param>"                             // (1L << 13)
 
393
    case             PACKAGE => "<package>"                           // (1L << 14)
 
394
    case               MACRO => "<macro>"                             // (1L << 15)
 
395
    case         BYNAMEPARAM => "<bynameparam/captured/covariant>"    // (1L << 16)
 
396
    case       CONTRAVARIANT => "<contravariant/inconstructor/label>" // (1L << 17)
 
397
    case         ABSOVERRIDE => "absoverride"                         // (1L << 18)
 
398
    case               LOCAL => "<local>"                             // (1L << 19)
 
399
    case                JAVA => "<java>"                              // (1L << 20)
 
400
    case           SYNTHETIC => "<synthetic>"                         // (1L << 21)
 
401
    case              STABLE => "<stable>"                            // (1L << 22)
 
402
    case              STATIC => "<static>"                            // (1L << 23)
 
403
    case        CASEACCESSOR => "<caseaccessor>"                      // (1L << 24)
 
404
    case        DEFAULTPARAM => "<defaultparam/trait>"                // (1L << 25)
 
405
    case              BRIDGE => "<bridge>"                            // (1L << 26)
 
406
    case            ACCESSOR => "<accessor>"                          // (1L << 27)
 
407
    case       SUPERACCESSOR => "<superaccessor>"                     // (1L << 28)
 
408
    case       PARAMACCESSOR => "<paramaccessor>"                     // (1L << 29)
 
409
    case           MODULEVAR => "<modulevar>"                         // (1L << 30)
 
410
    case                LAZY => "lazy"                                // (1L << 31)
 
411
    case            IS_ERROR => "<is_error>"                          // (1L << 32)
 
412
    case          OVERLOADED => "<overloaded>"                        // (1L << 33)
 
413
    case              LIFTED => "<lifted>"                            // (1L << 34)
 
414
    case         EXISTENTIAL => "<existential/mixedin>"               // (1L << 35)
 
415
    case        EXPANDEDNAME => "<expandedname>"                      // (1L << 36)
 
416
    case           IMPLCLASS => "<implclass/presuper>"                // (1L << 37)
 
417
    case          TRANS_FLAG => "<trans_flag>"                        // (1L << 38)
 
418
    case              LOCKED => "<locked>"                            // (1L << 39)
 
419
    case         SPECIALIZED => "<specialized>"                       // (1L << 40)
 
420
    case         DEFAULTINIT => "<defaultinit>"                       // (1L << 41)
 
421
    case             VBRIDGE => "<vbridge>"                           // (1L << 42)
 
422
    case             VARARGS => "<varargs>"                           // (1L << 43)
 
423
    case        TRIEDCOOKING => "<triedcooking>"                      // (1L << 44)
 
424
    case        SYNCHRONIZED => "<synchronized>"                      // (1L << 45)
 
425
    case     0x400000000000L => ""                                    // (1L << 46)
 
426
    case       DEFAULTMETHOD => "<defaultmethod>"                     // (1L << 47)
 
427
    case    0x1000000000000L => ""                                    // (1L << 48)
 
428
    case    0x2000000000000L => ""                                    // (1L << 49)
 
429
    case    0x4000000000000L => ""                                    // (1L << 50)
 
430
    case      `lateDEFERRED` => "<latedeferred>"                      // (1L << 51)
 
431
    case         `lateFINAL` => "<latefinal>"                         // (1L << 52)
 
432
    case        `lateMETHOD` => "<latemethod>"                        // (1L << 53)
 
433
    case     `lateINTERFACE` => "<lateinterface>"                     // (1L << 54)
 
434
    case        `lateMODULE` => "<latemodule>"                        // (1L << 55)
 
435
    case      `notPROTECTED` => "<notprotected>"                      // (1L << 56)
 
436
    case       `notOVERRIDE` => "<notoverride>"                       // (1L << 57)
 
437
    case        `notPRIVATE` => "<notprivate>"                        // (1L << 58)
 
438
    case  0x800000000000000L => ""                                    // (1L << 59)
 
439
    case 0x1000000000000000L => ""                                    // (1L << 60)
 
440
    case 0x2000000000000000L => ""                                    // (1L << 61)
 
441
    case 0x4000000000000000L => ""                                    // (1L << 62)
 
442
    case 0x8000000000000000L => ""                                    // (1L << 63)
 
443
    case _ => ""
 
444
  }
 
445
 
 
446
  private def accessString(flags: Long, privateWithin: String)= (
 
447
    if (privateWithin == "") {
 
448
      if ((flags & PrivateLocal) == PrivateLocal) "private[this]"
 
449
      else if ((flags & ProtectedLocal) == ProtectedLocal) "protected[this]"
 
450
      else if ((flags & PRIVATE) != 0) "private"
 
451
      else if ((flags & PROTECTED) != 0) "protected"
 
452
      else ""
 
453
    }
 
454
    else if ((flags & PROTECTED) != 0) "protected[" + privateWithin + "]"
 
455
    else "private[" + privateWithin + "]"
 
456
  )
 
457
 
 
458
  @deprecated("Use flagString on the flag-carrying member", "2.10.0")
 
459
  def flagsToString(flags: Long, privateWithin: String): String = {
 
460
    val access    = accessString(flags, privateWithin)
 
461
    val nonAccess = flagsToString(flags & ~AccessFlags)
 
462
 
 
463
    List(nonAccess, access) filterNot (_ == "") mkString " "
 
464
  }
 
465
 
 
466
  @deprecated("Use flagString on the flag-carrying member", "2.10.0")
 
467
  def flagsToString(flags: Long): String = {
 
468
    // Fast path for common case
 
469
    if (flags == 0L) "" else {
 
470
      var sb: StringBuilder = null
 
471
      var i = 0
 
472
      while (i <= MaxBitPosition) {
 
473
        val mask = rawFlagPickledOrder(i)
 
474
        if ((flags & mask) != 0L) {
 
475
          val s = flagToString(mask)
 
476
          if (s.length > 0) {
 
477
            if (sb eq null) sb = new StringBuilder append s
 
478
            else if (sb.length == 0) sb append s
 
479
            else sb append " " append s
 
480
          }
 
481
        }
 
482
        i += 1
 
483
      }
 
484
      if (sb eq null) "" else sb.toString
 
485
    }
 
486
  }
 
487
 
 
488
  // List of the raw flags, in pickled order
 
489
  final val MaxBitPosition = 62
 
490
 
 
491
  final val pickledListOrder: List[Long] = {
 
492
    val all   = 0 to MaxBitPosition map (1L << _)
 
493
    val front = mappedRawFlags map (_.toLong)
 
494
 
 
495
    front.toList ++ (all filterNot (front contains _))
 
496
  }
 
497
  final val rawFlagPickledOrder: Array[Long] = pickledListOrder.toArray
 
498
}
 
499
 
 
500
object Flags extends Flags { }