/*
 * Copyright (c) 1994, 2003, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package sun.tools.tree;

import sun.tools.java.*;
import sun.tools.asm.Assembler;
import java.util.Hashtable;

WARNING: The contents of this source file are not part of any supported API. Code that depends on them does so at its own risk: they are subject to change or removal without notice.
/** * WARNING: The contents of this source file are not part of any * supported API. Code that depends on them does so at its own risk: * they are subject to change or removal without notice. */
public class NewInstanceExpression extends NaryExpression { MemberDefinition field; Expression outerArg; ClassDefinition body; // Access method for constructor, if needed. MemberDefinition implMethod = null;
Constructor
/** * Constructor */
public NewInstanceExpression(long where, Expression right, Expression args[]) { super(NEWINSTANCE, where, Type.tError, right, args); } public NewInstanceExpression(long where, Expression right, Expression args[], Expression outerArg, ClassDefinition body) { this(where, right, args); this.outerArg = outerArg; this.body = body; }
From the "new" in an expression of the form outer.new InnerCls(...), return the "outer" expression, or null if there is none.
/** * From the "new" in an expression of the form outer.new InnerCls(...), * return the "outer" expression, or null if there is none. */
public Expression getOuterArg() { return outerArg; } int precedence() { return 100; } public Expression order() { // act like a method or field reference expression: if (outerArg != null && opPrecedence[FIELD] > outerArg.precedence()) { UnaryExpression e = (UnaryExpression)outerArg; outerArg = e.right; e.right = order(); return e; } return this; }
Check expression type
/** * Check expression type */
public Vset checkValue(Environment env, Context ctx, Vset vset, Hashtable exp) { // What type? ClassDefinition def = null; Expression alreadyChecked = null; try { if (outerArg != null) { vset = outerArg.checkValue(env, ctx, vset, exp); // Remember the expression that we already checked // so that we don't attempt to check it again when // it appears as an argument to the constructor. // Fix for 4030426. alreadyChecked = outerArg; // Check outerArg and the type name together. Identifier typeName = FieldExpression.toIdentifier(right); // According to the inner classes spec, the type name in a // qualified 'new' expression must be a single identifier. if (typeName != null && typeName.isQualified()) { env.error(where, "unqualified.name.required", typeName); } if (typeName == null || !outerArg.type.isType(TC_CLASS)) { if (!outerArg.type.isType(TC_ERROR)) { env.error(where, "invalid.field.reference", idNew, outerArg.type); } outerArg = null; } else { // Don't perform checks on components of qualified name // ('getQualifiedClassDefinition'), because a qualified // name is illegal in this context, and will have previously // been reported as an error. ClassDefinition oc = env.getClassDefinition(outerArg.type); Identifier nm = oc.resolveInnerClass(env, typeName); right = new TypeExpression(right.where, Type.tClass(nm)); // Check access directly, since we're not calling toType(). env.resolve(right.where, ctx.field.getClassDefinition(), right.type); // and fall through to env.getClassDefinition() below } } if (!(right instanceof TypeExpression)) { // The call to 'toType' should perform component access checks. right = new TypeExpression(right.where, right.toType(env, ctx)); } if (right.type.isType(TC_CLASS)) def = env.getClassDefinition(right.type); } catch (AmbiguousClass ee) { env.error(where, "ambig.class", ee.name1, ee.name2); } catch (ClassNotFound ee) { env.error(where, "class.not.found", ee.name, ctx.field); } Type t = right.type; boolean hasErrors = t.isType(TC_ERROR); if (!t.isType(TC_CLASS)) { if (!hasErrors) { env.error(where, "invalid.arg.type", t, opNames[op]); hasErrors = true; } } // If we failed to find a class or a class was ambiguous, def // may be null. Bail out. This allows us to report multiple // unfound or ambiguous classes rather than tripping over an // internal compiler error. if (def == null) { type = Type.tError; return vset; } // Add an extra argument, maybe. Expression args[] = this.args; args = NewInstanceExpression. insertOuterLink(env, ctx, where, def, outerArg, args); if (args.length > this.args.length) outerArg = args[0]; // recopy the checked arg else if (outerArg != null) // else set it to void (maybe it has a side-effect) outerArg = new CommaExpression(outerArg.where, outerArg, null); // Compose a list of argument types Type argTypes[] = new Type[args.length]; for (int i = 0 ; i < args.length ; i++) { // Don't check 'outerArg' again. Fix for 4030426. if (args[i] != alreadyChecked) { vset = args[i].checkValue(env, ctx, vset, exp); } argTypes[i] = args[i].type; hasErrors = hasErrors || argTypes[i].isType(TC_ERROR); } try { // Check if there are any type errors in the arguments if (hasErrors) { type = Type.tError; return vset; } // Get the source class that this declaration appears in. ClassDefinition sourceClass = ctx.field.getClassDefinition(); ClassDeclaration c = env.getClassDeclaration(t); // If this is an anonymous class, handle it specially now. if (body != null) { // The current package. Identifier packageName = sourceClass.getName().getQualifier(); // This is an anonymous class. ClassDefinition superDef = null; if (def.isInterface()) { // For interfaces, our superclass is java.lang.Object. // We could just assume that java.lang.Object has // one constructor with no arguments in the code // that follows, but we don't. This way, if Object // grows a new constructor (unlikely) then the // compiler should handle it. superDef = env.getClassDefinition(idJavaLangObject); } else { // Otherwise, def is actually our superclass. superDef = def; } // Try to find a matching constructor in our superclass. MemberDefinition constructor = superDef.matchAnonConstructor(env, packageName, argTypes); if (constructor != null) { // We've found one. Process the body. // // Note that we are passing in the constructors' argument // types, rather than the argument types of the actual // expressions, to checkLocalClass(). Previously, // the expression types were passed in. This could // lead to trouble when one of the argument types was // the special internal type tNull. (bug 4054689). if (tracing) env.dtEvent( "NewInstanceExpression.checkValue: ANON CLASS " + body + " SUPER " + def); vset = body.checkLocalClass(env, ctx, vset, def, args, constructor.getType() .getArgumentTypes()); // Set t to be the true type of this expression. // (bug 4102056). t = body.getClassDeclaration().getType(); def = body; } } else { // Check if it is an interface if (def.isInterface()) { env.error(where, "new.intf", c); return vset; } // Check for abstract class if (def.mustBeAbstract(env)) { env.error(where, "new.abstract", c); return vset; } } // Get the constructor that the "new" expression should call. field = def.matchMethod(env, sourceClass, idInit, argTypes); // Report an error if there is no matching constructor. if (field == null) { MemberDefinition anyInit = def.findAnyMethod(env, idInit); if (anyInit != null && new MethodExpression(where, right, anyInit, args) .diagnoseMismatch(env, args, argTypes)) return vset; String sig = c.getName().getName().toString(); sig = Type.tMethod(Type.tError, argTypes).typeString(sig, false, false); env.error(where, "unmatched.constr", sig, c); return vset; } if (field.isPrivate()) { ClassDefinition cdef = field.getClassDefinition(); if (cdef != sourceClass) { // Use access method. implMethod = cdef.getAccessMember(env, ctx, field, false); } } // Check for abstract anonymous class if (def.mustBeAbstract(env)) { env.error(where, "new.abstract", c); return vset; } if (field.reportDeprecated(env)) { env.error(where, "warn.constr.is.deprecated", field, field.getClassDefinition()); } // According to JLS 6.6.2, a protected constructor may be accessed // by a class instance creation expression only from within the // package in which it is defined. if (field.isProtected() && !(sourceClass.getName().getQualifier().equals( field.getClassDeclaration().getName().getQualifier()))) { env.error(where, "invalid.protected.constructor.use", sourceClass); } } catch (ClassNotFound ee) { env.error(where, "class.not.found", ee.name, opNames[op]); return vset; } catch (AmbiguousMember ee) { env.error(where, "ambig.constr", ee.field1, ee.field2); return vset; } // Cast arguments argTypes = field.getType().getArgumentTypes(); for (int i = 0 ; i < args.length ; i++) { args[i] = convert(env, ctx, argTypes[i], args[i]); } if (args.length > this.args.length) { outerArg = args[0]; // recopy the checked arg // maintain an accurate tree for (int i = 1 ; i < args.length ; i++) { this.args[i-1] = args[i]; } } // Throw the declared exceptions. ClassDeclaration exceptions[] = field.getExceptions(env); for (int i = 0 ; i < exceptions.length ; i++) { if (exp.get(exceptions[i]) == null) { exp.put(exceptions[i], this); } } type = t; return vset; }
Given a list of arguments for a constructor, return a possibly modified list which includes the hidden argument which initializes the uplevel self pointer.
@argdef the class which perhaps contains an outer link.
@argouterArg if non-null, an explicit location in which to construct.
/** * Given a list of arguments for a constructor, * return a possibly modified list which includes the hidden * argument which initializes the uplevel self pointer. * @arg def the class which perhaps contains an outer link. * @arg outerArg if non-null, an explicit location in which to construct. */
public static Expression[] insertOuterLink(Environment env, Context ctx, long where, ClassDefinition def, Expression outerArg, Expression args[]) { if (!def.isTopLevel() && !def.isLocal()) { Expression args2[] = new Expression[1+args.length]; System.arraycopy(args, 0, args2, 1, args.length); try { if (outerArg == null) outerArg = ctx.findOuterLink(env, where, def.findAnyMethod(env, idInit)); } catch (ClassNotFound e) { // die somewhere else } args2[0] = outerArg; args = args2; } return args; }
Check void expression
/** * Check void expression */
public Vset check(Environment env, Context ctx, Vset vset, Hashtable exp) { return checkValue(env, ctx, vset, exp); }
Inline
/** * Inline */
final int MAXINLINECOST = Statement.MAXINLINECOST; public Expression copyInline(Context ctx) { NewInstanceExpression e = (NewInstanceExpression)super.copyInline(ctx); if (outerArg != null) { e.outerArg = outerArg.copyInline(ctx); } return e; } Expression inlineNewInstance(Environment env, Context ctx, Statement s) { if (env.dump()) { System.out.println("INLINE NEW INSTANCE " + field + " in " + ctx.field); } LocalMember v[] = LocalMember.copyArguments(ctx, field); Statement body[] = new Statement[v.length + 2]; int o = 1; if (outerArg != null && !outerArg.type.isType(TC_VOID)) { o = 2; body[1] = new VarDeclarationStatement(where, v[1], outerArg); } else if (outerArg != null) { body[0] = new ExpressionStatement(where, outerArg); } for (int i = 0 ; i < args.length ; i++) { body[i+o] = new VarDeclarationStatement(where, v[i+o], args[i]); } //System.out.print("BEFORE:"); s.print(System.out); System.out.println(); body[body.length - 1] = (s != null) ? s.copyInline(ctx, false) : null; //System.out.print("COPY:"); body[body.length - 1].print(System.out); System.out.println(); //System.out.print("AFTER:"); s.print(System.out); System.out.println(); LocalMember.doneWithArguments(ctx, v); return new InlineNewInstanceExpression(where, type, field, new CompoundStatement(where, body)).inline(env, ctx); } public Expression inline(Environment env, Context ctx) { return inlineValue(env, ctx); } public Expression inlineValue(Environment env, Context ctx) { if (body != null) { body.inlineLocalClass(env); } ClassDefinition refc = field.getClassDefinition(); UplevelReference r = refc.getReferencesFrozen(); if (r != null) { r.willCodeArguments(env, ctx); } //right = right.inlineValue(env, ctx); try { if (outerArg != null) { if (outerArg.type.isType(TC_VOID)) outerArg = outerArg.inline(env, ctx); else outerArg = outerArg.inlineValue(env, ctx); } for (int i = 0 ; i < args.length ; i++) { args[i] = args[i].inlineValue(env, ctx); } // This 'false' that fy put in is inexplicable to me // the decision to not inline new instance expressions // should be revisited. - dps if (false && env.opt() && field.isInlineable(env, false) && (!ctx.field.isInitializer()) && ctx.field.isMethod() && (ctx.getInlineMemberContext(field) == null)) { Statement s = (Statement)field.getValue(env); if ((s == null) || (s.costInline(MAXINLINECOST, env, ctx) < MAXINLINECOST)) { return inlineNewInstance(env, ctx, s); } } } catch (ClassNotFound e) { throw new CompilerError(e); } if (outerArg != null && outerArg.type.isType(TC_VOID)) { Expression e = outerArg; outerArg = null; return new CommaExpression(where, e, this); } return this; } public int costInline(int thresh, Environment env, Context ctx) { if (body != null) { return thresh; // don't copy classes... } if (ctx == null) { return 2 + super.costInline(thresh, env, ctx); } // sourceClass is the current class trying to inline this method ClassDefinition sourceClass = ctx.field.getClassDefinition(); try { // We only allow the inlining if the current class can access // the field and the field's class; if ( sourceClass.permitInlinedAccess(env, field.getClassDeclaration()) && sourceClass.permitInlinedAccess(env, field)) { return 2 + super.costInline(thresh, env, ctx); } } catch (ClassNotFound e) { } return thresh; }
Code
/** * Code */
public void code(Environment env, Context ctx, Assembler asm) { codeCommon(env, ctx, asm, false); } public void codeValue(Environment env, Context ctx, Assembler asm) { codeCommon(env, ctx, asm, true); } private void codeCommon(Environment env, Context ctx, Assembler asm, boolean forValue) { asm.add(where, opc_new, field.getClassDeclaration()); if (forValue) { asm.add(where, opc_dup); } ClassDefinition refc = field.getClassDefinition(); UplevelReference r = refc.getReferencesFrozen(); if (r != null) { r.codeArguments(env, ctx, asm, where, field); } if (outerArg != null) { outerArg.codeValue(env, ctx, asm); switch (outerArg.op) { case THIS: case SUPER: case NEW: // guaranteed non-null break; case FIELD: { MemberDefinition f = ((FieldExpression)outerArg).field; if (f != null && f.isNeverNull()) { break; } // else fall through: } default: // Test for nullity by invoking some trivial operation // that can throw a NullPointerException. try { ClassDefinition c = env.getClassDefinition(idJavaLangObject); MemberDefinition getc = c.getFirstMatch(idGetClass); asm.add(where, opc_dup); asm.add(where, opc_invokevirtual, getc); asm.add(where, opc_pop); } catch (ClassNotFound e) { } } } if (implMethod != null) { // Constructor call will be via an access method. // Pass 'null' as the value of the dummy argument. asm.add(where, opc_aconst_null); } for (int i = 0 ; i < args.length ; i++) { args[i].codeValue(env, ctx, asm); } asm.add(where, opc_invokespecial, ((implMethod != null) ? implMethod : field)); } }