--- old/src/share/classes/com/sun/tools/classfile/AccessFlags.java 2013-02-08 16:14:01.791038128 -0500 +++ new/src/share/classes/com/sun/tools/classfile/AccessFlags.java 2013-02-08 16:14:01.662037181 -0500 @@ -56,7 +56,7 @@ public static final int ACC_SYNTHETIC = 0x1000; // class, inner, field, method public static final int ACC_ANNOTATION = 0x2000; // class, inner public static final int ACC_ENUM = 0x4000; // class, inner, field - public static final int ACC_MODULE = 0x8000; // class, inner, field, method + public static final int ACC_MANDATED = 0x8000; // class, inner, field, method public static enum Kind { Class, InnerClass, Field, Method}; @@ -81,12 +81,12 @@ } private static final int[] classModifiers = { - ACC_PUBLIC, ACC_FINAL, ACC_ABSTRACT, ACC_MODULE + ACC_PUBLIC, ACC_FINAL, ACC_ABSTRACT }; private static final int[] classFlags = { ACC_PUBLIC, ACC_FINAL, ACC_SUPER, ACC_INTERFACE, ACC_ABSTRACT, - ACC_SYNTHETIC, ACC_ANNOTATION, ACC_ENUM, ACC_MODULE + ACC_SYNTHETIC, ACC_ANNOTATION, ACC_ENUM }; public Set getClassModifiers() { @@ -100,12 +100,12 @@ private static final int[] innerClassModifiers = { ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC, ACC_FINAL, - ACC_ABSTRACT, ACC_MODULE + ACC_ABSTRACT }; private static final int[] innerClassFlags = { ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC, ACC_FINAL, ACC_SUPER, - ACC_INTERFACE, ACC_ABSTRACT, ACC_SYNTHETIC, ACC_ANNOTATION, ACC_ENUM, ACC_MODULE + ACC_INTERFACE, ACC_ABSTRACT, ACC_SYNTHETIC, ACC_ANNOTATION, ACC_ENUM }; public Set getInnerClassModifiers() { @@ -119,12 +119,12 @@ private static final int[] fieldModifiers = { ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC, ACC_FINAL, - ACC_VOLATILE, ACC_TRANSIENT, ACC_MODULE + ACC_VOLATILE, ACC_TRANSIENT }; private static final int[] fieldFlags = { ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC, ACC_FINAL, - ACC_VOLATILE, ACC_TRANSIENT, ACC_SYNTHETIC, ACC_ENUM, ACC_MODULE + ACC_VOLATILE, ACC_TRANSIENT, ACC_SYNTHETIC, ACC_ENUM }; public Set getFieldModifiers() { @@ -137,13 +137,13 @@ private static final int[] methodModifiers = { ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC, ACC_FINAL, - ACC_SYNCHRONIZED, ACC_NATIVE, ACC_ABSTRACT, ACC_STRICT, ACC_MODULE + ACC_SYNCHRONIZED, ACC_NATIVE, ACC_ABSTRACT, ACC_STRICT }; private static final int[] methodFlags = { ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC, ACC_FINAL, ACC_SYNCHRONIZED, ACC_BRIDGE, ACC_VARARGS, ACC_NATIVE, ACC_ABSTRACT, - ACC_STRICT, ACC_SYNTHETIC, ACC_MODULE + ACC_STRICT, ACC_SYNTHETIC }; public Set getMethodModifiers() { @@ -208,8 +208,8 @@ return "abstract"; case ACC_STRICT: return "strictfp"; - case ACC_MODULE: - return "module"; + case ACC_MANDATED: + return "mandated"; default: return null; } @@ -247,8 +247,8 @@ return "ACC_ANNOTATION"; case ACC_ENUM: return "ACC_ENUM"; - case ACC_MODULE: - return "ACC_MODULE"; + case ACC_MANDATED: + return "ACC_MANDATED"; default: return null; } --- old/src/share/classes/com/sun/tools/javac/code/Flags.java 2013-02-08 16:14:02.235041386 -0500 +++ new/src/share/classes/com/sun/tools/javac/code/Flags.java 2013-02-08 16:14:02.107040448 -0500 @@ -74,6 +74,7 @@ if ((mask&DEPRECATED) != 0) flags.add(Flag.DEPRECATED); if ((mask&HASINIT) != 0) flags.add(Flag.HASINIT); if ((mask&ENUM) != 0) flags.add(Flag.ENUM); + if ((mask&MANDATED) != 0) flags.add(Flag.MANDATED); if ((mask&IPROXY) != 0) flags.add(Flag.IPROXY); if ((mask&NOOUTERTHIS) != 0) flags.add(Flag.NOOUTERTHIS); if ((mask&EXISTS) != 0) flags.add(Flag.EXISTS); @@ -114,6 +115,9 @@ * classfile v49.0. */ public static final int ENUM = 1<<14; + /** Added in SE8, represents constructs implicitly declared in source. */ + public static final int MANDATED = 1<<15; + public static final int StandardFlags = 0x0fff; public static final int ModifierFlags = StandardFlags & ~INTERFACE; @@ -342,6 +346,7 @@ DEPRECATED("deprecated"), HASINIT("hasinit"), ENUM("enum"), + MANDATED("mandated"), IPROXY("iproxy"), NOOUTERTHIS("noouterthis"), EXISTS("exists"), --- old/src/share/classes/com/sun/tools/javac/code/Symbol.java 2013-02-08 16:14:02.628044271 -0500 +++ new/src/share/classes/com/sun/tools/javac/code/Symbol.java 2013-02-08 16:14:02.508043391 -0500 @@ -217,6 +217,14 @@ return (flags() & INTERFACE) != 0; } + public boolean isPrivate() { + return (flags_field & Flags.AccessFlags) == PRIVATE; + } + + public boolean isEnum() { + return (flags() & ENUM) != 0; + } + /** Is this symbol declared (directly or indirectly) local * to a method or variable initializer? * Also includes fields of inner classes which are in --- old/src/share/classes/com/sun/tools/javac/jvm/ClassWriter.java 2013-02-08 16:14:03.040047295 -0500 +++ new/src/share/classes/com/sun/tools/javac/jvm/ClassWriter.java 2013-02-08 16:14:02.907046319 -0500 @@ -726,20 +726,67 @@ return acount; } + // Decide if the first formal parameter should be mandated. + // There are two cases that apply here: + // + // The first parameter to a non-private member class + // + // The first parameter of an anonymous constructor + boolean firstIsMandated(MethodSymbol m) { + ClassSymbol c = m.enclClass(); + + return + // Anonymous constructors + (m.isConstructor() && c.isAnonymous()) || + // Constructors of non-private inner member classes + (m.isConstructor() && c.isInner() && + !c.isPrivate() && !c.isStatic()); + } + + // The "name" parameter of an enum's valueOf is mandated, so we + // need to figure out if we're dealing with that function. + boolean isEnumValueOf(MethodSymbol m) { + return m.enclClass().isEnum() && m.name.contentEquals("valueOf"); + } + /** * Write method parameter names attribute. */ int writeMethodParametersAttr(MethodSymbol m) { - if (m.params != null && 0 != m.params.length()) { - int attrIndex = writeAttr(names.MethodParameters); - databuf.appendByte(m.params.length()); + MethodType ty = m.externalType(types).asMethodType(); + final int allparams = ty.argtypes.size(); + if (m.params != null && allparams != 0) { + final int realparams = m.params.length(); + final int synthparams = allparams - realparams; + final int attrIndex = writeAttr(names.MethodParameters); + final boolean firstmandated = firstIsMandated(m); + final boolean valueof = isEnumValueOf(m); + databuf.appendByte(allparams); + // Add synthetic/mandatade parameters. Note: at the + // present, these parameters have no easily accessible + // list of VarSymbols. It is probably a good idea to + // change MethodSymbol so that one exists, and the proper + // flags are set on the symbols when they are created, as + // opposed to doing it like this. + for (int i = 0; i < synthparams; i++) { + databuf.appendChar(0); + if(firstmandated && i == 0) + databuf.appendInt(MANDATED); + else + databuf.appendInt(SYNTHETIC); + } for (VarSymbol s : m.params) { - // TODO: expand to cover synthesized, once we figure out - // how to represent that. final int flags = (int) s.flags() & (FINAL | SYNTHETIC); + // TODO: this is done this way to preserve uniformity + // in how mandated parameters are detected and set. + // If this is changed, then set the MANDATED flag when + // this parameter is created. // output parameter info databuf.appendChar(pool.put(s.name)); - databuf.appendInt(flags); + if(valueof && s.name.contentEquals("name")) + databuf.appendInt(MANDATED); + else + databuf.appendInt(flags); } endAttr(attrIndex); return 1; --- old/src/share/classes/com/sun/tools/javap/AttributeWriter.java 2013-02-08 16:14:03.481050532 -0500 +++ new/src/share/classes/com/sun/tools/javap/AttributeWriter.java 2013-02-08 16:14:03.350049570 -0500 @@ -400,12 +400,14 @@ println(header); for (MethodParameters_attribute.Entry entry : attr.method_parameter_table) { + String namestr = + entry.name_index != 0 ? + constantWriter.stringValue(entry.name_index) : ""; String flagstr = - (0 != (entry.flags & ACC_FINAL) ? " final" : "") + + (0 != (entry.flags & ACC_FINAL) ? "final " : "") + + (0 != (entry.flags & ACC_MANDATED) ? "mandated " : "") + (0 != (entry.flags & ACC_SYNTHETIC) ? " synthetic" : ""); - println(String.format(format, - constantWriter.stringValue(entry.name_index), - flagstr)); + println(String.format(format, namestr, flagstr)); } indent(-1); return null;