/*
* 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.*;
import java.io.PrintStream;
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 FieldExpression extends UnaryExpression {
Identifier id;
MemberDefinition field;
Expression implementation;
// The class from which the field is select ed.
ClassDefinition clazz;
// For an expression of the form '<class>.super', then
// this is <class>, else null.
private ClassDefinition superBase;
/**
* constructor
*/
public FieldExpression(long where, Expression right, Identifier id) {
super(FIELD, where, Type.tError, right);
this.id = id;
}
public FieldExpression(long where, Expression right, MemberDefinition field) {
super(FIELD, where, field.getType(), right);
this.id = field.getName();
this.field = field;
}
public Expression getImplementation() {
if (implementation != null)
return implementation;
return this;
}
/**
* Return true if the field is being selected from
* a qualified 'super'.
*/
private boolean isQualSuper() {
return superBase != null;
}
/**
* Convert an '.' expression to a qualified identifier
*/
static public Identifier toIdentifier(Expression e) {
StringBuffer buf = new StringBuffer();
while (e.op == FIELD) {
FieldExpression fe = (FieldExpression)e;
if (fe.id == idThis || fe.id == idClass) {
return null;
}
buf.insert(0, fe.id);
buf.insert(0, '.');
e = fe.right;
}
if (e.op != IDENT) {
return null;
}
buf.insert(0, ((IdentifierExpression)e).id);
return Identifier.lookup(buf.toString());
}
/**
* Convert a qualified name into a type.
* Performs a careful check of each inner-class component,
* including the JLS 6.6.1 access checks that were omitted
* in 'FieldExpression.toType'.
* <p>
* This code is similar to 'checkCommon', which could be cleaned
* up a bit long the lines we have done here.
*/
/*-------------------------------------------------------*
Type toQualifiedType(Environment env, Context ctx) {
ClassDefinition ctxClass = ctx.field.getClassDefinition();
Type rty = right.toQualifiedType(env, ctx);
if (rty == Type.tPackage) {
// Is this field expression a non-inner type?
Identifier nm = toIdentifier(this);
if ((nm != null) && env.classExists(nm)) {
Type t = Type.tClass(nm);
if (env.resolve(where, ctxClass, t)) {
return t;
} else {
return null;
}
}
// Not a type. Must be a package prefix.
return Type.tPackage;
}
if (rty == null) {
// An error was already reported, so quit.
return null;
}
// Check inner-class qualification while unwinding from recursion.
try {
ClassDefinition rightClass = env.getClassDefinition(rty);
// Local variables, which cannot be inner classes,
// are ignored here, and thus will not hide inner
// classes. Is this correct?
MemberDefinition field = rightClass.getInnerClass(env, id);
if (field == null) {
env.error(where, "inner.class.expected", id, rightClass);
return Type.tError;
}
ClassDefinition innerClass = field.getInnerClass();
Type t = innerClass.getType();
if (!ctxClass.canAccess(env, field)) {
env.error(where, "no.type.access", id, rightClass, ctxClass);
return t;
}
if (field.isProtected()
&& !ctxClass.protectedAccess(env, field, rty)) {
env.error(where, "invalid.protected.type.use", id, ctxClass, rty);
return t;
}
// These were ommitted earlier in calls to 'toType', but I can't
// see any reason for that. I think it was an oversight. See
// 'checkCommon' and 'checkInnerClass'.
innerClass.noteUsedBy(ctxClass, where, env);
ctxClass.addDependency(field.getClassDeclaration());
return t;
} catch (ClassNotFound e) {
env.error(where, "class.not.found", e.name, ctx.field);
}
// Class not found.
return null;
}
*-------------------------------------------------------*/
/**
* Convert an '.' expression to a type
*/
// This is a rewrite to treat qualified names in a
// context in which a type name is expected in the
// same way that they are handled for an ambiguous
// or expression-expected context in 'checkCommon'
// below. The new code is cleaner and allows better
// localization of errors. Unfortunately, most
// qualified names appearing in types are actually
// handled by 'Environment.resolve'. There isn't
// much point, then, in breaking out 'toType' as a
// special case until the other cases can be cleaned
// up as well. For the time being, we will leave this
// code disabled, thus reducing the testing requirements.
/*-------------------------------------------------------*
Type toType(Environment env, Context ctx) {
Type t = toQualifiedType(env, ctx);
if (t == null) {
return Type.tError;
}
if (t == Type.tPackage) {
FieldExpression.reportFailedPackagePrefix(env, right, true);
return Type.tError;
}
return t;
}
*-------------------------------------------------------*/
Type toType(Environment env, Context ctx) {
Identifier id = toIdentifier(this);
if (id == null) {
env.error(where, "invalid.type.expr");
return Type.tError;
}
Type t = Type.tClass(ctx.resolveName(env, id));
if (env.resolve(where, ctx.field.getClassDefinition(), t)) {
return t;
}
return Type.tError;
}
/**
* Check if the present name is part of a scoping prefix.
*/
public Vset checkAmbigName(Environment env, Context ctx,
Vset vset, Hashtable exp,
UnaryExpression loc) {
if (id == idThis || id == idClass) {
loc = null; // this cannot be a type or package
}
return checkCommon(env, ctx, vset, exp, loc, false);
}
/**
* Check the expression
*/
public Vset checkValue(Environment env, Context ctx,
Vset vset, Hashtable exp) {
vset = checkCommon(env, ctx, vset, exp, null, false);
if (id == idSuper && type != Type.tError) {
// "super" is not allowed in this context.
// It must always qualify another name.
env.error(where, "undef.var.super", idSuper);
}
return vset;
}
/**
* If 'checkAmbiguousName' returns 'Package.tPackage', then it was
* unable to resolve any prefix of the qualified name. This method
* attempts to diagnose the problem.
*/
static void reportFailedPackagePrefix(Environment env, Expression right) {
reportFailedPackagePrefix(env, right, false);
}
static void reportFailedPackagePrefix(Environment env,
Expression right,
boolean mustBeType) {
// Find the leftmost component, and put the blame on it.
Expression idp = right;
while (idp instanceof UnaryExpression)
idp = ((UnaryExpression)idp).right;
IdentifierExpression ie = (IdentifierExpression)idp;
// It may be that 'ie' refers to an ambiguous class. Check this
// with a call to env.resolve(). Part of solution for 4059855.
try {
env.resolve(ie.id);
} catch (AmbiguousClass e) {
env.error(right.where, "ambig.class", e.name1, e.name2);
return;
} catch (ClassNotFound e) {
}
if (idp == right) {
if (mustBeType) {
env.error(ie.where, "undef.class", ie.id);
} else {
env.error(ie.where, "undef.var.or.class", ie.id);
}
} else {
if (mustBeType) {
env.error(ie.where, "undef.class.or.package", ie.id);
} else {
env.error(ie.where, "undef.var.class.or.package", ie.id);
}
}
}
/**
* Rewrite accesses to private fields of another class.
*/
private Expression
implementFieldAccess(Environment env, Context ctx, Expression base, boolean isLHS) {
ClassDefinition abase = accessBase(env, ctx);
if (abase != null) {
// If the field is final and its initializer is a constant expression,
// then just rewrite to the constant expression. This is not just an
// optimization, but is required for correctness. If an expression is
// rewritten to use an access method, then its status as a constant
// expression is lost. This was the cause of bug 4098737. Note that
// a call to 'getValue(env)' below would not be correct, as it attempts
// to simplify the initial value expression, which must not occur until
// after the checking phase, for example, after definite assignment checks.
if (field.isFinal()) {
Expression e = (Expression)field.getValue();
// Must not be LHS here. Test as a precaution,
// as we may not be careful to avoid this when
// compiling an erroneous program.
if ((e != null) && e.isConstant() && !isLHS) {
return e.copyInline(ctx);
}
}
//System.out.println("Finding access method for " + field);
MemberDefinition af = abase.getAccessMember(env, ctx, field, isQualSuper());
//System.out.println("Using access method " + af);
if (!isLHS) {
//System.out.println("Reading " + field +
// " via access method " + af);
// If referencing the value of the field, then replace
// with a call to the access method. If assigning to
// the field, a call to the update method will be
// generated later. It is important that
// 'implementation' not be set to non-null if the
// expression is a valid assignment target.
// (See 'checkLHS'.)
if (field.isStatic()) {
Expression args[] = { };
Expression call =
new MethodExpression(where, null, af, args);
return new CommaExpression(where, base, call);
} else {
Expression args[] = { base };
return new MethodExpression(where, null, af, args);
}
}
}
return null;
}
/**
* Determine if an access method is required, and, if so, return
* the class in which it should appear, else return null.
*/
private ClassDefinition accessBase(Environment env, Context ctx) {
if (field.isPrivate()) {
ClassDefinition cdef = field.getClassDefinition();
ClassDefinition ctxClass = ctx.field.getClassDefinition();
if (cdef == ctxClass){
// If access from same class as field, then no access
// method is needed.
return null;
}
// An access method is needed in the class containing the field.
return cdef;
} else if (field.isProtected()) {
if (superBase == null) {
// If access is not via qualified super, then it is either
// OK without an access method, or it is an illegal access
// for which an error message should have been issued.
// Legal accesses include unqualified 'super.foo'.
return null;
}
ClassDefinition cdef = field.getClassDefinition();
ClassDefinition ctxClass = ctx.field.getClassDefinition();
if (cdef.inSamePackage(ctxClass)) {
// Access to protected member in same package always allowed.
return null;
}
// Access via qualified super.
// An access method is needed in the qualifying class, an
// immediate subclass of the class containing the selected
// field. NOTE: The fact that the returned class is 'superBase'
// carries the additional bit of information (that a special
// superclass access method is being created) which is provided
// to 'getAccessMember' via its 'isSuper' argument.
return superBase;
} else {
// No access method needed.
return null;
}
}
/**
* Determine if a type is accessible from a given class.
*/
static boolean isTypeAccessible(long where,
Environment env,
Type t,
ClassDefinition c) {
switch (t.getTypeCode()) {
case TC_CLASS:
try {
Identifier nm = t.getClassName();
// Why not just use 'Environment.getClassDeclaration' here?
// But 'Environment.getClassDeclation' has special treatment
// for local classes that is probably necessary. This code
// was adapted from 'Environment.resolve'.
ClassDefinition def = env.getClassDefinition(t);
return c.canAccess(env, def.getClassDeclaration());
} catch (ClassNotFound e) {} // Ignore -- reported elsewhere.
return true;
case TC_ARRAY:
return isTypeAccessible(where, env, t.getElementType(), c);
default:
return true;
}
}
/**
* Common code for checkValue and checkAmbigName
*/
private Vset checkCommon(Environment env, Context ctx,
Vset vset, Hashtable exp,
UnaryExpression loc, boolean isLHS) {
// Handle class literal, e.g., 'x.class'.
if (id == idClass) {
// In 'x.class', 'x' must be a type name, possibly qualified.
Type t = right.toType(env, ctx);
if (!t.isType(TC_CLASS) && !t.isType(TC_ARRAY)) {
if (t.isType(TC_ERROR)) {
type = Type.tClassDesc;
return vset;
}
String wrc = null;
switch (t.getTypeCode()) {
case TC_VOID: wrc = "Void"; break;
case TC_BOOLEAN: wrc = "Boolean"; break;
case TC_BYTE: wrc = "Byte"; break;
case TC_CHAR: wrc = "Character"; break;
case TC_SHORT: wrc = "Short"; break;
case TC_INT: wrc = "Integer"; break;
case TC_FLOAT: wrc = "Float"; break;
case TC_LONG: wrc = "Long"; break;
case TC_DOUBLE: wrc = "Double"; break;
default:
env.error(right.where, "invalid.type.expr");
return vset;
}
Identifier wid = Identifier.lookup(idJavaLang+"."+wrc);
Expression wcls = new TypeExpression(where, Type.tClass(wid));
implementation = new FieldExpression(where, wcls, idTYPE);
vset = implementation.checkValue(env, ctx, vset, exp);
type = implementation.type; // java.lang.Class
return vset;
}
// Check for the bogus type `array of void'
if (t.isVoidArray()) {
type = Type.tClassDesc;
env.error(right.where, "void.array");
return vset;
}
// it is a class or array
long fwhere = ctx.field.getWhere();
ClassDefinition fcls = ctx.field.getClassDefinition();
MemberDefinition lookup = fcls.getClassLiteralLookup(fwhere);
String sig = t.getTypeSignature();
String className;
if (t.isType(TC_CLASS)) {
// sig is like "Lfoo/bar;", name is like "foo.bar".
// We assume SIG_CLASS and SIG_ENDCLASS are 1 char each.
className = sig.substring(1, sig.length()-1)
.replace(SIGC_PACKAGE, '.');
} else {
// sig is like "[Lfoo/bar;" or "[I";
// name is like "[Lfoo.bar" or (again) "[I".
className = sig.replace(SIGC_PACKAGE, '.');
}
if (fcls.isInterface()) {
// The immediately-enclosing type is an interface.
// The class literal can only appear in an initialization
// expression, so don't bother caching it. (This could
// lose if many initializations use the same class literal,
// but saves time and code space otherwise.)
implementation =
makeClassLiteralInlineRef(env, ctx, lookup, className);
} else {
// Cache the call to the helper, as it may be executed
// many times (e.g., if the class literal is inside a loop).
ClassDefinition inClass = lookup.getClassDefinition();
MemberDefinition cfld =
getClassLiteralCache(env, ctx, className, inClass);
implementation =
makeClassLiteralCacheRef(env, ctx, lookup, cfld, className);
}
vset = implementation.checkValue(env, ctx, vset, exp);
type = implementation.type; // java.lang.Class
return vset;
}
// Arrive here if not a class literal.
if (field != null) {
// The field as been pre-set, e.g., as the result of transforming
// an 'IdentifierExpression'. Most error-checking has already been
// performed at this point.
// QUERY: Why don't we further unify checking of identifier
// expressions and field expressions that denote instance and
// class variables?
implementation = implementFieldAccess(env, ctx, right, isLHS);
return (right == null) ?
vset : right.checkAmbigName(env, ctx, vset, exp, this);
}
// Does the qualifier have a meaning of its own?
vset = right.checkAmbigName(env, ctx, vset, exp, this);
if (right.type == Type.tPackage) {
// Are we out of options?
if (loc == null) {
FieldExpression.reportFailedPackagePrefix(env, right);
return vset;
}
// ASSERT(loc.right == this)
// Nope. Is this field expression a type?
Identifier nm = toIdentifier(this);
if ((nm != null) && env.classExists(nm)) {
loc.right = new TypeExpression(where, Type.tClass(nm));
// Check access. (Cf. IdentifierExpression.toResolvedType.)
ClassDefinition ctxClass = ctx.field.getClassDefinition();
env.resolve(where, ctxClass, loc.right.type);
return vset;
}
// Let the caller make sense of it, then.
type = Type.tPackage;
return vset;
}
// Good; we have a well-defined qualifier type.
ClassDefinition ctxClass = ctx.field.getClassDefinition();
boolean staticRef = (right instanceof TypeExpression);
try {
// Handle array 'length' field, e.g., 'x.length'.
if (!right.type.isType(TC_CLASS)) {
if (right.type.isType(TC_ARRAY) && id.equals(idLength)) {
// Verify that the type of the base expression is accessible.
// Required by JLS 6.6.1. Fixes 4094658.
if (!FieldExpression.isTypeAccessible(where, env, right.type, ctxClass)) {
ClassDeclaration cdecl = ctxClass.getClassDeclaration();
if (staticRef) {
env.error(where, "no.type.access",
id, right.type.toString(), cdecl);
} else {
env.error(where, "cant.access.member.type",
id, right.type.toString(), cdecl);
}
}
type = Type.tInt;
implementation = new LengthExpression(where, right);
return vset;
}
if (!right.type.isType(TC_ERROR)) {
env.error(where, "invalid.field.reference", id, right.type);
}
return vset;
}
// At this point, we know that 'right.type' is a class type.
// Note that '<expr>.super(...)' and '<expr>.this(...)' cases never
// reach here. Instead, '<expr>' is stored as the 'outerArg' field
// of a 'SuperExpression' or 'ThisExpression' node.
// If our prefix is of the form '<class>.super', then we are
// about to do a field selection '<class>.super.<field>'.
// Save the qualifying class in 'superBase', which is non-null
// only if the current FieldExpression is a qualified 'super' form.
// Also, set 'sourceClass' to the "effective accessing class" relative
// to which access checks will be performed. Normally, this is the
// immediately enclosing class. For '<class>.this' and '<class>.super',
// however, we use <class>.
ClassDefinition sourceClass = ctxClass;
if (right instanceof FieldExpression) {
Identifier id = ((FieldExpression)right).id;
if (id == idThis) {
sourceClass = ((FieldExpression)right).clazz;
} else if (id == idSuper) {
sourceClass = ((FieldExpression)right).clazz;
superBase = sourceClass;
}
}
// Handle 'class.this' and 'class.super'.
//
// Suppose 'super.name' appears within a class C with immediate
// superclass S. According to JLS 15.10.2, 'super.name' in this
// case is equivalent to '((S)this).name'. Analogously, we interpret
// 'class.super.name' as '((S)(class.this)).name', where S is the
// immediate superclass of (enclosing) class 'class'.
// Note that 'super' may not stand alone as an expression, but must
// occur as the qualifying expression of a field access or a method
// invocation. This is enforced in 'SuperExpression.checkValue' and
// 'FieldExpression.checkValue', and need not concern us here.
//ClassDefinition clazz = env.getClassDefinition(right.type);
clazz = env.getClassDefinition(right.type);
if (id == idThis || id == idSuper) {
if (!staticRef) {
env.error(right.where, "invalid.type.expr");
}
// We used to check that 'right.type' is accessible here,
// per JLS 6.6.1. As a result of the fix for 4102393, however,
// the qualifying class name must exactly match an enclosing
// outer class, which is necessarily accessible.
/*** Temporary assertion check ***/
if (ctx.field.isSynthetic())
throw new CompilerError("synthetic qualified this");
/*********************************/
// A.this means we're inside an A and we want its self ptr.
// C.this is always the same as this when C is innermost.
// Another A.this means we skip out to get a "hidden" this,
// just as ASuper.foo skips out to get a hidden variable.
// Last argument 'true' means we want an exact class match,
// not a subclass of the specified class ('clazz').
implementation = ctx.findOuterLink(env, where, clazz, null, true);
vset = implementation.checkValue(env, ctx, vset, exp);
if (id == idSuper) {
type = clazz.getSuperClass().getType();
} else {
type = clazz.getType();
}
return vset;
}
// Field should be an instance variable or class variable.
field = clazz.getVariable(env, id, sourceClass);
if (field == null && staticRef && loc != null) {
// Is this field expression an inner type?
// Search the class and its supers (but not its outers).
// QUERY: We may need to get the inner class from a
// superclass of 'clazz'. This call is prepared to
// resolve the superclass if necessary. Can we arrange
// to assure that it is always previously resolved?
// This is one of a small number of problematic calls that
// requires 'getSuperClass' to resolve superclasses on demand.
// See 'ClassDefinition.getInnerClass(env, nm)'.
field = clazz.getInnerClass(env, id);
if (field != null) {
return checkInnerClass(env, ctx, vset, exp, loc);
}
}
// If not a variable reference, diagnose error if name is
// that of a method.
if (field == null) {
if ((field = clazz.findAnyMethod(env, id)) != null) {
env.error(where, "invalid.field",
id, field.getClassDeclaration());
} else {
env.error(where, "no.such.field", id, clazz);
}
return vset;
}
// At this point, we have identified a valid field.
// Required by JLS 6.6.1. Fixes 4094658.
if (!FieldExpression.isTypeAccessible(where, env, right.type, sourceClass)) {
ClassDeclaration cdecl = sourceClass.getClassDeclaration();
if (staticRef) {
env.error(where, "no.type.access",
id, right.type.toString(), cdecl);
} else {
env.error(where, "cant.access.member.type",
id, right.type.toString(), cdecl);
}
}
type = field.getType();
if (!sourceClass.canAccess(env, field)) {
env.error(where, "no.field.access",
id, clazz, sourceClass.getClassDeclaration());
return vset;
}
if (staticRef && !field.isStatic()) {
// 'Class.field' is not legal when field is not static;
// see JLS 15.13.1. This case was permitted by javac
// prior to 1.2; static refs were silently changed to
// be dynamic access of the form 'this.field'.
env.error(where, "no.static.field.access", id, clazz);
return vset;
} else {
// Rewrite access to use an access method if necessary.
implementation = implementFieldAccess(env, ctx, right, isLHS);
}
// Check for invalid access to protected field.
if (field.isProtected()
&& !(right instanceof SuperExpression
// Extension of JLS 6.6.2 for qualified 'super'.
|| (right instanceof FieldExpression &&
((FieldExpression)right).id == idSuper))
&& !sourceClass.protectedAccess(env, field, right.type)) {
env.error(where, "invalid.protected.field.use",
field.getName(), field.getClassDeclaration(),
right.type);
return vset;
}
if ((!field.isStatic()) &&
(right.op == THIS) && !vset.testVar(ctx.getThisNumber())) {
env.error(where, "access.inst.before.super", id);
}
if (field.reportDeprecated(env)) {
env.error(where, "warn."+"field.is.deprecated",
id, field.getClassDefinition());
}
// When a package-private class defines public or protected
// members, those members may sometimes be accessed from
// outside of the package in public subclasses. In these
// cases, we need to massage the getField to refer to
// to an accessible subclass rather than the package-private
// parent class. Part of fix for 4135692.
// Find out if the class which contains this field
// reference has access to the class which declares the
// public or protected field.
if (sourceClass == ctxClass) {
ClassDefinition declarer = field.getClassDefinition();
if (declarer.isPackagePrivate() &&
!declarer.getName().getQualifier()
.equals(sourceClass.getName().getQualifier())) {
//System.out.println("The access of member " +
// field + " declared in class " +
// declarer +
// " is not allowed by the VM from class " +
// ctxClass +
// ". Replacing with an access of class " +
// clazz);
// We cannot make this access at the VM level.
// Construct a member which will stand for this
// field in ctxClass and set `field' to refer to it.
field =
MemberDefinition.makeProxyMember(field, clazz, env);
}
}
sourceClass.addDependency(field.getClassDeclaration());
} catch (ClassNotFound e) {
env.error(where, "class.not.found", e.name, ctx.field);
} catch (AmbiguousMember e) {
env.error(where, "ambig.field",
id, e.field1.getClassDeclaration(), e.field2.getClassDeclaration());
}
return vset;
}
/**
* Return a <code>FieldUpdater</code> object to be used in updating the
* value of the location denoted by <code>this</code>, which must be an
* expression suitable for the left-hand side of an assignment.
* This is used for implementing assignments to private fields for which
* an access method is required. Returns null if no access method is
* needed, in which case the assignment is handled in the usual way, by
* direct access. Only simple assignment expressions are handled here
* Assignment operators and pre/post increment/decrement operators are
* are handled by 'getUpdater' below.
* <p>
* Must be called after 'checkValue', else 'right' will be invalid.
*/
public FieldUpdater getAssigner(Environment env, Context ctx) {
if (field == null) {
// Field can legitimately be null if the field name was
// undefined, in which case an error was reported, but
// no value for 'field' is available.
// throw new CompilerError("getAssigner");
return null;
}
ClassDefinition abase = accessBase(env, ctx);
if (abase != null) {
MemberDefinition setter = abase.getUpdateMember(env, ctx, field, isQualSuper());
// It may not be necessary to copy 'right' here.
Expression base = (right == null) ? null : right.copyInline(ctx);
// Created 'FieldUpdater' has no getter method.
return new FieldUpdater(where, field, base, null, setter);
}
return null;
}
/**
* Return a <code>FieldUpdater</code> object to be used in updating the
* value of the location denoted by <code>this</code>, which must be an
* expression suitable for the left-hand side of an assignment. This is
* used for implementing the assignment operators and the increment and
* decrement operators on private fields that are accessed from another
* class, e.g, uplevel from an inner class. Returns null if no access
* method is needed.
* <p>
* Must be called after 'checkValue', else 'right' will be invalid.
*/
public FieldUpdater getUpdater(Environment env, Context ctx) {
if (field == null) {
// Field can legitimately be null if the field name was
// undefined, in which case an error was reported, but
// no value for 'field' is available.
// throw new CompilerError("getUpdater");
return null;
}
ClassDefinition abase = accessBase(env, ctx);
if (abase != null) {
MemberDefinition getter = abase.getAccessMember(env, ctx, field, isQualSuper());
MemberDefinition setter = abase.getUpdateMember(env, ctx, field, isQualSuper());
// It may not be necessary to copy 'right' here.
Expression base = (right == null) ? null : right.copyInline(ctx);
return new FieldUpdater(where, field, base, getter, setter);
}
return null;
}
/**
* This field expression is an inner class reference.
* Finish checking it.
*/
private Vset checkInnerClass(Environment env, Context ctx,
Vset vset, Hashtable exp,
UnaryExpression loc) {
ClassDefinition inner = field.getInnerClass();
type = inner.getType();
if (!inner.isTopLevel()) {
env.error(where, "inner.static.ref", inner.getName());
}
Expression te = new TypeExpression(where, type);
// check access
ClassDefinition ctxClass = ctx.field.getClassDefinition();
try {
if (!ctxClass.canAccess(env, field)) {
ClassDefinition clazz = env.getClassDefinition(right.type);
//env.error(where, "no.type.access",
// id, clazz, ctx.field.getClassDeclaration());
env.error(where, "no.type.access",
id, clazz, ctxClass.getClassDeclaration());
return vset;
}
if (field.isProtected()
&& !(right instanceof SuperExpression
// Extension of JLS 6.6.2 for qualified 'super'.
|| (right instanceof FieldExpression &&
((FieldExpression)right).id == idSuper))
&& !ctxClass.protectedAccess(env, field, right.type)){
env.error(where, "invalid.protected.field.use",
field.getName(), field.getClassDeclaration(),
right.type);
return vset;
}
inner.noteUsedBy(ctxClass, where, env);
} catch (ClassNotFound e) {
env.error(where, "class.not.found", e.name, ctx.field);
}
ctxClass.addDependency(field.getClassDeclaration());
if (loc == null)
// Complain about a free-floating type name.
return te.checkValue(env, ctx, vset, exp);
loc.right = te;
return vset;
}
/**
* Check the expression if it appears on the LHS of an assignment
*/
public Vset checkLHS(Environment env, Context ctx,
Vset vset, Hashtable exp) {
boolean hadField = (field != null);
//checkValue(env, ctx, vset, exp);
checkCommon(env, ctx, vset, exp, null, true);
// If 'implementation' is set to a non-null value, then the
// field expression does not denote an assignable location,
// e.g., the 'length' field of an array.
if (implementation != null) {
// This just reports an error and recovers.
return super.checkLHS(env, ctx, vset, exp);
}
if (field != null && field.isFinal() && !hadField) {
if (field.isBlankFinal()) {
if (field.isStatic()) {
if (right != null) {
env.error(where, "qualified.static.final.assign");
}
// Continue with checking anyhow.
// In fact, it would be easy to allow this case.
} else {
if ((right != null) && (right.op != THIS)) {
env.error(where, "bad.qualified.final.assign", field.getName());
// The actual instance could be anywhere, so don't
// continue with checking the definite assignment status.
return vset;
}
}
vset = checkFinalAssign(env, ctx, vset, where, field);
} else {
env.error(where, "assign.to.final", id);
}
}
return vset;
}
/**
* Check the expression if it appears on the LHS of an op= expression
*/
public Vset checkAssignOp(Environment env, Context ctx,
Vset vset, Hashtable exp, Expression outside) {
//checkValue(env, ctx, vset, exp);
checkCommon(env, ctx, vset, exp, null, true);
// If 'implementation' is set to a non-null value, then the
// field expression does not denote an assignable location,
// e.g., the 'length' field of an array.
if (implementation != null) {
return super.checkLHS(env, ctx, vset, exp);
}
if (field != null && field.isFinal()) {
env.error(where, "assign.to.final", id);
}
return vset;
}
/**
* There is a simple assignment being made to the given final field.
* The field was named either by a simple name or by an almost-simple
* expression of the form "this.v".
* Check if this is a legal assignment.
* <p>
* Blank final variables can be set in initializers or constructor
* bodies. In all cases there must be definite single assignment.
* (All instance and instance variable initializers and each
* constructor body are treated as if concatenated for the purposes
* of this check. Assignment to "this.x" is treated as a definite
* assignment to the simple name "x" which names the instance variable.)
*/
public static Vset checkFinalAssign(Environment env, Context ctx,
Vset vset, long where,
MemberDefinition field) {
if (field.isBlankFinal()
&& field.getClassDefinition() == ctx.field.getClassDefinition()) {
int number = ctx.getFieldNumber(field);
if (number >= 0 && vset.testVarUnassigned(number)) {
// definite single assignment
vset = vset.addVar(number);
} else {
// it is a blank final in this class, but not assignable
Identifier id = field.getName();
env.error(where, "assign.to.blank.final", id);
}
} else {
// give the generic error message
Identifier id = field.getName();
env.error(where, "assign.to.final", id);
}
return vset;
}
private static MemberDefinition getClassLiteralCache(Environment env,
Context ctx,
String className,
ClassDefinition c) {
// Given a class name, look for a static field to cache it.
// className lname
// pkg.Foo class$pkg$Foo
// [Lpkg.Foo; array$Lpkg$Foo
// [[Lpkg.Foo; array$$Lpkg$Foo
// [I array$I
// [[I array$$I
String lname;
if (!className.startsWith(SIG_ARRAY)) {
lname = prefixClass + className.replace('.', '$');
} else {
lname = prefixArray + className.substring(1);
lname = lname.replace(SIGC_ARRAY, '$'); // [[[I => array$$$I
if (className.endsWith(SIG_ENDCLASS)) {
// [Lpkg.Foo; => array$Lpkg$Foo
lname = lname.substring(0, lname.length() - 1);
lname = lname.replace('.', '$');
}
// else [I => array$I or some such; lname is already OK
}
Identifier fname = Identifier.lookup(lname);
// The class to put the cache in is now given as an argument.
//
// ClassDefinition c = ctx.field.getClassDefinition();
// while (c.isInnerClass()) {
// c = c.getOuterClass();
MemberDefinition cfld;
try {
cfld = c.getVariable(env, fname, c);
} catch (ClassNotFound ee) {
return null;
} catch (AmbiguousMember ee) {
return null;
}
// Ignore inherited field. Each top-level class
// containing a given class literal must have its own copy,
// both for reasons of binary compatibility and to prevent
// access violations should the superclass be in another
// package. Part of fix 4106051.
if (cfld != null && cfld.getClassDefinition() == c) {
return cfld;
}
// Since each class now has its own copy, we might as well
// tighten up the access to private (previously default).
// Part of fix for 4106051.
// ** Temporarily retract this, as it tickles 4098316.
return env.makeMemberDefinition(env, c.getWhere(),
c, null,
M_STATIC | M_SYNTHETIC, // M_PRIVATE,
Type.tClassDesc, fname,
null, null, null);
}
private Expression makeClassLiteralCacheRef(Environment env, Context ctx,
MemberDefinition lookup,
MemberDefinition cfld,
String className) {
Expression ccls = new TypeExpression(where,
cfld.getClassDefinition()
.getType());
Expression cache = new FieldExpression(where, ccls, cfld);
Expression cacheOK =
new NotEqualExpression(where, cache.copyInline(ctx),
new NullExpression(where));
Expression lcls =
new TypeExpression(where, lookup.getClassDefinition() .getType());
Expression name = new StringExpression(where, className);
Expression namearg[] = { name };
Expression setCache = new MethodExpression(where, lcls,
lookup, namearg);
setCache = new AssignExpression(where, cache.copyInline(ctx),
setCache);
return new ConditionalExpression(where, cacheOK, cache, setCache);
}
private Expression makeClassLiteralInlineRef(Environment env, Context ctx,
MemberDefinition lookup,
String className) {
Expression lcls =
new TypeExpression(where, lookup.getClassDefinition().getType());
Expression name = new StringExpression(where, className);
Expression namearg[] = { name };
Expression getClass = new MethodExpression(where, lcls,
lookup, namearg);
return getClass;
}
/**
* Check if constant: Will it inline away?
*/
public boolean isConstant() {
if (implementation != null)
return implementation.isConstant();
if ((field != null)
&& (right == null || right instanceof TypeExpression
|| (right.op == THIS && right.where == where))) {
return field.isConstant();
}
return false;
}
/**
* Inline
*/
public Expression inline(Environment env, Context ctx) {
if (implementation != null)
return implementation.inline(env, ctx);
// A field expression may have the side effect of causing
// a NullPointerException, so evaluate it even though
// the value is not needed. Similarly, static field dereferences
// may cause class initialization, so they mustn't be omitted
// either.
//
// However, NullPointerException can't happen and initialization must
// already have occured if you are dotting into 'this'. So
// allow fields of 'this' to be eliminated as a special case.
Expression e = inlineValue(env, ctx);
if (e instanceof FieldExpression) {
FieldExpression fe = (FieldExpression) e;
if ((fe.right != null) && (fe.right.op==THIS))
return null;
// It should be possible to split this into two checks: one using
// isNonNull() for non-statics and a different check for statics.
// That would make the inlining slightly less conservative by
// allowing, for example, dotting into String constants.
}
return e;
}
public Expression inlineValue(Environment env, Context ctx) {
if (implementation != null)
return implementation.inlineValue(env, ctx);
try {
if (field == null) {
return this;
}
if (field.isFinal()) {
Expression e = (Expression)field.getValue(env);
if ((e != null) && e.isConstant()) {
// remove bogus line-number info
e = e.copyInline(ctx);
e.where = where;
return new CommaExpression(where, right, e).inlineValue(env, ctx);
}
}
if (right != null) {
if (field.isStatic()) {
Expression e = right.inline(env, ctx);
right = null;
if (e != null) {
return new CommaExpression(where, e, this);
}
} else {
right = right.inlineValue(env, ctx);
}
}
return this;
} catch (ClassNotFound e) {
throw new CompilerError(e);
}
}
public Expression inlineLHS(Environment env, Context ctx) {
if (implementation != null)
return implementation.inlineLHS(env, ctx);
if (right != null) {
if (field.isStatic()) {
Expression e = right.inline(env, ctx);
right = null;
if (e != null) {
return new CommaExpression(where, e, this);
}
} else {
right = right.inlineValue(env, ctx);
}
}
return this;
}
public Expression copyInline(Context ctx) {
if (implementation != null)
return implementation.copyInline(ctx);
return super.copyInline(ctx);
}
/**
* The cost of inlining this expression
*/
public int costInline(int thresh, Environment env, Context ctx) {
if (implementation != null)
return implementation.costInline(thresh, env, ctx);
if (ctx == null) {
return 3 + ((right == null) ? 0
: right.costInline(thresh, env, ctx));
}
// ctxClass is the current class trying to inline this method
ClassDefinition ctxClass = ctx.field.getClassDefinition();
try {
// We only allow the inlining if the current class can access
// the field, the field's class, and right's declared type.
if ( ctxClass.permitInlinedAccess(env, field.getClassDeclaration())
&& ctxClass.permitInlinedAccess(env, field)) {
if (right == null) {
return 3;
} else {
ClassDeclaration rt = env.getClassDeclaration(right.type);
if (ctxClass.permitInlinedAccess(env, rt)) {
return 3 + right.costInline(thresh, env, ctx);
}
}
}
} catch (ClassNotFound e) {
}
return thresh;
}
/**
* Code
*/
int codeLValue(Environment env, Context ctx, Assembler asm) {
if (implementation != null)
throw new CompilerError("codeLValue");
if (field.isStatic()) {
if (right != null) {
right.code(env, ctx, asm);
return 1;
}
return 0;
}
right.codeValue(env, ctx, asm);
return 1;
}
void codeLoad(Environment env, Context ctx, Assembler asm) {
if (field == null) {
throw new CompilerError("should not be null");
}
if (field.isStatic()) {
asm.add(where, opc_getstatic, field);
} else {
asm.add(where, opc_getfield, field);
}
}
void codeStore(Environment env, Context ctx, Assembler asm) {
if (field.isStatic()) {
asm.add(where, opc_putstatic, field);
} else {
asm.add(where, opc_putfield, field);
}
}
public void codeValue(Environment env, Context ctx, Assembler asm) {
codeLValue(env, ctx, asm);
codeLoad(env, ctx, asm);
}
/**
* Print
*/
public void print(PrintStream out) {
out.print("(");
if (right != null) {
right.print(out);
} else {
out.print("<empty>");
}
out.print("." + id + ")");
if (implementation != null) {
out.print("/IMPL=");
implementation.print(out);
}
}
}