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

-:f91144b7da75
+:af8417e590f4
 *  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;
 }
 while (owner.kind == TYP && ((ClassSymbol)owner).members().lookup(result).scope != null)
 result = names.fromString(result.toString() + target.syntheticNameChar());
 return result;
 }
-/** Definition for this$n field.
+private VarSymbol makeOuterThisVarSymbol(Symbol owner, long flags) {
-*  @param pos        The source code position of the definition.
-*  @param owner      The class in which the definition goes.
-*/
-JCVariableDecl outerThisDef(int pos, Symbol owner) {
-long flags = FINAL | SYNTHETIC;
 if (owner.kind == TYP &&
 target.usePrivateSyntheticFields())
 flags |= PRIVATE;
 Type target = types.erasure(owner.enclClass().type.getEnclosingType());
-VarSymbol outerThis = new VarSymbol(
+VarSymbol outerThis =
-flags, outerThisName(target, owner), target, owner);
+new VarSymbol(flags, outerThisName(target, owner), target, owner);
 outerThisStack = outerThisStack.prepend(outerThis);
-JCVariableDecl vd = make.at(pos).VarDef(outerThis, null);
+return outerThis;
+}
+private JCVariableDecl makeOuterThisVarDecl(int pos, VarSymbol sym) {
+JCVariableDecl vd = make.at(pos).VarDef(sym, null);
 vd.vartype = access(vd.vartype);
 return vd;
+}
+/** Definition for this$n field.
+*  @param pos        The source code position of the definition.
+*  @param owner      The method in which the definition goes.
+*/
+JCVariableDecl outerThisDef(int pos, MethodSymbol owner) {
+ClassSymbol c = owner.enclClass();
+boolean isMandated =
+// Anonymous constructors
+(owner.isConstructor() && owner.isAnonymous()) ||
+// Constructors of non-private inner member classes
+(owner.isConstructor() && c.isInner() &&
+!c.isPrivate() && !c.isStatic());
+long flags =
+FINAL | (isMandated ? MANDATED : SYNTHETIC);
+VarSymbol outerThis = makeOuterThisVarSymbol(owner, flags);
+owner.extraParams = owner.extraParams.prepend(outerThis);
+return makeOuterThisVarDecl(pos, outerThis);
+}
+/** Definition for this$n field.
+*  @param pos        The source code position of the definition.
+*  @param owner      The class in which the definition goes.
+*/
+JCVariableDecl outerThisDef(int pos, ClassSymbol owner) {
+VarSymbol outerThis = makeOuterThisVarSymbol(owner, FINAL | SYNTHETIC);
+return makeOuterThisVarDecl(pos, outerThis);
 }
 /** Return a list of trees that load the free variables in given list,
 *  in reverse order.
 *  @param pos          The source code position to be used for the trees.
 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:
 *
 JCVariableDecl nameParam = make_at(tree.pos()).
 Param(names.fromString(target.syntheticNameChar() +
 "enum" + target.syntheticNameChar() + "name"),
 syms.stringType, tree.sym);
 nameParam.mods.flags |= SYNTHETIC; nameParam.sym.flags_field |= SYNTHETIC;
 JCVariableDecl ordParam = make.
 Param(names.fromString(target.syntheticNameChar() +
 "enum" + target.syntheticNameChar() +
 "ordinal"),
 syms.intType, tree.sym);
 ordParam.mods.flags |= SYNTHETIC; ordParam.sym.flags_field |= SYNTHETIC;
 tree.params = tree.params.prepend(ordParam).prepend(nameParam);
 MethodSymbol m = tree.sym;
+m.extraParams = m.extraParams.prepend(ordParam.sym);
+m.extraParams = m.extraParams.prepend(nameParam.sym);
 Type olderasure = m.erasure(types);
 m.erasure_field = new MethodType(
 olderasure.getParameterTypes().prepend(syms.intType).prepend(syms.stringType),
 olderasure.getReturnType(),
 olderasure.getThrownTypes(),
 result = tree;
 }
 }
 public void visitAssignop(final JCAssignOp tree) {
-if (!tree.lhs.type.isPrimitive() &&
+final boolean boxingReq = !tree.lhs.type.isPrimitive() &&
-tree.operator.type.getReturnType().isPrimitive()) {
+tree.operator.type.getReturnType().isPrimitive();
-// boxing required; need to rewrite as x = (unbox typeof x)(x op y);
-// or if x == (typeof x)z then z = (unbox typeof x)((typeof x)z op y)
+// boxing required; need to rewrite as x = (unbox typeof x)(x op y);
-// (but without recomputing x)
+// or if x == (typeof x)z then z = (unbox typeof x)((typeof x)z op y)
-JCTree newTree = abstractLval(tree.lhs, new TreeBuilder() {
+// (but without recomputing x)
-public JCTree build(final JCTree lhs) {
+JCTree newTree = abstractLval(tree.lhs, new TreeBuilder() {
-JCTree.Tag newTag = tree.getTag().noAssignOp();
+public JCTree build(final JCTree lhs) {
-// Erasure (TransTypes) can change the type of
+JCTree.Tag newTag = tree.getTag().noAssignOp();
-// tree.lhs.  However, we can still get the
+// Erasure (TransTypes) can change the type of
-// unerased type of tree.lhs as it is stored
+// tree.lhs.  However, we can still get the
-// in tree.type in Attr.
+// unerased type of tree.lhs as it is stored
-Symbol newOperator = rs.resolveBinaryOperator(tree.pos(),
+// in tree.type in Attr.
-newTag,
+Symbol newOperator = rs.resolveBinaryOperator(tree.pos(),
-attrEnv,
+newTag,
-tree.type,
+attrEnv,
-tree.rhs.type);
+tree.type,
-JCExpression expr = (JCExpression)lhs;
+tree.rhs.type);
-if (expr.type != tree.type)
+JCExpression expr = (JCExpression)lhs;
-expr = make.TypeCast(tree.type, expr);
+if (expr.type != tree.type)
-JCBinary opResult = make.Binary(newTag, expr, tree.rhs);
+expr = make.TypeCast(tree.type, expr);
-opResult.operator = newOperator;
+JCBinary opResult = make.Binary(newTag, expr, tree.rhs);
-opResult.type = newOperator.type.getReturnType();
+opResult.operator = newOperator;
-JCTypeCast newRhs = make.TypeCast(types.unboxedType(tree.type),
+opResult.type = newOperator.type.getReturnType();
-opResult);
+JCExpression newRhs = boxingReq ?
-return make.Assign((JCExpression)lhs, newRhs).setType(tree.type);
+make.TypeCast(types.unboxedType(tree.type),
-}
+opResult) :
-});
+opResult;
-result = translate(newTree);
+return make.Assign((JCExpression)lhs, newRhs).setType(tree.type);
-return;
+}
-}
+});
-tree.lhs = translate(tree.lhs, tree);
+result = translate(newTree);
-tree.rhs = translate(tree.rhs, tree.operator.type.getParameterTypes().tail.head);
-// If translated left hand side is an Apply, we are
-// seeing an access method invocation. In this case, append
-// right hand side as last argument of the access method.
-if (tree.lhs.hasTag(APPLY)) {
-JCMethodInvocation app = (JCMethodInvocation)tree.lhs;
-// if operation is a += on strings,
-// make sure to convert argument to string
-JCExpression rhs = (((OperatorSymbol)tree.operator).opcode == string_add)
-? makeString(tree.rhs)
-: tree.rhs;
-app.args = List.of(rhs).prependList(app.args);
-result = app;
-} else {
-result = tree;
-}
 }
 /** Lower a tree of the form e++ or e-- where e is an object type */
 JCTree lowerBoxedPostop(final JCUnary tree) {
 // translate to tmp1=lval(e); tmp2=tmp1; tmp1 OP 1; tmp2

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