Back to index...

	/*
	* 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;

	/**
	* 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 Context implements Constants {
	Context prev;
	Node node;
	int varNumber;
	LocalMember locals;
	LocalMember classes;
	MemberDefinition field;
	int scopeNumber;
	int frameNumber;

	/**
	* Create the initial context for a method
	* The incoming context is inherited from
	*/
	public Context(Context ctx, MemberDefinition field) {
	this.field = field;
	if (ctx == null) {
	this.frameNumber = 1;
	this.scopeNumber = 2;
	this.varNumber = 0;
	} else {
	this.prev = ctx;
	this.locals = ctx.locals;
	this.classes = ctx.classes;
	if (field != null &&
	(field.isVariable() \|\| field.isInitializer())) {
	// Variables and initializers are inlined into a constructor.
	// Model this by inheriting the frame number of the parent,
	// which will contain a "this" parameter.
	this.frameNumber = ctx.frameNumber;
	this.scopeNumber = ctx.scopeNumber + 1;
	} else {
	this.frameNumber = ctx.scopeNumber + 1;
	this.scopeNumber = this.frameNumber + 1;
	}
	this.varNumber = ctx.varNumber;
	}
	}

	/**
	* Create a new context, for initializing a class.
	*/
	public Context(Context ctx, ClassDefinition c) {
	this(ctx, (MemberDefinition)null);
	}

	/**
	* Create a new nested context, for a block statement
	*/
	Context(Context ctx, Node node) {
	if (ctx == null) {
	this.frameNumber = 1;
	this.scopeNumber = 2;
	this.varNumber = 0;
	} else {
	this.prev = ctx;
	this.locals = ctx.locals;
	// Inherit local classes from surrounding block,
	// just as for local variables. Fixes 4074421.
	this.classes = ctx.classes;
	this.varNumber = ctx.varNumber;
	this.field = ctx.field;
	this.frameNumber = ctx.frameNumber;
	this.scopeNumber = ctx.scopeNumber + 1;
	this.node = node;
	}
	}

	public Context(Context ctx) {
	this(ctx, (Node)null);
	}

	/**
	* Declare local
	*/
	public int declare(Environment env, LocalMember local) {
	//System.out.println( "DECLARE= " + local.getName() + "=" + varNumber + ", read=" + local.readcount + ", write=" + local.writecount + ", hash=" + local.hashCode());
	local.scopeNumber = scopeNumber;
	if (this.field == null && idThis.equals(local.getName())) {
	local.scopeNumber += 1; // Anticipate variable or initializer.
	}
	if (local.isInnerClass()) {
	local.prev = classes;
	classes = local;
	return 0;
	}

	// Originally the statement:
	//
	// local.subModifiers(M_INLINEABLE);
	//
	// was here with the comment:
	//
	// // prevent inlining across call sites
	//
	// This statement prevented constant local variables from
	// inlining. It didn't seem to do anything useful.
	//
	// The statement has been removed and an assertion has been
	// added which mandates that the only members which are marked
	// with M_INLINEABLE are the ones for which isConstant() is true.
	// (Fix for 4106244.)
	//
	// Addition to the above comment: they might also be
	// final variables initialized with 'this', 'super', or other
	// final identifiers. See VarDeclarationStatement.inline().
	// So I've removed the assertion. The original subModifiers
	// call appears to have been there to fix nested class translation
	// breakage, which has been fixed in VarDeclarationStatement
	// now instead. (Fix for 4073244.)

	local.prev = locals;
	locals = local;
	local.number = varNumber;
	varNumber += local.getType().stackSize();
	return local.number;
	}

	/**
	* Get a local variable by name
	*/
	public
	LocalMember getLocalField(Identifier name) {
	for (LocalMember f = locals ; f != null ; f = f.prev) {
	if (name.equals(f.getName())) {
	return f;
	}
	}
	return null;
	}

	/**
	* Get the scope number for a reference to a member of this class
	* (Larger scope numbers are more deeply nested.)
	* @see LocalMember#scopeNumber
	*/
	public
	int getScopeNumber(ClassDefinition c) {
	for (Context ctx = this; ctx != null; ctx = ctx.prev) {
	if (ctx.field == null) continue;
	if (ctx.field.getClassDefinition() == c) {
	return ctx.frameNumber;
	}
	}
	return -1;
	}

	private
	MemberDefinition getFieldCommon(Environment env, Identifier name,
	boolean apparentOnly) throws AmbiguousMember, ClassNotFound {
	// Note: This is structured as a pair of parallel lookups.
	// If we were to redesign Context, we might prefer to walk
	// along a single chain of scopes.

	LocalMember lf = getLocalField(name);
	int ls = (lf == null) ? -2 : lf.scopeNumber;

	ClassDefinition thisClass = field.getClassDefinition();

	// Also look for a class member in a shallower scope.
	for (ClassDefinition c = thisClass;
	c != null;
	c = c.getOuterClass()) {
	MemberDefinition f = c.getVariable(env, name, thisClass);
	if (f != null && getScopeNumber(c) > ls) {
	if (apparentOnly && f.getClassDefinition() != c) {
	continue;
	}
	return f;
	}
	}

	return lf;
	}

	/**
	* Assign a number to a class field.
	* (This is used to track definite assignment of some blank finals.)
	*/
	public int declareFieldNumber(MemberDefinition field) {
	return declare(null, new LocalMember(field));
	}

	/**
	* Retrieve a number previously assigned by declareMember().
	* Return -1 if there was no such assignment in this context.
	*/
	public int getFieldNumber(MemberDefinition field) {
	for (LocalMember f = locals ; f != null ; f = f.prev) {
	if (f.getMember() == field) {
	return f.number;
	}
	}
	return -1;
	}

	/**
	* Return the local field or member field corresponding to a number.
	* Return null if there is no such field.
	*/
	public MemberDefinition getElement(int number) {
	for (LocalMember f = locals ; f != null ; f = f.prev) {
	if (f.number == number) {
	MemberDefinition field = f.getMember();
	return (field != null) ? field : f;
	}
	}
	return null;
	}

	/**
	* Get a local class by name
	*/
	public
	LocalMember getLocalClass(Identifier name) {
	for (LocalMember f = classes ; f != null ; f = f.prev) {
	if (name.equals(f.getName())) {
	return f;
	}
	}
	return null;
	}

	private
	MemberDefinition getClassCommon(Environment env, Identifier name,
	boolean apparentOnly) throws ClassNotFound {
	LocalMember lf = getLocalClass(name);
	int ls = (lf == null) ? -2 : lf.scopeNumber;

	// Also look for a class member in a shallower scope.
	for (ClassDefinition c = field.getClassDefinition();
	c != null;
	c = c.getOuterClass()) {
	// QUERY: We may need to get the inner class from a
	// superclass of 'c'. 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)'.
	MemberDefinition f = c.getInnerClass(env, name);
	if (f != null && getScopeNumber(c) > ls) {
	if (apparentOnly && f.getClassDefinition() != c) {
	continue;
	}
	return f;
	}
	}

	return lf;
	}

	/**
	* Get either a local variable, or a field in a current class
	*/
	public final
	MemberDefinition getField(Environment env, Identifier name) throws AmbiguousMember, ClassNotFound {
	return getFieldCommon(env, name, false);
	}

	/**
	* Like getField, except that it skips over inherited fields.
	* Used for error checking.
	*/
	public final
	MemberDefinition getApparentField(Environment env, Identifier name) throws AmbiguousMember, ClassNotFound {
	return getFieldCommon(env, name, true);
	}

	/**
	* Check if the given field is active in this context.
	*/
	public boolean isInScope(LocalMember field) {
	for (LocalMember f = locals ; f != null ; f = f.prev) {
	if (field == f) {
	return true;
	}
	}
	return false;
	}

	/**
	* Notice a reference (usually an uplevel one).
	* Update the references list of every enclosing class
	* which is enclosed by the scope of the target.
	* Update decisions about which uplevels to make into fields.
	* Return the uplevel reference descriptor, or null if it's local.
	* <p>
	* The target must be in scope in this context.
	* So, call this method only from the check phase.
	* (In other phases, the context may be less complete.)
	* <p>
	* This can and should be called both before and after classes are frozen.
	* It should be a no-op, and will raise a compiler error if not.
	*/
	public UplevelReference noteReference(Environment env, LocalMember target) {
	int targetScopeNumber = !isInScope(target) ? -1 : target.scopeNumber;

	// Walk outward visiting each scope.
	// Note each distinct frame (i.e., enclosing method).
	// For each frame in which the variable is uplevel,
	// record the event in the references list of the enclosing class.
	UplevelReference res = null;
	int currentFrameNumber = -1;
	for (Context refctx = this; refctx != null; refctx = refctx.prev) {
	if (currentFrameNumber == refctx.frameNumber) {
	continue; // we're processing frames, not contexts
	}
	currentFrameNumber = refctx.frameNumber;
	if (targetScopeNumber >= currentFrameNumber) {
	break; // the target is native to this frame
	}

	// process a frame which is using this variable as an uplevel
	ClassDefinition refc = refctx.field.getClassDefinition();
	UplevelReference r = refc.getReference(target);
	r.noteReference(env, refctx);

	// remember the reference pertaining to the innermost frame
	if (res == null) {
	res = r;
	}
	}
	return res;
	}

	/**
	* Implement a reference (usually an uplevel one).
	* Call noteReference() first, to make sure the reference
	* lists are up to date.
	* <p>
	* The resulting expression tree does not need checking;
	* it can be code-generated right away.
	* If the reference is not uplevel, the result is an IDENT or THIS.
	*/
	public Expression makeReference(Environment env, LocalMember target) {
	UplevelReference r = noteReference(env, target);

	// Now create a referencing expression.
	if (r != null) {
	return r.makeLocalReference(env, this);
	} else if (idThis.equals(target.getName())) {
	return new ThisExpression(0, target);
	} else {
	return new IdentifierExpression(0, target);
	}
	}

	/**
	* Return a local expression which can serve as the base reference
	* for the given field. If the field is a constructor, return an
	* expression for the implicit enclosing instance argument.
	* <p>
	* Return null if there is no need for such an argument,
	* or if there was an error.
	*/
	public Expression findOuterLink(Environment env, long where,
	MemberDefinition f) {
	// reqc is the base pointer type required to use f
	ClassDefinition fc = f.getClassDefinition();
	ClassDefinition reqc = f.isStatic() ? null
	: !f.isConstructor() ? fc
	: fc.isTopLevel() ? null
	: fc.getOuterClass();
	if (reqc == null) {
	return null;
	}
	return findOuterLink(env, where, reqc, f, false);
	}

	private static boolean match(Environment env,
	ClassDefinition thisc, ClassDefinition reqc) {
	try {
	return thisc == reqc
	\|\| reqc.implementedBy(env, thisc.getClassDeclaration());
	} catch (ClassNotFound ee) {
	return false;
	}
	}

	public Expression findOuterLink(Environment env, long where,
	ClassDefinition reqc,
	MemberDefinition f,
	boolean needExactMatch) {
	if (field.isStatic()) {
	if (f == null) {
	// say something like: undefined variable A.this
	Identifier nm = reqc.getName().getFlatName().getName();
	env.error(where, "undef.var", Identifier.lookup(nm,idThis));
	} else if (f.isConstructor()) {
	env.error(where, "no.outer.arg", reqc, f.getClassDeclaration());
	} else if (f.isMethod()) {
	env.error(where, "no.static.meth.access",
	f, f.getClassDeclaration());
	} else {
	env.error(where, "no.static.field.access", f.getName(),
	f.getClassDeclaration());
	}
	// This is an attempt at error recovery.
	// Unfortunately, the constructor may throw
	// a null pointer exception after failing to resolve
	// 'idThis'. Since an error message has already been
	// issued previously, this exception is caught and
	// silently ignored. Ideally, we should avoid throwing
	// the exception.
	Expression e = new ThisExpression(where, this);
	e.type = reqc.getType();
	return e;
	}

	// use lp to scan for current instances (locals named "this")
	LocalMember lp = locals;

	// thise is a link expression being built up
	Expression thise = null;

	// root is the local variable (idThis) at the far left of thise
	LocalMember root = null;

	// thisc is the class of the link expression thise
	ClassDefinition thisc = null;

	// conCls is the class of the "this", in a constructor
	ClassDefinition conCls = null;
	if (field.isConstructor()) {
	conCls = field.getClassDefinition();
	}

	if (!field.isMethod()) {
	thisc = field.getClassDefinition();
	thise = new ThisExpression(where, this);
	}

	while (true) {
	if (thise == null) {
	// start fresh from lp
	while (lp != null && !idThis.equals(lp.getName())) {
	lp = lp.prev;
	}
	if (lp == null) {
	break;
	}
	thise = new ThisExpression(where, lp);
	thisc = lp.getClassDefinition();
	root = lp;
	lp = lp.prev;
	}

	// Require exact class identity when called with
	// 'needExactMatch' true. This is done when checking
	// the '<class>.this' syntax. Fixes 4102393 and 4133457.
	if (thisc == reqc \|\|
	(!needExactMatch && match(env, thisc, reqc))) {
	break;
	}

	// move out one step, if the current instance has an outer link

	MemberDefinition outerMember = thisc.findOuterMember();
	if (outerMember == null) {
	thise = null;
	continue; // try to find more help in lp
	}
	ClassDefinition prevc = thisc;
	thisc = prevc.getOuterClass();

	if (prevc == conCls) {
	// Must pick up "this$C" from the constructor argument,
	// not from "this.this$C", since the latter may not be
	// initialized properly. (This way is cheaper too.)
	Identifier nm = outerMember.getName();
	IdentifierExpression arg = new IdentifierExpression(where, nm);
	arg.bind(env, this);
	thise = arg;
	} else {
	thise = new FieldExpression(where, thise, outerMember);
	}
	}
	if (thise != null) {
	// mark crossed scopes
	// ?????
	//ensureAvailable(root);
	return thise;
	}

	if (f == null) {
	// say something like: undefined variable A.this
	Identifier nm = reqc.getName().getFlatName().getName();
	env.error(where, "undef.var", Identifier.lookup(nm,idThis));
	} else if (f.isConstructor()) {
	env.error(where, "no.outer.arg", reqc, f.getClassDefinition());
	} else {
	env.error(where, "no.static.field.access", f, field);
	}

	// avoid floodgating:
	Expression e = new ThisExpression(where, this);
	e.type = reqc.getType();
	return e;
	}

	/**
	* Is there a "this" of type reqc in scope?
	*/
	public static boolean outerLinkExists(Environment env,
	ClassDefinition reqc,
	ClassDefinition thisc) {
	while (!match(env, thisc, reqc)) {
	if (thisc.isTopLevel()) {
	return false;
	}
	thisc = thisc.getOuterClass();
	}
	return true;
	}

	/**
	* From which enclosing class do members of this type come?
	*/
	public ClassDefinition findScope(Environment env, ClassDefinition reqc) {
	ClassDefinition thisc = field.getClassDefinition();
	while (thisc != null && !match(env, thisc, reqc)) {
	thisc = thisc.getOuterClass();
	}
	return thisc;
	}

	/**
	* Resolve a type name from within a local scope.
	* @see Environment#resolveName
	*/
	Identifier resolveName(Environment env, Identifier name) {
	// This logic is pretty much exactly parallel to that of
	// Environment.resolveName().
	if (name.isQualified()) {
	// Try to resolve the first identifier component,
	// because inner class names take precedence over
	// package prefixes. (Cf. Environment.resolveName.)
	Identifier rhead = resolveName(env, name.getHead());

	if (rhead.hasAmbigPrefix()) {
	// The first identifier component refers to an
	// ambiguous class. Limp on. We throw away the
	// rest of the classname as it is irrelevant.
	// (part of solution for 4059855).
	return rhead;
	}

	if (!env.classExists(rhead)) {
	return env.resolvePackageQualifiedName(name);
	}
	try {
	return env.getClassDefinition(rhead).
	resolveInnerClass(env, name.getTail());
	} catch (ClassNotFound ee) {
	// return partially-resolved name someone else can fail on
	return Identifier.lookupInner(rhead, name.getTail());
	}
	}

	// Look for an unqualified name in enclosing scopes.
	try {
	MemberDefinition f = getClassCommon(env, name, false);
	if (f != null) {
	return f.getInnerClass().getName();
	}
	} catch (ClassNotFound ee) {
	// a missing superclass, or something catastrophic
	}

	// look in imports, etc.
	return env.resolveName(name);
	}

	/**
	* Return the name of a lexically apparent type,
	* skipping inherited members, and ignoring
	* the current pacakge and imports.
	* This is used for error checking.
	*/
	public
	Identifier getApparentClassName(Environment env, Identifier name) {
	if (name.isQualified()) {
	// Try to resolve the first identifier component,
	// because inner class names take precedence over
	// package prefixes. (Cf. Environment.resolveName.)
	Identifier rhead = getApparentClassName(env, name.getHead());
	return (rhead == null) ? idNull
	: Identifier.lookup(rhead,
	name.getTail());
	}

	// Look for an unqualified name in enclosing scopes.
	try {
	MemberDefinition f = getClassCommon(env, name, true);
	if (f != null) {
	return f.getInnerClass().getName();
	}
	} catch (ClassNotFound ee) {
	// a missing superclass, or something catastrophic
	}

	// the enclosing class name is the only apparent package member:
	Identifier topnm = field.getClassDefinition().getTopClass().getName();
	if (topnm.getName().equals(name)) {
	return topnm;
	}
	return idNull;
	}

	/**
	* Raise an error if a blank final was definitely unassigned
	* on entry to a loop, but has possibly been assigned on the
	* back-branch. If this is the case, the loop may be assigning
	* it multiple times.
	*/
	public void checkBackBranch(Environment env, Statement loop,
	Vset vsEntry, Vset vsBack) {
	for (LocalMember f = locals ; f != null ; f = f.prev) {
	if (f.isBlankFinal()
	&& vsEntry.testVarUnassigned(f.number)
	&& !vsBack.testVarUnassigned(f.number)) {
	env.error(loop.where, "assign.to.blank.final.in.loop",
	f.getName());
	}
	}
	}

	/**
	* Check if a field can reach another field (only considers
	* forward references, not the access modifiers).
	*/
	public boolean canReach(Environment env, MemberDefinition f) {
	return field.canReach(env, f);
	}

	/**
	* Get the context that corresponds to a label, return null if
	* not found.
	*/
	public
	Context getLabelContext(Identifier lbl) {
	for (Context ctx = this ; ctx != null ; ctx = ctx.prev) {
	if ((ctx.node != null) && (ctx.node instanceof Statement)) {
	if (((Statement)(ctx.node)).hasLabel(lbl))
	return ctx;
	}
	}
	return null;
	}

	/**
	* Get the destination context of a break
	*/
	public
	Context getBreakContext(Identifier lbl) {
	if (lbl != null) {
	return getLabelContext(lbl);
	}
	for (Context ctx = this ; ctx != null ; ctx = ctx.prev) {
	if (ctx.node != null) {
	switch (ctx.node.op) {
	case SWITCH:
	case FOR:
	case DO:
	case WHILE:
	return ctx;
	}
	}
	}
	return null;
	}

	/**
	* Get the destination context of a continue
	*/
	public
	Context getContinueContext(Identifier lbl) {
	if (lbl != null) {
	return getLabelContext(lbl);
	}
	for (Context ctx = this ; ctx != null ; ctx = ctx.prev) {
	if (ctx.node != null) {
	switch (ctx.node.op) {
	case FOR:
	case DO:
	case WHILE:
	return ctx;
	}
	}
	}
	return null;
	}

	/**
	* Get the destination context of a return (the method body)
	*/
	public
	CheckContext getReturnContext() {
	for (Context ctx = this ; ctx != null ; ctx = ctx.prev) {
	// The METHOD node is set up by Statement.checkMethod().
	if (ctx.node != null && ctx.node.op == METHOD) {
	return (CheckContext)ctx;
	}
	}
	return null;
	}

	/**
	* Get the context of the innermost surrounding try-block.
	* Consider only try-blocks contained within the same method.
	* (There could be others when searching from within a method
	* of a local class, but they are irrelevant to our purpose.)
	* This is used for recording DA/DU information preceding
	* all abnormal transfers of control: break, continue, return,
	* and throw.
	*/
	public
	CheckContext getTryExitContext() {
	for (Context ctx = this;
	ctx != null && ctx.node != null && ctx.node.op != METHOD;
	ctx = ctx.prev) {
	if (ctx.node.op == TRY) {
	return (CheckContext)ctx;
	}
	}
	return null;
	}

	/**
	* Get the nearest inlined context
	*/
	Context getInlineContext() {
	for (Context ctx = this ; ctx != null ; ctx = ctx.prev) {
	if (ctx.node != null) {
	switch (ctx.node.op) {
	case INLINEMETHOD:
	case INLINENEWINSTANCE:
	return ctx;
	}
	}
	}
	return null;
	}

	/**
	* Get the context of a field that is being inlined
	*/
	Context getInlineMemberContext(MemberDefinition field) {
	for (Context ctx = this ; ctx != null ; ctx = ctx.prev) {
	if (ctx.node != null) {
	switch (ctx.node.op) {
	case INLINEMETHOD:
	if (((InlineMethodExpression)ctx.node).field.equals(field)) {
	return ctx;
	}
	break;
	case INLINENEWINSTANCE:
	if (((InlineNewInstanceExpression)ctx.node).field.equals(field)) {
	return ctx;
	}
	}
	}
	}
	return null;
	}

	/**
	* Remove variables from the vset set that are no longer part of
	* this context.
	*/
	public final Vset removeAdditionalVars(Vset vset) {
	return vset.removeAdditionalVars(varNumber);
	}

	public final int getVarNumber() {
	return varNumber;
	}

	/**
	* Return the number of the innermost current instance reference.
	*/
	public int getThisNumber() {
	LocalMember thisf = getLocalField(idThis);
	if (thisf != null
	&& thisf.getClassDefinition() == field.getClassDefinition()) {
	return thisf.number;
	}
	// this is a variable; there is no "this" (should not happen)
	return varNumber;
	}

	/**
	* Return the field containing the present context.
	*/
	public final MemberDefinition getField() {
	return field;
	}

	/**
	* Extend an environment with the given context.
	* The resulting environment behaves the same as
	* the given one, except that resolveName() takes
	* into account local class names in this context.
	*/
	public static Environment newEnvironment(Environment env, Context ctx) {
	return new ContextEnvironment(env, ctx);
	}
	}

	final
	class ContextEnvironment extends Environment {
	Context ctx;
	Environment innerEnv;

	ContextEnvironment(Environment env, Context ctx) {
	super(env, env.getSource());
	this.ctx = ctx;
	this.innerEnv = env;
	}

	public Identifier resolveName(Identifier name) {
	return ctx.resolveName(innerEnv, name);
	}
	}

Back to index...