path: root/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedNameReference.java

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 QualifiedNameReference extends NameReference {
	public char[][] tokens;
	public FieldBinding[] otherBindings;
	public int indexOfFirstFieldBinding; //points (into tokens) for the first token that corresponds to first FieldBinding
	
	SyntheticAccessMethodBinding syntheticWriteAccessor;
	SyntheticAccessMethodBinding[] syntheticReadAccessors;
	protected FieldBinding lastFieldBinding;
public QualifiedNameReference(char[][] sources, int sourceStart, int sourceEnd) {
	super();
	tokens = sources;
	this.sourceStart = sourceStart;
	this.sourceEnd = sourceEnd;
}
public FlowInfo analyseAssignment(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, Assignment assignment, boolean isCompound) {
	if (assignment.expression != null) {
		flowInfo = assignment.expression.analyseCode(currentScope, flowContext, flowInfo).unconditionalInits();
	}
	// determine the rank until which we now we do not need any actual value for the field access
	int otherBindingsCount = otherBindings == null ? 0 : otherBindings.length;
	int indexOfFirstValueRequired = otherBindingsCount;
	while (indexOfFirstValueRequired > 0) {
		FieldBinding otherBinding = otherBindings[indexOfFirstValueRequired - 1];
		if (otherBinding.isStatic())
			break; // no longer need any value before this point
		indexOfFirstValueRequired--;
	}

	FieldBinding lastFieldBinding = null;
	if ((bits & FIELD) != 0) {
		// reading from a field
		// check if final blank field
		if ((lastFieldBinding = (FieldBinding) binding).isFinal() && currentScope.allowBlankFinalFieldAssignment(lastFieldBinding)) {
			if (!flowInfo.isDefinitelyAssigned(lastFieldBinding)) {
				currentScope.problemReporter().uninitializedBlankFinalField(lastFieldBinding, this);
			}
		}
	} else {
		if ((bits & LOCAL) != 0) {
			// first binding is a local variable
			LocalVariableBinding localBinding;
			if (!flowInfo.isDefinitelyAssigned(localBinding = (LocalVariableBinding) binding)) {
				currentScope.problemReporter().uninitializedLocalVariable(localBinding, this);
			}
			if (!flowInfo.isFakeReachable()) localBinding.used = true;			
		}
	}
	if (indexOfFirstValueRequired == 0) {
		manageEnclosingInstanceAccessIfNecessary(currentScope); // only for first binding
	}
	// all intermediate field accesses are read accesses
	if (otherBindings != null) {
		int start = indexOfFirstValueRequired == 0 ? 0 : indexOfFirstValueRequired - 1;
		for (int i = start; i < otherBindingsCount; i++) {
			if (lastFieldBinding != null) { // could be null if first was a local variable
				manageSyntheticReadAccessIfNecessary(currentScope, lastFieldBinding, i);
			}
			lastFieldBinding = otherBindings[i];
		}
	}
	if (isCompound) {
		if (binding == lastFieldBinding && currentScope.allowBlankFinalFieldAssignment(lastFieldBinding) && (!flowInfo.isDefinitelyAssigned(lastFieldBinding))) {
			currentScope.problemReporter().uninitializedBlankFinalField(lastFieldBinding, this);
		}
		manageSyntheticReadAccessIfNecessary(currentScope, lastFieldBinding, binding == lastFieldBinding ? 0 : otherBindings.length);
	}
	// the last field access is a write access
	if (lastFieldBinding.isFinal()) {
		// in a context where it can be assigned?
		if (currentScope.allowBlankFinalFieldAssignment(lastFieldBinding)) {
			if (flowInfo.isPotentiallyAssigned(lastFieldBinding)) {
				if (indexOfFirstFieldBinding == 1) { // was an implicit reference to the first field binding
					currentScope.problemReporter().duplicateInitializationOfBlankFinalField(lastFieldBinding, this);
				} else {
					currentScope.problemReporter().cannotAssignToFinalField(lastFieldBinding, this); // attempting to assign a non implicit reference
				}
			}
			flowInfo.markAsDefinitelyAssigned(lastFieldBinding);
			flowContext.recordSettingFinal(lastFieldBinding, this);
		} else {
			currentScope.problemReporter().cannotAssignToFinalField(lastFieldBinding, this);
		}
	}
	// equivalent to valuesRequired[maxOtherBindings]
	manageSyntheticWriteAccessIfNecessary(currentScope, lastFieldBinding);
	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) {

	// determine the rank until which we now we do not need any actual value for the field access
	int otherBindingsCount = otherBindings == null ? 0 : otherBindings.length;
	int indexOfFirstValueRequired;
	if (valueRequired) {
		indexOfFirstValueRequired = otherBindingsCount;
		while (indexOfFirstValueRequired > 0) {
			FieldBinding otherBinding = otherBindings[indexOfFirstValueRequired - 1];
			if (otherBinding.isStatic())
				break; // no longer need any value before this point
			indexOfFirstValueRequired--;
		}
	} else {
		indexOfFirstValueRequired = otherBindingsCount + 1;
	}
	switch (bits & RestrictiveFlagMASK) {
		case FIELD : // reading a field
			if (indexOfFirstValueRequired == 0) {
				manageSyntheticReadAccessIfNecessary(currentScope, (FieldBinding) binding, 0);
			}
			// check if reading a final blank field
			FieldBinding fieldBinding;
			if ((fieldBinding = (FieldBinding) binding).isFinal()
				&& (indexOfFirstFieldBinding == 1) // was an implicit reference to the first field binding
				&& currentScope.allowBlankFinalFieldAssignment(fieldBinding)
				&& (!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 (indexOfFirstValueRequired == 0) { 
		manageEnclosingInstanceAccessIfNecessary(currentScope); // only for first binding
	}
	if (otherBindings != null) {
		int start = indexOfFirstValueRequired == 0 ? 0 : indexOfFirstValueRequired - 1;
		for (int i = start; i < otherBindingsCount; i++) {
			manageSyntheticReadAccessIfNecessary(currentScope, otherBindings[i], i + 1);
		}
	}
	return flowInfo;
}
/**
 * Check and/or redirect the field access to the delegate receiver if any
 */
public TypeBinding checkFieldAccess(BlockScope scope) {
	// check for forward references
	FieldBinding fieldBinding = (FieldBinding) binding;
	MethodScope methodScope = scope.methodScope();
	if (methodScope.enclosingSourceType() == fieldBinding.declaringClass
		&& methodScope.fieldDeclarationIndex != MethodScope.NotInFieldDecl
		&& fieldBinding.id >= methodScope.fieldDeclarationIndex) {
		if ((!fieldBinding.isStatic() || methodScope.isStatic)
			&& this.indexOfFirstFieldBinding == 1)
			scope.problemReporter().forwardReference(this, 0, scope.enclosingSourceType());
	}
	bits &= ~RestrictiveFlagMASK; // clear bits
	bits |= FIELD;
	return getOtherFieldBindings(scope);
}
public void generateAssignment(BlockScope currentScope, CodeStream codeStream, Assignment assignment, boolean valueRequired) {
	generateReadSequence(currentScope, codeStream, true);
	// the last field access is a write access
	assignment.expression.generateCode(currentScope, codeStream, true);
	fieldStore(codeStream, lastFieldBinding, syntheticWriteAccessor, valueRequired); // equivalent to valuesRequired[maxOtherBindings]
	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 {
		generateReadSequence(currentScope, codeStream, valueRequired);
		if (valueRequired) {
			if (lastFieldBinding.declaringClass == null) { // array length
				codeStream.arraylength();
				codeStream.generateImplicitConversion(implicitConversion);
			} else {
				if (lastFieldBinding.constant != NotAConstant) {
					// inline the last field constant
					codeStream.generateConstant(lastFieldBinding.constant, implicitConversion);
				} else {					
					SyntheticAccessMethodBinding accessor = syntheticReadAccessors == null ? null : syntheticReadAccessors[syntheticReadAccessors.length - 1];
					if (accessor == null) {
						if (lastFieldBinding.isStatic()) {
							codeStream.getstatic(lastFieldBinding);
						} else {
							codeStream.getfield(lastFieldBinding);
						}
					} else {
						codeStream.invokestatic(accessor);
					}
					codeStream.generateImplicitConversion(implicitConversion);
				}
			}
		}
	}
	codeStream.recordPositionsFrom(pc, this);
}
public void generateCompoundAssignment(BlockScope currentScope, CodeStream codeStream, Expression expression, int operator, int assignmentImplicitConversion, boolean valueRequired) {
	
	generateReadSequence(currentScope, codeStream, true);
	SyntheticAccessMethodBinding accessor = syntheticReadAccessors == null ? null : syntheticReadAccessors[syntheticReadAccessors.length - 1];
	
	if (lastFieldBinding.isStatic()){
		if (accessor == null) {
			codeStream.getstatic(lastFieldBinding);
		} else {
			codeStream.invokestatic(accessor);
		}
	} else {
		codeStream.dup();
		if (accessor == null) {
			codeStream.getfield(lastFieldBinding);
		} else {
			codeStream.invokestatic(accessor);
		}
	}
	// the last field access is a write access
	// perform the actual compound operation
	int operationTypeID;
	if ((operationTypeID = implicitConversion >> 4) == T_String) {
		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);
	}
	// actual assignment
	fieldStore(codeStream, lastFieldBinding, syntheticWriteAccessor, valueRequired); // equivalent to valuesRequired[maxOtherBindings]
}
public void generatePostIncrement(BlockScope currentScope, CodeStream codeStream, CompoundAssignment postIncrement, boolean valueRequired) {
	generateReadSequence(currentScope, codeStream, true);
	SyntheticAccessMethodBinding accessor = syntheticReadAccessors == null ? null : syntheticReadAccessors[syntheticReadAccessors.length - 1];

	if (lastFieldBinding.isStatic()){
		if (accessor == null) {
			codeStream.getstatic(lastFieldBinding);
		} else {
			codeStream.invokestatic(accessor);
		}
	} else {
		codeStream.dup();
		if (accessor == null) {
			codeStream.getfield(lastFieldBinding);
		} else {
			codeStream.invokestatic(accessor);
		}
	}	
	// duplicate the old field value
	if (valueRequired) {
		if (lastFieldBinding.isStatic()) {
			if ((lastFieldBinding.type == LongBinding) || (lastFieldBinding.type == DoubleBinding)) {
				codeStream.dup2();
			} else {
				codeStream.dup();
			}
		} else { // Stack:  [owner][old field value]  ---> [old field value][owner][old field value]
			if ((lastFieldBinding.type == LongBinding) || (lastFieldBinding.type == DoubleBinding)) {
				codeStream.dup2_x1();
			} else {
				codeStream.dup_x1();
			}
		}
	}
	codeStream.generateConstant(postIncrement.expression.constant, implicitConversion);
	codeStream.sendOperator(postIncrement.operator, lastFieldBinding.type.id);
	codeStream.generateImplicitConversion(postIncrement.assignmentImplicitConversion);
	
	fieldStore(codeStream, lastFieldBinding, syntheticWriteAccessor, false);
}
/*
 * Generate code for all bindings (local and fields) excluding the last one, which may then be generated code
 * for a read or write access.
 */
public void generateReadSequence(BlockScope currentScope, CodeStream codeStream, boolean valueRequired) {

	// determine the rank until which we now we do not need any actual value for the field access
	int otherBindingsCount = otherBindings == null ? 0 : otherBindings.length;
	int indexOfFirstValueRequired;
	if (valueRequired) {
		indexOfFirstValueRequired = otherBindingsCount;
		while (indexOfFirstValueRequired > 0) {
			FieldBinding otherBinding = otherBindings[indexOfFirstValueRequired - 1];
			if (otherBinding.isStatic() || otherBinding.constant != NotAConstant)
				break; // no longer need any value before this point
			indexOfFirstValueRequired--;
		}
	} else {
		indexOfFirstValueRequired = otherBindingsCount + 1;
	}
	if (indexOfFirstValueRequired == 0) {
		switch (bits & RestrictiveFlagMASK) {
			case FIELD :
				lastFieldBinding = (FieldBinding) binding;

				// if first field is actually constant, we can inline it
				if (lastFieldBinding.constant != NotAConstant) {
					codeStream.generateConstant(lastFieldBinding.constant, 0); // no implicit conversion
					lastFieldBinding = null; // will not generate it again
					break;
				}
				if (!lastFieldBinding.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);
					}
				}
				break;
			case LOCAL : // reading the first local variable
				lastFieldBinding = null;
				LocalVariableBinding localBinding = (LocalVariableBinding) binding;

				// regular local variable read
				if (localBinding.constant != NotAConstant) {
					codeStream.generateConstant(localBinding.constant, 0); // no implicit conversion
				} else {
					// 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 {
						codeStream.load(localBinding);
					}
				}
		}
	} else {
		lastFieldBinding = null;
	}
	// all intermediate field accesses are read accesses
	// only the last field binding is a write access
	if (otherBindings != null) {
		int start = indexOfFirstValueRequired == 0 ? 0 : indexOfFirstValueRequired - 1;
		for (int i = start; i < otherBindingsCount; i++) {
			if (lastFieldBinding != null) {
				MethodBinding accessor = syntheticReadAccessors == null ? null : syntheticReadAccessors[i];
				if (accessor == null)
					if (lastFieldBinding.isStatic())
						codeStream.getstatic(lastFieldBinding);
					else
						codeStream.getfield(lastFieldBinding);
				else
					codeStream.invokestatic(accessor);
			}
			lastFieldBinding = otherBindings[i];
		}
	}
}
public void generateReceiver(CodeStream codeStream) {
	codeStream.aload_0();
}
public TypeBinding getOtherFieldBindings(BlockScope scope) {
	// At this point restrictiveFlag may ONLY have two potential value : FIELD LOCAL (i.e cast <<(VariableBinding) binding>> is valid)

	if ((bits & FIELD) != 0) {
		if (!((FieldBinding) binding).isStatic()) { //must check for the static status....
			if (indexOfFirstFieldBinding == 1) {
				//the field is the first token of the qualified reference....
				if (scope.methodScope().isStatic) {
					scope.problemReporter().staticFieldAccessToNonStaticVariable(this, (FieldBinding) binding);
					return null;
				}
			} else { //accessing to a field using a type as "receiver" is allowed only with static field	
				scope.problemReporter().staticFieldAccessToNonStaticVariable(this, (FieldBinding) binding);
				return null;
			}
		}
		if (isFieldUseDeprecated((FieldBinding) binding, scope))
			scope.problemReporter().deprecatedField((FieldBinding) binding, 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
		FieldBinding fieldBinding = (FieldBinding)binding;
		if (fieldBinding.declaringClass != null
			&& fieldBinding.constant == NotAConstant
			&& !fieldBinding.declaringClass.canBeSeenBy(scope))
				binding = new FieldBinding(fieldBinding, scope.enclosingSourceType());
	}

	TypeBinding type = ((VariableBinding) binding).type;
	int index = indexOfFirstFieldBinding;
	int length = tokens.length;
	if (index == length) { //	restrictiveFlag == FIELD
		constant = FieldReference.getConstantFor((FieldBinding) binding, false, this, index - 1);
		return type;
	}

	// allocation of the fieldBindings array	and its respective constants
	int otherBindingsLength = length - index;
	otherBindings = new FieldBinding[otherBindingsLength];
	
	// fill the first constant (the one of the binding)
	constant =
		((bits & FIELD) != 0)
			? FieldReference.getConstantFor((FieldBinding) binding, false, this, index - 1)
			: ((VariableBinding) binding).constant;

	// iteration on each field	
	while (index < length) {
		char[] token = tokens[index];
		if (type == null) return null; // could not resolve type prior to this point
		FieldBinding field = scope.getField(type, token, this);
		int place = index - indexOfFirstFieldBinding;
		otherBindings[place] = field;
		if (field.isValidBinding()) {
			if (isFieldUseDeprecated(field, scope))
				scope.problemReporter().deprecatedField(field, this);
			Constant someConstant = FieldReference.getConstantFor(field, false, this, place);
			// constant propagation can only be performed as long as the previous one is a constant too.
			if (constant != NotAConstant){
				constant = someConstant;
			}
			// 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 (field.declaringClass != type
				&& field.declaringClass != null // array.length
				&& field.constant == NotAConstant
				&& !field.declaringClass.canBeSeenBy(scope))
					otherBindings[place] = new FieldBinding(field, (ReferenceBinding)type);
			type = field.type;
			index++;
		} else {
			constant = NotAConstant; //don't fill other constants slots...
			scope.problemReporter().invalidField(this, field, index, type);
			return null;
		}
	}
	return (otherBindings[otherBindingsLength - 1]).type;
}
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, FieldBinding fieldBinding, int index) {
	// index == 0 denotes the first fieldBinding, index > 0 denotes one of the 'otherBindings'

	if (fieldBinding.constant != NotAConstant) return;
	if (fieldBinding.isPrivate()) { // private access
		if (fieldBinding.declaringClass != currentScope.enclosingSourceType()) {
			if (syntheticReadAccessors == null) {
				if (otherBindings == null)
					syntheticReadAccessors = new SyntheticAccessMethodBinding[1];
				else
					syntheticReadAccessors = new SyntheticAccessMethodBinding[otherBindings.length + 1];
			}
			syntheticReadAccessors[index] = fieldBinding.getSyntheticReadAccess();
			currentScope.problemReporter().needToEmulateFieldReadAccess(fieldBinding, this);
		}
		return;
	}
	if (fieldBinding.isProtected() // implicit protected access (only for first one)
		&& index == 0
		&& (bits & DepthMASK) != 0
		&& (fieldBinding.declaringClass.getPackage() 
			!= currentScope.enclosingSourceType().getPackage())){	
			if (syntheticReadAccessors == null) {
				if (otherBindings == null)
					syntheticReadAccessors = new SyntheticAccessMethodBinding[1];
				else
					syntheticReadAccessors = new SyntheticAccessMethodBinding[otherBindings.length + 1];
			}
			syntheticReadAccessors[index] = 
				((SourceTypeBinding)currentScope.enclosingSourceType().
					enclosingTypeAt((bits & DepthMASK) >> DepthSHIFT)).
						addSyntheticMethod(fieldBinding, true);
			currentScope.problemReporter().needToEmulateFieldReadAccess(fieldBinding, this);
	}
}
/*
 * No need to emulate access to protected fields since not implicitly accessed
 */
public void manageSyntheticWriteAccessIfNecessary(BlockScope currentScope, FieldBinding fieldBinding) {
	if (fieldBinding.isPrivate() && fieldBinding.declaringClass != currentScope.enclosingSourceType()) {
		syntheticWriteAccessor = fieldBinding.getSyntheticWriteAccess();
		currentScope.problemReporter().needToEmulateFieldWriteAccess(fieldBinding, this);
	}
}
/**
 * Normal field binding did not work, try to bind to a field of the delegate receiver.
 */
public TypeBinding reportError(BlockScope scope) {
	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) {
	// field and/or local are done before type lookups

	// the only available value for the restrictiveFlag BEFORE
	// the TC is Flag_Type Flag_LocalField and Flag_TypeLocalField 
	this.receiverType = scope.enclosingSourceType();
	
	constant = Constant.NotAConstant;
	if ((binding = scope.getBinding(tokens, bits & RestrictiveFlagMASK, this)).isValidBinding()) {
		switch (bits & RestrictiveFlagMASK) {
			case VARIABLE : //============only variable===========
			case TYPE | VARIABLE :
				if (binding instanceof LocalVariableBinding) {
					if (!((LocalVariableBinding) binding).isFinal() && ((bits & DepthMASK) != 0))
						scope.problemReporter().cannotReferToNonFinalOuterLocal((LocalVariableBinding) binding, this);
					bits &= ~RestrictiveFlagMASK;  // clear bits
					bits |= LOCAL;
					return getOtherFieldBindings(scope);
				}
				if (binding instanceof FieldBinding) {
					// check for forward references
					FieldBinding fieldBinding = (FieldBinding) binding;
					MethodScope methodScope = scope.methodScope() ;
					if (methodScope.enclosingSourceType() == fieldBinding.declaringClass
						&& methodScope.fieldDeclarationIndex != MethodScope.NotInFieldDecl
						&& fieldBinding.id >= methodScope.fieldDeclarationIndex) {
							if ((!fieldBinding.isStatic() || methodScope.isStatic) && this.indexOfFirstFieldBinding == 1)
								scope.problemReporter().forwardReference(this,0,scope.enclosingSourceType());
					}					
					bits &= ~RestrictiveFlagMASK;  // clear bits
					bits |= FIELD;					
					return getOtherFieldBindings(scope);
				}

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

	//========error cases===============
	return this.reportError(scope);
}
public void setFieldIndex(int index){

	indexOfFirstFieldBinding = index ;
}
public String toStringExpression() {
	/* slow speed */
	StringBuffer buffer = new StringBuffer();
	for (int i = 0; i < tokens.length; i++) {
		buffer.append(tokens[i]);
		if (i < (tokens.length - 1)) {
			buffer.append("."/*nonNLS*/);
		}
	}
	return buffer.toString();
}
public void traverse(IAbstractSyntaxTreeVisitor visitor, BlockScope scope) {
	visitor.visit(this, scope);
	visitor.endVisit(this, scope);
}
public  String unboundReferenceErrorName(){

	return new String(tokens[0]);}
}