package org.eclipse.jdt.internal.compiler.ast;

/*
 * (c) Copyright IBM Corp. 2000, 2001.
 * All Rights Reserved.
 */
import org.eclipse.jdt.internal.compiler.IAbstractSyntaxTreeVisitor;
import org.eclipse.jdt.internal.compiler.impl.*;
import org.eclipse.jdt.internal.compiler.codegen.*;
import org.eclipse.jdt.internal.compiler.flow.*;
import org.eclipse.jdt.internal.compiler.lookup.*;

public class SingleNameReference extends NameReference implements OperatorIds {
	public char[] token;

	public MethodBinding[] syntheticAccessors; // [0]=read accessor [1]=write accessor
	public static final int READ = 0;
	public static final int WRITE = 1;
public SingleNameReference(char[] source, long pos) {
	super();
	token = source;
	sourceStart = (int) (pos >>> 32);
	sourceEnd = (int) pos;
}
public FlowInfo analyseAssignment(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, Assignment assignment, boolean isCompound) {

	// compound assignment extra work
	if (isCompound) { // check the variable part is initialized if blank final
		switch (bits & RestrictiveFlagMASK) {
			case FIELD : // reading a field
				FieldBinding fieldBinding;
				if ((fieldBinding = (FieldBinding) binding).isFinal() && currentScope.allowBlankFinalFieldAssignment(fieldBinding)) {
					if (!flowInfo.isDefinitelyAssigned(fieldBinding)) {
						currentScope.problemReporter().uninitializedBlankFinalField(fieldBinding, this);
						// we could improve error msg here telling "cannot use compound assignment on final blank field"
					}
				}
				manageSyntheticReadAccessIfNecessary(currentScope);
				break;
			case LOCAL : // reading a local variable
				// check if assigning a final blank field
				LocalVariableBinding localBinding;
				if (!flowInfo.isDefinitelyAssigned(localBinding = (LocalVariableBinding) binding)) {
					currentScope.problemReporter().uninitializedLocalVariable(localBinding, this);
					// we could improve error msg here telling "cannot use compound assignment on final local variable"
				}
				if (!flowInfo.isFakeReachable()) localBinding.used = true;
		}
	}
	if (assignment.expression != null) {
		flowInfo = assignment.expression.analyseCode(currentScope, flowContext, flowInfo).unconditionalInits();
	}
	switch (bits & RestrictiveFlagMASK) {
		case FIELD : // assigning to a field
			manageSyntheticWriteAccessIfNecessary(currentScope);

			// check if assigning a final field
			FieldBinding fieldBinding;
			if ((fieldBinding = (FieldBinding) binding).isFinal()) {
				// inside a context where allowed
				if (currentScope.allowBlankFinalFieldAssignment(fieldBinding)) {
					if (flowInfo.isPotentiallyAssigned(fieldBinding)) {
						currentScope.problemReporter().duplicateInitializationOfBlankFinalField(fieldBinding, this);
					}
					flowInfo.markAsDefinitelyAssigned(fieldBinding);
					flowContext.recordSettingFinal(fieldBinding, this);						
				} else {
					currentScope.problemReporter().cannotAssignToFinalField(fieldBinding, this);
				}
			}
			break;
		case LOCAL : // assigning to a local variable 
			LocalVariableBinding localBinding = (LocalVariableBinding) binding;
			if (!flowInfo.isDefinitelyAssigned(localBinding)){// for local variable debug attributes
				bits |= FirstAssignmentToLocalMASK;
			} else {
				bits &= ~FirstAssignmentToLocalMASK;
			}
			if (localBinding.isFinal()) {
				if ((bits & DepthMASK) == 0) {
					if (flowInfo.isPotentiallyAssigned(localBinding)) {
						currentScope.problemReporter().duplicateInitializationOfFinalLocal(localBinding, this);
					}
					flowContext.recordSettingFinal(localBinding, this);								
				} else {
					currentScope.problemReporter().cannotAssignToFinalOuterLocal(localBinding, this);
				}
			}
			flowInfo.markAsDefinitelyAssigned(localBinding);
	}
	manageEnclosingInstanceAccessIfNecessary(currentScope);
	return flowInfo;
}
public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
	return analyseCode(currentScope, flowContext, flowInfo, true);
}
public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
	switch (bits & RestrictiveFlagMASK) {
		case FIELD : // reading a field
			if (valueRequired) {
				manageSyntheticReadAccessIfNecessary(currentScope);
			}
			// check if reading a final blank field
			FieldBinding fieldBinding;
			if ((fieldBinding = (FieldBinding) binding).isFinal() && currentScope.allowBlankFinalFieldAssignment(fieldBinding)) {
				if (!flowInfo.isDefinitelyAssigned(fieldBinding)) {
					currentScope.problemReporter().uninitializedBlankFinalField(fieldBinding, this);
				}
			}
			break;
		case LOCAL : // reading a local variable
			LocalVariableBinding localBinding;
			if (!flowInfo.isDefinitelyAssigned(localBinding = (LocalVariableBinding) binding)) {
				currentScope.problemReporter().uninitializedLocalVariable(localBinding, this);
			}
			if (!flowInfo.isFakeReachable()) localBinding.used = true;			
	}
	if (valueRequired) {
		manageEnclosingInstanceAccessIfNecessary(currentScope);
	}
	return flowInfo;
}
public TypeBinding checkFieldAccess(BlockScope scope) {

	FieldBinding fieldBinding = (FieldBinding) binding;
	
	bits &= ~RestrictiveFlagMASK; // clear bits
	bits |= FIELD;
	if (!((FieldBinding) binding).isStatic()) {
		// must check for the static status....
		if (scope.methodScope().isStatic) {
			scope.problemReporter().staticFieldAccessToNonStaticVariable(
				this,
				fieldBinding);
			constant = NotAConstant;
			return null;
		}
	}
	constant = FieldReference.getConstantFor(fieldBinding, true, this, 0);
	if (isFieldUseDeprecated(fieldBinding, scope))
		scope.problemReporter().deprecatedField(fieldBinding, this);
	// if the binding declaring class is not visible, need special action
	// for runtime compatibility on 1.2 VMs : change the declaring class of the binding
	if (fieldBinding.declaringClass != null
		&& fieldBinding.constant == NotAConstant
		&& !fieldBinding.declaringClass.canBeSeenBy(scope))
		binding = new FieldBinding(fieldBinding, scope.enclosingSourceType());

	//===============================================
	//cycle are forbidden ONLY within the same class...why ?????? (poor javac....)
	//Cycle can be done using cross class ref but not direct into a same class reference ????
	//class A {	static int k = B.k+1;}
	//class B {	static int k = A.k+2;}
	//The k-cycle in this example is valid.

	//class C { static int k = k + 1 ;}
	//here it is forbidden ! ????
	//but the next one is valid !!!
	//class C { static int k = C.k + 1;}

	//notice that the next one is also valid ?!?!
	//class A {	static int k = foo().k+1 ; static A foo(){return new A();}}

	//for all these reasons, the next piece of code is only here and not
	//commun for all FieldRef and QualifiedNameRef....(i.e. in the getField(..) API.....

	//instance field may refer to forward static field, like in
	//int i = staticI;
	//static int staticI = 2 ;

	MethodScope ms = scope.methodScope();
	if (ms.enclosingSourceType() == fieldBinding.declaringClass
		&& ms.fieldDeclarationIndex != MethodScope.NotInFieldDecl
		&& fieldBinding.id >= ms.fieldDeclarationIndex) {
		//if the field is static and ms is not .... then it is valid
		if (!fieldBinding.isStatic() || ms.isStatic)
			scope.problemReporter().forwardReference(this, 0, scope.enclosingSourceType());
	}
	//====================================================

	return fieldBinding.type;

}
public void generateAssignment(BlockScope currentScope, CodeStream codeStream, Assignment assignment, boolean valueRequired) {

	// optimizing assignment like: i = i + 1 or i = 1 + i
	if (assignment.expression.isCompactableOperation()) {
		BinaryExpression operation = (BinaryExpression) assignment.expression;
		SingleNameReference variableReference;
		if ((operation.left instanceof SingleNameReference) && ((variableReference = (SingleNameReference) operation.left).binding == binding)) {
			// i = i + value, then use the variable on the right hand side, since it has the correct implicit conversion
			variableReference.generateCompoundAssignment(currentScope, codeStream, syntheticAccessors == null ? null : syntheticAccessors[WRITE], operation.right, (operation.bits & OperatorMASK) >> OperatorSHIFT, operation.left.implicitConversion /*should be equivalent to no conversion*/, valueRequired);
			return;
		}
		int operator = (operation.bits & OperatorMASK) >> OperatorSHIFT;
		if ((operation.right instanceof SingleNameReference)
			&& ((operator == PLUS) || (operator == MULTIPLY)) // only commutative operations
			&& ((variableReference = (SingleNameReference) operation.right).binding == binding)
			&& (operation.left.constant != NotAConstant) // exclude non constant expressions, since could have side-effect
			&& ((operation.left.implicitConversion >> 4) != T_String) // exclude string concatenation which would occur backwards
			&& ((operation.right.implicitConversion >> 4) != T_String)) { // exclude string concatenation which would occur backwards
			// i = value + i, then use the variable on the right hand side, since it has the correct implicit conversion
			variableReference.generateCompoundAssignment(currentScope, codeStream, syntheticAccessors == null ? null : syntheticAccessors[WRITE], operation.left, operator, operation.right.implicitConversion /*should be equivalent to no conversion*/, valueRequired);
			return;
		}
	}
	switch (bits & RestrictiveFlagMASK) {
		case FIELD : // assigning to a field
			FieldBinding fieldBinding;
			if (!(fieldBinding = (FieldBinding) binding).isStatic()) { // need a receiver?
				if ((bits & DepthMASK) != 0) {
					Object[] emulationPath = currentScope.getExactEmulationPath(currentScope.enclosingSourceType().enclosingTypeAt((bits & DepthMASK) >> DepthSHIFT));
					if (emulationPath == null) {
						// internal error, per construction we should have found it
						currentScope.problemReporter().needImplementation();
					} else {
						codeStream.generateOuterAccess(emulationPath, this, currentScope);
					}
				} else {
					this.generateReceiver(codeStream);
				}
			}
			assignment.expression.generateCode(currentScope, codeStream, true);
			fieldStore(codeStream, fieldBinding, syntheticAccessors == null ? null : syntheticAccessors[WRITE], valueRequired);
			if (valueRequired) {
				codeStream.generateImplicitConversion(assignment.implicitConversion);
			}
			return;
		case LOCAL : // assigning to a local variable
			LocalVariableBinding localBinding = (LocalVariableBinding) binding;
			if (localBinding.resolvedPosition != -1) {
				assignment.expression.generateCode(currentScope, codeStream, true);
			} else {
				if (assignment.expression.constant != NotAConstant) {
					// assigning an unused local to a constant value = no actual assignment is necessary
					if (valueRequired) {
						codeStream.generateConstant(assignment.expression.constant, assignment.implicitConversion);
					}
				} else {
					assignment.expression.generateCode(currentScope, codeStream, true);
					/* Even though the value may not be required, we force it to be produced, and discard it later
					on if it was actually not necessary, so as to provide the same behavior as JDK1.2beta3.	*/
					if (valueRequired) {
						codeStream.generateImplicitConversion(assignment.implicitConversion); // implicit conversion
					} else {
						if ((localBinding.type == LongBinding) || (localBinding.type == DoubleBinding)) {
							codeStream.pop2();
						} else {
							codeStream.pop();
						}
					}
				}
				return;
			}
			// normal local assignment (since cannot store in outer local which are final locations)
			codeStream.store(localBinding, valueRequired);
			if ((bits & FirstAssignmentToLocalMASK) != 0) { // for local variable debug attributes
				localBinding.recordInitializationStartPC(codeStream.position);
			}
			// implicit conversion
			if (valueRequired) {
				codeStream.generateImplicitConversion(assignment.implicitConversion);
			}
	}
}
public void generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired) {
	int pc = codeStream.position;
	if (constant != NotAConstant) {
		if (valueRequired) {
			codeStream.generateConstant(constant, implicitConversion);
		}
	} else {
		switch (bits & RestrictiveFlagMASK) {
			case FIELD : // reading a field
				FieldBinding fieldBinding;
				if (valueRequired) {
					if ((fieldBinding = (FieldBinding) binding).constant == NotAConstant) { // directly use inlined value for constant fields
						boolean isStatic;
						if (!(isStatic = fieldBinding.isStatic())) {
							if ((bits & DepthMASK) != 0) {
								Object[] emulationPath = currentScope.getExactEmulationPath(currentScope.enclosingSourceType().enclosingTypeAt((bits & DepthMASK) >> DepthSHIFT));
								if (emulationPath == null) {
									// internal error, per construction we should have found it
									currentScope.problemReporter().needImplementation();
								} else {
									codeStream.generateOuterAccess(emulationPath, this, currentScope);
								}
							} else {
								generateReceiver(codeStream);
							}
						}
						// managing private access							
						if ((syntheticAccessors == null) || (syntheticAccessors[READ] == null)) {
							if (isStatic) {
								codeStream.getstatic(fieldBinding);
							} else {
								codeStream.getfield(fieldBinding);
							}
						} else {
							codeStream.invokestatic(syntheticAccessors[READ]);
						}
						codeStream.generateImplicitConversion(implicitConversion);
					} else { // directly use the inlined value
						codeStream.generateConstant(fieldBinding.constant, implicitConversion);
					}
				}
				break;
			case LOCAL : // reading a local
				LocalVariableBinding localBinding = (LocalVariableBinding) binding;
				if (valueRequired) {
					// outer local?
					if ((bits & DepthMASK) != 0) {
						// outer local can be reached either through a synthetic arg or a synthetic field
						VariableBinding[] path = currentScope.getEmulationPath(localBinding);
						if (path == null) {
							// emulation was not possible (should not happen per construction)
							currentScope.problemReporter().needImplementation();
						} else {
							codeStream.generateOuterAccess(path, this, currentScope);
						}
					} else {
						// regular local variable read
						codeStream.load(localBinding);
					}
					codeStream.generateImplicitConversion(implicitConversion);
				}
		}
	}
	codeStream.recordPositionsFrom(pc, this);
}
/*
 * Regular API for compound assignment, relies on the fact that there is only one reference to the
 * variable, which carries both synthetic read/write accessors.
 * The APIs with an extra argument is used whenever there are two references to the same variable which
 * are optimized in one access: e.g "a = a + 1" optimized into "a++".
 */
public void generateCompoundAssignment(BlockScope currentScope, CodeStream codeStream, Expression expression, int operator, int assignmentImplicitConversion, boolean valueRequired) {

	this.generateCompoundAssignment(
		currentScope, 
		codeStream, 
		syntheticAccessors == null ? null : syntheticAccessors[WRITE],
		expression,
		operator, 
		assignmentImplicitConversion, 
		valueRequired);
}
/*
 * The APIs with an extra argument is used whenever there are two references to the same variable which
 * are optimized in one access: e.g "a = a + 1" optimized into "a++".
 */
public void generateCompoundAssignment(BlockScope currentScope, CodeStream codeStream, MethodBinding writeAccessor, Expression expression, int operator, int assignmentImplicitConversion, boolean valueRequired) {
	switch (bits & RestrictiveFlagMASK) {
		case FIELD : // assigning to a field
			FieldBinding fieldBinding;
			if ((fieldBinding = (FieldBinding) binding).isStatic()) {
				if ((syntheticAccessors == null) || (syntheticAccessors[READ] == null)) {
					codeStream.getstatic(fieldBinding);
				} else {
					codeStream.invokestatic(syntheticAccessors[READ]);
				}
			} else {
				if ((bits & DepthMASK) != 0) {
					Object[] emulationPath = currentScope.getExactEmulationPath(currentScope.enclosingSourceType().enclosingTypeAt((bits & DepthMASK) >> DepthSHIFT));
					if (emulationPath == null) {
						// internal error, per construction we should have found it
						currentScope.problemReporter().needImplementation();
					} else {
						codeStream.generateOuterAccess(emulationPath, this, currentScope);
					}
				} else {
					codeStream.aload_0();
				}
				codeStream.dup();
				if ((syntheticAccessors == null) || (syntheticAccessors[READ] == null)) {
					codeStream.getfield(fieldBinding);
				} else {
					codeStream.invokestatic(syntheticAccessors[READ]);
				}
			}
			break;
		case LOCAL : // assigning to a local variable (cannot assign to outer local)
			LocalVariableBinding localBinding = (LocalVariableBinding) binding;
			Constant assignConstant;
			int increment;
			// using incr bytecode if possible
			switch (localBinding.type.id) {
				case T_String :
					codeStream.generateStringAppend(currentScope, this, expression);
					if (valueRequired) {
						codeStream.dup();
					}
					codeStream.store(localBinding, false);
					return;
				case T_int :
					if (((assignConstant = expression.constant) != NotAConstant) && ((increment = assignConstant.intValue()) == (short) increment)) { // 16 bits value
						switch (operator) {
							case PLUS :
								codeStream.iinc(localBinding.resolvedPosition, increment);
								if (valueRequired) {
									codeStream.load(localBinding);
								}
								return;
							case MINUS :
								codeStream.iinc(localBinding.resolvedPosition, -increment);
								if (valueRequired) {
									codeStream.load(localBinding);
								}
								return;
						}
					}
				default :
					codeStream.load(localBinding);
			}
	}
	// perform the actual compound operation
	int operationTypeID;
	if ((operationTypeID = implicitConversion >> 4) == T_String || operationTypeID == T_Object) {
		// we enter here if the single name reference is a field of type java.lang.String or if the type of the 
		// operation is java.lang.Object
		// For example: o = o + ""; // where the compiled type of o is java.lang.Object.
		codeStream.generateStringAppend(currentScope, null, expression);
	} else {
		// promote the array reference to the suitable operation type
		codeStream.generateImplicitConversion(implicitConversion);
		// generate the increment value (will by itself  be promoted to the operation value)
		if (expression == IntLiteral.One){ // prefix operation
			codeStream.generateConstant(expression.constant, implicitConversion);			
		} else {
			expression.generateCode(currentScope, codeStream, true);
		}		
		// perform the operation
		codeStream.sendOperator(operator, operationTypeID);
		// cast the value back to the array reference type
		codeStream.generateImplicitConversion(assignmentImplicitConversion);
	}
	// store the result back into the variable
	switch (bits & RestrictiveFlagMASK) {
		case FIELD : // assigning to a field
			fieldStore(codeStream, (FieldBinding) binding, writeAccessor, valueRequired);
			return;
		case LOCAL : // assigning to a local variable
			LocalVariableBinding localBinding = (LocalVariableBinding) binding;
			if (valueRequired) {
				if ((localBinding.type == LongBinding) || (localBinding.type == DoubleBinding)) {
					codeStream.dup2();
				} else {
					codeStream.dup();
				}
			}
			codeStream.store(localBinding, false);
	}
}
public void generatePostIncrement(BlockScope currentScope, CodeStream codeStream, CompoundAssignment postIncrement, boolean valueRequired) {
	switch (bits & RestrictiveFlagMASK) {
		case FIELD : // assigning to a field
			FieldBinding fieldBinding;
			if ((fieldBinding = (FieldBinding) binding).isStatic()) {
				if ((syntheticAccessors == null) || (syntheticAccessors[READ] == null)) {
					codeStream.getstatic(fieldBinding);
				} else {
					codeStream.invokestatic(syntheticAccessors[READ]);
				}
			} else {
				if ((bits & DepthMASK) != 0) {
					Object[] emulationPath = currentScope.getExactEmulationPath(currentScope.enclosingSourceType().enclosingTypeAt((bits & DepthMASK) >> DepthSHIFT));
					if (emulationPath == null) {
						// internal error, per construction we should have found it
						currentScope.problemReporter().needImplementation();
					} else {
						codeStream.generateOuterAccess(emulationPath, this, currentScope);
					}
				} else {
					codeStream.aload_0();
				}
				codeStream.dup();
				if ((syntheticAccessors == null) || (syntheticAccessors[READ] == null)) {
					codeStream.getfield(fieldBinding);
				} else {
					codeStream.invokestatic(syntheticAccessors[READ]);
				}
			}
			if (valueRequired) {
				if (fieldBinding.isStatic()) {
					if ((fieldBinding.type == LongBinding) || (fieldBinding.type == DoubleBinding)) {
						codeStream.dup2();
					} else {
						codeStream.dup();
					}
				} else { // Stack:  [owner][old field value]  ---> [old field value][owner][old field value]
					if ((fieldBinding.type == LongBinding) || (fieldBinding.type == DoubleBinding)) {
						codeStream.dup2_x1();
					} else {
						codeStream.dup_x1();
					}
				}
			}
			codeStream.generateConstant(postIncrement.expression.constant, implicitConversion);
			codeStream.sendOperator(postIncrement.operator, fieldBinding.type.id);
			codeStream.generateImplicitConversion(postIncrement.assignmentImplicitConversion);
			fieldStore(codeStream, fieldBinding, syntheticAccessors == null ? null : syntheticAccessors[WRITE], false);
			return;
		case LOCAL : // assigning to a local variable
			LocalVariableBinding localBinding = (LocalVariableBinding) binding;
			// using incr bytecode if possible
			if (localBinding.type == IntBinding) {
				if (valueRequired) {
					codeStream.load(localBinding);
				}
				if (postIncrement.operator == PLUS) {
					codeStream.iinc(localBinding.resolvedPosition, 1);
				} else {
					codeStream.iinc(localBinding.resolvedPosition, -1);
				}
			} else {
				codeStream.load(localBinding);
				if (valueRequired){
					if ((localBinding.type == LongBinding) || (localBinding.type == DoubleBinding)) {
						codeStream.dup2();
					} else {
						codeStream.dup();
					}
				}
				codeStream.generateConstant(postIncrement.expression.constant, implicitConversion);
				codeStream.sendOperator(postIncrement.operator, localBinding.type.id);
				codeStream.generateImplicitConversion(postIncrement.assignmentImplicitConversion);

				codeStream.store(localBinding, false);
			}
	}
}
public void generateReceiver(CodeStream codeStream) {
	codeStream.aload_0();
}
public void manageEnclosingInstanceAccessIfNecessary(BlockScope currentScope) {

	//If inlinable field, forget the access emulation, the code gen will directly target it
	if (((bits & DepthMASK) == 0) || (constant != NotAConstant)) return;

	switch (bits & RestrictiveFlagMASK) {
		case FIELD :
			FieldBinding fieldBinding;
			if ((fieldBinding = (FieldBinding)binding).isStatic() || (fieldBinding.constant != NotAConstant)) return;
			ReferenceBinding compatibleType = currentScope.enclosingSourceType();
			// the declaringClass of the target binding must be compatible with the enclosing
			// type at <depth> levels outside
			for (int i = 0, depth = (bits & DepthMASK) >> DepthSHIFT; i < depth; i++) {
				compatibleType = compatibleType.enclosingType();
			}
			currentScope.emulateOuterAccess(compatibleType, false); // request cascade of accesses
			break;
		case LOCAL :
			currentScope.emulateOuterAccess((LocalVariableBinding) binding);
	}
}
public void manageSyntheticReadAccessIfNecessary(BlockScope currentScope) {

	//If inlinable field, forget the access emulation, the code gen will directly target it
	if (constant != NotAConstant)
		return;

	if ((bits & FIELD) != 0) {
		FieldBinding fieldBinding = (FieldBinding) binding;
		if (((bits & DepthMASK) != 0)
			&& (fieldBinding.isPrivate() // private access
				|| (fieldBinding.isProtected() // implicit protected access
						&& fieldBinding.declaringClass.getPackage() 
							!= currentScope.enclosingSourceType().getPackage()))) {
			if (syntheticAccessors == null)
				syntheticAccessors = new MethodBinding[2];
			syntheticAccessors[READ] = 
				((SourceTypeBinding)currentScope.enclosingSourceType().
					enclosingTypeAt((bits & DepthMASK) >> DepthSHIFT)).
						addSyntheticMethod(fieldBinding, true);
			currentScope.problemReporter().needToEmulateFieldReadAccess(fieldBinding, this);
		}
	}
}
public void manageSyntheticWriteAccessIfNecessary(BlockScope currentScope) {

	if ((bits & FIELD) != 0) {
		FieldBinding fieldBinding = (FieldBinding) binding;
		if (((bits & DepthMASK) != 0) 
			&& (fieldBinding.isPrivate() // private access
				|| (fieldBinding.isProtected() // implicit protected access
						&& fieldBinding.declaringClass.getPackage() 
							!= currentScope.enclosingSourceType().getPackage()))) {
			if (syntheticAccessors == null)
				syntheticAccessors = new MethodBinding[2];
			syntheticAccessors[WRITE] = 
				((SourceTypeBinding)currentScope.enclosingSourceType().
					enclosingTypeAt((bits & DepthMASK) >> DepthSHIFT)).
						addSyntheticMethod(fieldBinding, false);
			currentScope.problemReporter().needToEmulateFieldWriteAccess(fieldBinding, this);
		}
	}
}
public TypeBinding reportError(BlockScope scope) {
	//=====error cases=======
	constant = Constant.NotAConstant;
	if (binding instanceof ProblemFieldBinding) {
		scope.problemReporter().invalidField(this, (FieldBinding) binding);
	} else if (binding instanceof ProblemReferenceBinding) {
		scope.problemReporter().invalidType(this, (TypeBinding) binding);
	} else {
		scope.problemReporter().unresolvableReference(this, binding);
	}
	return null;
}
public TypeBinding resolveType(BlockScope scope) {
	// for code gen, harm the restrictiveFlag 	

	this.receiverType = scope.enclosingSourceType();
	
	if ((binding = scope.getBinding(token, bits & RestrictiveFlagMASK, this)).isValidBinding()) {
		switch (bits & RestrictiveFlagMASK) {
			case VARIABLE : // =========only variable============
			case VARIABLE | TYPE : //====both variable and type============
				if (binding instanceof VariableBinding) {
					VariableBinding vb = (VariableBinding) binding;
					if (binding instanceof LocalVariableBinding) {
						bits &= ~RestrictiveFlagMASK;  // clear bits
						bits |= LOCAL;
						constant = vb.constant;
						if ((!vb.isFinal()) && ((bits & DepthMASK) != 0))
							scope.problemReporter().cannotReferToNonFinalOuterLocal((LocalVariableBinding)vb, this);
						return vb.type;
					}
					// a field
					return checkFieldAccess(scope);
				}

				// thus it was a type
				bits &= ~RestrictiveFlagMASK;  // clear bits
				bits |= TYPE;
			case TYPE : //========only type==============
				constant = Constant.NotAConstant;
				//deprecated test
				if (isTypeUseDeprecated((TypeBinding) binding, scope))
					scope.problemReporter().deprecatedType((TypeBinding) binding, this);
				return (TypeBinding) binding;
		}
	}

	// error scenarii
	return this.reportError(scope);
}
public String toStringExpression(){

	return new String(token);}
public void traverse(IAbstractSyntaxTreeVisitor visitor, BlockScope scope) {
	visitor.visit(this, scope);
	visitor.endVisit(this, scope);
}
public String unboundReferenceErrorName(){

	return new String(token);}
}