jdk8-mips64-public/langtools: comparison src/share/classes/com/sun/tools/javac/comp/Lower.java

-:4cc73ec94686
+:a51a8dac0a2f
 *  its symbol. Return the class definition's symbol.
 *  and create
 *  @param flags    The class symbol's flags
 *  @param owner    The class symbol's owner
 */
-ClassSymbol makeEmptyClass(long flags, ClassSymbol owner) {
+JCClassDecl makeEmptyClass(long flags, ClassSymbol owner) {
+return makeEmptyClass(flags, owner, null, true);
+}
+JCClassDecl makeEmptyClass(long flags, ClassSymbol owner, Name flatname,
+boolean addToDefs) {
 // Create class symbol.
 ClassSymbol c = reader.defineClass(names.empty, owner);
-c.flatname = chk.localClassName(c);
+if (flatname != null) {
+c.flatname = flatname;
+} else {
+c.flatname = chk.localClassName(c);
+}
 c.sourcefile = owner.sourcefile;
 c.completer = null;
 c.members_field = new Scope(c);
 c.flags_field = flags;
 ClassType ctype = (ClassType) c.type;
 null, List.<JCExpression>nil(), List.<JCTree>nil());
 cdef.sym = c;
 cdef.type = c.type;
 // Append class definition tree to owner's definitions.
-odef.defs = odef.defs.prepend(cdef);
+if (addToDefs) odef.defs = odef.defs.prepend(cdef);
+return cdef;
-return c;
 }
 /**************************************************************************
 * Symbol manipulation utilities
 *************************************************************************/
 /** Anon inner classes are used as access constructor tags.
 * accessConstructorTag will use an existing anon class if one is available,
 * and synthethise a class (with makeEmptyClass) if one is not available.
 * However, there is a small possibility that an existing class will not
 * be generated as expected if it is inside a conditional with a constant
-* expression. If that is found to be the case, create an empty class here.
+* expression. If that is found to be the case, create an empty class tree here.
 */
 private void checkAccessConstructorTags() {
 for (List<ClassSymbol> l = accessConstrTags; l.nonEmpty(); l = l.tail) {
 ClassSymbol c = l.head;
 if (isTranslatedClassAvailable(c))
 continue;
 // Create class definition tree.
-JCClassDecl cdef = make.ClassDef(
+JCClassDecl cdec = makeEmptyClass(STATIC | SYNTHETIC,
-make.Modifiers(STATIC | SYNTHETIC), names.empty,
+c.outermostClass(), c.flatname, false);
-List.<JCTypeParameter>nil(),
+swapAccessConstructorTag(c, cdec.sym);
-null, List.<JCExpression>nil(), List.<JCTree>nil());
+translated.append(cdec);
-cdef.sym = c;
-cdef.type = c.type;
-// add it to the list of classes to be generated
-translated.append(cdef);
 }
 }
 // where
 private boolean isTranslatedClassAvailable(ClassSymbol c) {
 for (JCTree tree: translated) {
 && ((JCClassDecl) tree).sym == c) {
 return true;
 }
 }
 return false;
+}
+void swapAccessConstructorTag(ClassSymbol oldCTag, ClassSymbol newCTag) {
+for (MethodSymbol methodSymbol : accessConstrs.values()) {
+Assert.check(methodSymbol.type.hasTag(METHOD));
+MethodType oldMethodType =
+(MethodType)methodSymbol.type;
+if (oldMethodType.argtypes.head.tsym == oldCTag)
+methodSymbol.type =
+types.createMethodTypeWithParameters(oldMethodType,
+oldMethodType.getParameterTypes().tail
+.prepend(newCTag.erasure(types)));
+}
 }
 /**************************************************************************
 * Access methods
 *************************************************************************/
 Name flatname = names.fromString("" + topClass.getQualifiedName() +
 target.syntheticNameChar() +
 "1");
 ClassSymbol ctag = chk.compiled.get(flatname);
 if (ctag == null)
-ctag = makeEmptyClass(STATIC | SYNTHETIC, topClass);
+ctag = makeEmptyClass(STATIC | SYNTHETIC, topClass).sym;
 // keep a record of all tags, to verify that all are generated as required
 accessConstrTags = accessConstrTags.prepend(ctag);
 return ctag;
 }
 Scope s = clazz.members();
 for (Scope.Entry e = s.elems; e != null; e = e.sibling)
 if (e.sym.kind == TYP &&
 e.sym.name == names.empty &&
 (e.sym.flags() & INTERFACE) == 0) return (ClassSymbol) e.sym;
-return makeEmptyClass(STATIC | SYNTHETIC, clazz);
+return makeEmptyClass(STATIC | SYNTHETIC, clazz).sym;
 }
 /** Return symbol for "class$" method. If there is no method definition
 *  for class$, construct one as follows:
 *

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: src/share/classes/com/sun/tools/javac/comp/Lower.java

src/share/classes/com/sun/tools/javac/comp/Lower.java