/*
* 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.
*/
public
class NewInstanceExpression extends NaryExpression {
MemberDefinition field;
Expression outerArg;
ClassDefinition body;
// Access method for constructor, if needed.
MemberDefinition implMethod = null;
/**
* 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.
*/
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
*/
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.
* @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
*/
public Vset check(Environment env, Context ctx, Vset vset, Hashtable exp) {
return checkValue(env, ctx, vset, exp);
}
/**
* 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
*/
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));
}
}