/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package net.sourceforge.phpeclipse.internal.compiler.ast;

import net.sourceforge.phpdt.internal.compiler.IAbstractSyntaxTreeVisitor;
import net.sourceforge.phpdt.internal.compiler.flow.FlowContext;
import net.sourceforge.phpdt.internal.compiler.flow.FlowInfo;
import net.sourceforge.phpdt.internal.compiler.impl.Constant;
import net.sourceforge.phpdt.internal.compiler.lookup.BlockScope;
import net.sourceforge.phpdt.internal.compiler.lookup.FieldBinding;
import net.sourceforge.phpdt.internal.compiler.lookup.LocalVariableBinding;
import net.sourceforge.phpdt.internal.compiler.lookup.MethodBinding;
import net.sourceforge.phpdt.internal.compiler.lookup.MethodScope;
import net.sourceforge.phpdt.internal.compiler.lookup.ProblemFieldBinding;
import net.sourceforge.phpdt.internal.compiler.lookup.ProblemReferenceBinding;
import net.sourceforge.phpdt.internal.compiler.lookup.ReferenceBinding;
import net.sourceforge.phpdt.internal.compiler.lookup.SourceTypeBinding;
import net.sourceforge.phpdt.internal.compiler.lookup.TypeBinding;
import net.sourceforge.phpdt.internal.compiler.lookup.VariableBinding;

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).isBlankFinal() 
						&& currentScope.allowBlankFinalFieldAssignment(fieldBinding)) {
					if (!flowInfo.isDefinitelyAssigned(fieldBinding)) {
						currentScope.problemReporter().uninitializedBlankFinalField(fieldBinding, this);
					}
				}
				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.isReachable()) {
					localBinding.useFlag = LocalVariableBinding.USED;
				} else if (localBinding.useFlag == LocalVariableBinding.UNUSED) {
					localBinding.useFlag = LocalVariableBinding.FAKE_USED;
				}
		}
	}
	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 (!isCompound && fieldBinding.isBlankFinal() && currentScope.allowBlankFinalFieldAssignment(fieldBinding)) {
					if (flowInfo.isPotentiallyAssigned(fieldBinding)) {
						currentScope.problemReporter().duplicateInitializationOfBlankFinalField(fieldBinding, this);
					} else {
						flowContext.recordSettingFinal(fieldBinding, this);						
					}
					flowInfo.markAsDefinitelyAssigned(fieldBinding);
				} 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 (isCompound || !localBinding.isBlankFinal()){
						currentScope.problemReporter().cannotAssignToFinalLocal(localBinding, this);
					} else if (flowInfo.isPotentiallyAssigned(localBinding)) {
						currentScope.problemReporter().duplicateInitializationOfFinalLocal(localBinding, this);
					} else {
						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).isBlankFinal() 
					&& 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.isReachable()) {
				localBinding.useFlag = LocalVariableBinding.USED;
			} else if (localBinding.useFlag == LocalVariableBinding.UNUSED) {
				localBinding.useFlag = LocalVariableBinding.FAKE_USED;
			}
	}
	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 fieldBinding.type;
		}
	}
	constant = FieldReference.getConstantFor(fieldBinding, this, true, scope);

	if (isFieldUseDeprecated(fieldBinding, scope))
		scope.problemReporter().deprecatedField(fieldBinding, this);

	MethodScope ms = scope.methodScope();
	if ((this.bits & IsStrictlyAssignedMASK) == 0
		&& 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) this.codegenBinding).isStatic()) { // need a receiver?
//				if ((bits & DepthMASK) != 0) {
//					ReferenceBinding targetType = currentScope.enclosingSourceType().enclosingTypeAt((bits & DepthMASK) >> DepthSHIFT);
//					Object[] emulationPath = currentScope.getEmulationPath(targetType, true /*only exact match*/, false/*consider enclosing arg*/);
//					codeStream.generateOuterAccess(emulationPath, this, targetType, 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) this.codegenBinding;
//			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;
//			}
//			// 26903, need extra cast to store null in array local var	
//			if (localBinding.type.isArrayType() 
//				&& (assignment.expression.resolvedType == NullBinding	// arrayLoc = null
//					|| ((assignment.expression instanceof CastExpression)	// arrayLoc = (type[])null
//						&& (((CastExpression)assignment.expression).innermostCastedExpression().resolvedType == NullBinding)))){
//				codeStream.checkcast(localBinding.type); 
//			}
//			
//			// 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) this.codegenBinding).constant == NotAConstant) { // directly use inlined value for constant fields
//						boolean isStatic;
//						if (!(isStatic = fieldBinding.isStatic())) {
//							if ((bits & DepthMASK) != 0) {
//								ReferenceBinding targetType = currentScope.enclosingSourceType().enclosingTypeAt((bits & DepthMASK) >> DepthSHIFT);
//								Object[] emulationPath = currentScope.getEmulationPath(targetType, true /*only exact match*/, false/*consider enclosing arg*/);
//								codeStream.generateOuterAccess(emulationPath, this, targetType, 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) this.codegenBinding;
//				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);
//						codeStream.generateOuterAccess(path, this, localBinding, currentScope);
//					} else {
//						// regular local variable read
//						codeStream.load(localBinding);
//					}
//					codeStream.generateImplicitConversion(implicitConversion);
//				}
//		}
//	}
//	codeStream.recordPositionsFrom(pc, this.sourceStart);
//}
///*
// * 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) this.codegenBinding).isStatic()) {
//				if ((syntheticAccessors == null) || (syntheticAccessors[READ] == null)) {
//					codeStream.getstatic(fieldBinding);
//				} else {
//					codeStream.invokestatic(syntheticAccessors[READ]);
//				}
//			} else {
//				if ((bits & DepthMASK) != 0) {
//					ReferenceBinding targetType = currentScope.enclosingSourceType().enclosingTypeAt((bits & DepthMASK) >> DepthSHIFT);
//					Object[] emulationPath = currentScope.getEmulationPath(targetType, true /*only exact match*/, false/*consider enclosing arg*/);
//					codeStream.generateOuterAccess(emulationPath, this, targetType, 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) this.codegenBinding;
//			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) 
//						&& (assignConstant.typeID() != T_float) // only for integral types
//						&& (assignConstant.typeID() != T_double)
//						&& ((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) this.codegenBinding, writeAccessor, valueRequired);
//			return;
//		case LOCAL : // assigning to a local variable
//			LocalVariableBinding localBinding = (LocalVariableBinding) this.codegenBinding;
//			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) this.codegenBinding).isStatic()) {
//				if ((syntheticAccessors == null) || (syntheticAccessors[READ] == null)) {
//					codeStream.getstatic(fieldBinding);
//				} else {
//					codeStream.invokestatic(syntheticAccessors[READ]);
//				}
//			} else {
//				if ((bits & DepthMASK) != 0) {
//					ReferenceBinding targetType = currentScope.enclosingSourceType().enclosingTypeAt((bits & DepthMASK) >> DepthSHIFT);
//					Object[] emulationPath = currentScope.getEmulationPath(targetType, true /*only exact match*/, false/*consider enclosing arg*/);
//					codeStream.generateOuterAccess(emulationPath, this, targetType, 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) this.codegenBinding;
//			// 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;

	if ((bits & RestrictiveFlagMASK) == 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);
			return;
		}
		// 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
		// NOTE: from target 1.2 on, field's declaring class is touched if any different from receiver type
		// and not from Object or implicit static field access.	
//		if (fieldBinding.declaringClass != this.actualReceiverType
//			&& !this.actualReceiverType.isArrayType()	
//			&& fieldBinding.declaringClass != null
//			&& fieldBinding.constant == NotAConstant
//			&& ((currentScope.environment().options.targetJDK >= CompilerOptions.JDK1_2 
//					&& !fieldBinding.isStatic()
//					&& fieldBinding.declaringClass.id != T_Object) // no change for Object fields (if there was any)
//				|| !fieldBinding.declaringClass.canBeSeenBy(currentScope))){
//			this.codegenBinding = currentScope.enclosingSourceType().getUpdatedFieldBinding(fieldBinding, (ReferenceBinding)this.actualReceiverType);
//		}
	}
}
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);
			return;
		}
		// 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
		// NOTE: from target 1.2 on, field's declaring class is touched if any different from receiver type
		// and not from Object or implicit static field access.	
//		if (fieldBinding.declaringClass != this.actualReceiverType
//			&& !this.actualReceiverType.isArrayType()	
//			&& fieldBinding.declaringClass != null
//			&& fieldBinding.constant == NotAConstant
//			&& ((currentScope.environment().options.targetJDK >= CompilerOptions.JDK1_2 
//					&& !fieldBinding.isStatic()
//					&& fieldBinding.declaringClass.id != T_Object) // no change for Object fields (if there was any)
//				|| !fieldBinding.declaringClass.canBeSeenBy(currentScope))){
//			this.codegenBinding = currentScope.enclosingSourceType().getUpdatedFieldBinding(fieldBinding, (ReferenceBinding)this.actualReceiverType);
//		}
	}
}
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.actualReceiverType = this.receiverType = scope.enclosingSourceType();
	
	if ((this.codegenBinding = this.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 variable = (VariableBinding) binding;
					if (binding instanceof LocalVariableBinding) {
						bits &= ~RestrictiveFlagMASK;  // clear bits
						bits |= LOCAL;
						if ((this.bits & IsStrictlyAssignedMASK) == 0) {
							constant = variable.constant;
						} else {
							constant = NotAConstant;
						}
						if ((!variable.isFinal()) && ((bits & DepthMASK) != 0)) {
							scope.problemReporter().cannotReferToNonFinalOuterLocal((LocalVariableBinding)variable, this);
						}
						return this.resolvedType = variable.type;
					}
					// a field
					return this.resolvedType = 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 this.resolvedType = (TypeBinding) binding;
		}
	}

	// error scenarii
	return this.resolvedType = this.reportError(scope);
}
public StringBuffer printExpression(int indent, StringBuffer output){
	
		return output.append(token);
	}
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);}
}