< prev index next > src/jdk.compiler/share/classes/com/sun/tools/javac/code/Flags.java
Print this page
// bit positions, we translate them when reading and writing class
// files into unique bits positions: ACC_SYNTHETIC <-> SYNTHETIC,
// for example.
@Use({FlagTarget.CLASS})
@NoToStringValue
- public static final int ACC_SUPER = 1<<5;
+ public static final int ACC_IDENTITY = 1<<5;
@Use({FlagTarget.METHOD})
@NoToStringValue
public static final int ACC_BRIDGE = 1<<6;
@Use({FlagTarget.METHOD})
@NoToStringValue
public static final int ACC_VARARGS = 1<<7;
+ @Use({FlagTarget.VARIABLE})
+ @NoToStringValue
+ public static final int ACC_STRICT = 1<<11;
@Use({FlagTarget.CLASS})
@NoToStringValue
public static final int ACC_MODULE = 1<<15;
/* ***************************************
* has an initializer part.
*/
@Use({FlagTarget.VARIABLE})
public static final int HASINIT = 1<<18;
+ /** Flag is set for a class or interface whose instances have identity
+ * i.e. any concrete class not declared with the modifier `value'
+ * (a) abstract class not declared `value'
+ * (b) older class files with ACC_SUPER bit set
+ */
+ @Use({FlagTarget.CLASS})
+ public static final int IDENTITY_TYPE = 1<<18;
+
/** Class is an implicitly declared top level class.
*/
@Use({FlagTarget.CLASS})
public static final int IMPLICIT_CLASS = 1<<19;
/** Flag is set for compiler-generated anonymous method symbols
* that `own' an initializer block.
*/
@Use({FlagTarget.METHOD})
- public static final int BLOCK = 1<<20;
+ public static final int BLOCK = 1<<21;
+
+ /** Marks a type as a value class */
+ @Use({FlagTarget.CLASS})
+ public static final int VALUE_CLASS = 1<<20;
/** Flag is set for ClassSymbols that are being compiled from source.
*/
@Use({FlagTarget.CLASS})
public static final int FROM_SOURCE = 1<<21;
* Flag to indicate the given ClassSymbol is a value based.
*/
@Use({FlagTarget.CLASS})
public static final long VALUE_BASED = 1L<<53;
+ /**
+ * Flag to indicate the given ClassSymbol is a value based.
+ */
+ @Use({FlagTarget.CLASS})
+ public static final long MIGRATED_VALUE_CLASS = 1L<<57; //ClassSymbols only
+
/**
* Flag to indicate the given symbol has a @Deprecated annotation.
*/
@Use({FlagTarget.CLASS, FlagTarget.METHOD, FlagTarget.MODULE, FlagTarget.PACKAGE, FlagTarget.TYPE_VAR, FlagTarget.VARIABLE})
public static final long DEPRECATED_ANNOTATION = 1L<<54;
*/
@Use({FlagTarget.CLASS})
@CustomToStringValue("non-sealed")
public static final long NON_SEALED = 1L<<63; // part of ExtendedStandardFlags, cannot be reused
+ /**
+ * Flag to indicate that a class has at least one strict field
+ */
+ @Use({FlagTarget.CLASS})
+ public static final long HAS_STRICT = 1L<<52; // ClassSymbols, temporary hack
+
+ /**
+ * Flag to indicate that a field is strict
+ */
+ @Use({FlagTarget.VARIABLE})
+ public static final long STRICT = 1L<<19; // VarSymbols
+
/**
* Describe modifier flags as they might appear in source code, i.e.,
* separated by spaces and in the order suggested by JLS 8.1.1.
*/
public static String toSource(long flags) {
/** Modifier masks.
*/
@NotFlag
public static final int
AccessFlags = PUBLIC | PROTECTED | PRIVATE,
- LocalClassFlags = FINAL | ABSTRACT | STRICTFP | ENUM | SYNTHETIC,
- StaticLocalFlags = LocalClassFlags | STATIC | INTERFACE,
+ LocalClassFlags = FINAL | ABSTRACT | STRICTFP | ENUM | SYNTHETIC | IDENTITY_TYPE,
+ StaticLocalClassFlags = LocalClassFlags | STATIC | INTERFACE,
MemberClassFlags = LocalClassFlags | INTERFACE | AccessFlags,
MemberStaticClassFlags = MemberClassFlags | STATIC,
ClassFlags = LocalClassFlags | INTERFACE | PUBLIC | ANNOTATION,
InterfaceVarFlags = FINAL | STATIC | PUBLIC,
VarFlags = AccessFlags | FINAL | STATIC |
RecordMethodFlags = AccessFlags | ABSTRACT | STATIC |
SYNCHRONIZED | FINAL | STRICTFP;
@NotFlag
public static final long
//NOTE: flags in ExtendedStandardFlags cannot be overlayed across Symbol kinds:
- ExtendedStandardFlags = (long)StandardFlags | DEFAULT | SEALED | NON_SEALED,
- ExtendedMemberClassFlags = (long)MemberClassFlags | SEALED | NON_SEALED,
- ExtendedMemberStaticClassFlags = (long) MemberStaticClassFlags | SEALED | NON_SEALED,
- ExtendedClassFlags = (long)ClassFlags | SEALED | NON_SEALED,
- ModifierFlags = ((long)StandardFlags & ~INTERFACE) | DEFAULT | SEALED | NON_SEALED,
+ ExtendedStandardFlags = (long)StandardFlags | DEFAULT | SEALED | NON_SEALED | VALUE_CLASS,
+ ExtendedMemberClassFlags = (long)MemberClassFlags | SEALED | NON_SEALED | VALUE_CLASS,
+ ExtendedMemberStaticClassFlags = (long) MemberStaticClassFlags | SEALED | NON_SEALED | VALUE_CLASS,
+ ExtendedClassFlags = (long)ClassFlags | SEALED | NON_SEALED | VALUE_CLASS,
+ ExtendedLocalClassFlags = (long) LocalClassFlags | VALUE_CLASS,
+ ExtendedStaticLocalClassFlags = (long) StaticLocalClassFlags | VALUE_CLASS,
+ ValueFieldFlags = (long) VarFlags | STRICT | FINAL,
+ ModifierFlags = ((long)StandardFlags & ~INTERFACE) | DEFAULT | SEALED | NON_SEALED | VALUE_CLASS,
InterfaceMethodMask = ABSTRACT | PRIVATE | STATIC | PUBLIC | STRICTFP | DEFAULT,
AnnotationTypeElementMask = ABSTRACT | PUBLIC,
LocalVarFlags = FINAL | PARAMETER,
ReceiverParamFlags = PARAMETER;
if (0 != (flags & SYNCHRONIZED))
modifiers.add(Modifier.SYNCHRONIZED);
if (0 != (flags & NATIVE)) modifiers.add(Modifier.NATIVE);
if (0 != (flags & STRICTFP)) modifiers.add(Modifier.STRICTFP);
if (0 != (flags & DEFAULT)) modifiers.add(Modifier.DEFAULT);
+ if (0 != (flags & VALUE_CLASS)) modifiers.add(Modifier.VALUE);
modifiers = Collections.unmodifiableSet(modifiers);
modifierSets.put(flags, modifiers);
}
return modifiers;
}
< prev index next >