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

-:be5cafeb318d
+:d8a15fda7e3a
 */
 private VarSymbol lookupField(DiagnosticPosition pos, Type qual, Name name) {
 return rs.resolveInternalField(pos, attrEnv, qual, name);
 }
+/** 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.
+*/
+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(
+make.Modifiers(STATIC | SYNTHETIC), names.empty,
+List.<JCTypeParameter>nil(),
+null, List.<JCExpression>nil(), List.<JCTree>nil());
+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) {
+if (tree.getTag() == JCTree.CLASSDEF
+&& ((JCClassDecl) tree).sym == c) {
+return true;
+}
+}
+return false;
+}
 /**************************************************************************
 * Access methods
 *************************************************************************/
 /** Access codes for dereferencing, assignment,
 private Map<Symbol,MethodSymbol[]> accessSyms;
 /** A mapping from (constructor) symbols to access constructor symbols.
 */
 private Map<Symbol,MethodSymbol> accessConstrs;
+/** A list of all class symbols used for access constructor tags.
+*/
+private List<ClassSymbol> accessConstrTags;
 /** A queue for all accessed symbols.
 */
 private ListBuffer<Symbol> accessed;
 target.syntheticNameChar() +
 "1");
 ClassSymbol ctag = chk.compiled.get(flatname);
 if (ctag == null)
 ctag = makeEmptyClass(STATIC | SYNTHETIC, topClass);
+// keep a record of all tags, to verify that all are generated as required
+accessConstrTags = accessConstrTags.prepend(ctag);
 return ctag;
 }
 /** Add all required access methods for a private symbol to enclosing class.
 *  @param sym       The symbol.
 proxies = new Scope(syms.noSymbol);
 outerThisStack = List.nil();
 accessNums = new HashMap<Symbol,Integer>();
 accessSyms = new HashMap<Symbol,MethodSymbol[]>();
 accessConstrs = new HashMap<Symbol,MethodSymbol>();
+accessConstrTags = List.nil();
 accessed = new ListBuffer<Symbol>();
 translate(cdef, (JCExpression)null);
 for (List<Symbol> l = accessed.toList(); l.nonEmpty(); l = l.tail)
 makeAccessible(l.head);
 for (EnumMapping map : enumSwitchMap.values())
 map.translate();
 checkConflicts(this.translated.toList());
+checkAccessConstructorTags();
 translated = this.translated;
 } finally {
 // note that recursive invocations of this method fail hard
 attrEnv = null;
 this.make = null;
 proxies = null;
 outerThisStack = null;
 accessNums = null;
 accessSyms = null;
 accessConstrs = null;
+accessConstrTags = null;
 accessed = null;
 enumSwitchMap.clear();
 }
 return translated.toList();
 }

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