Attachment #113015 for bug #247612

Lines 1065-1071 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java (-1 / +1 lines)
1065	public ReferenceBinding[] memberTypes() {	1065	public ReferenceBinding[] memberTypes() {
1066	return this.memberTypes;	1066	return this.memberTypes;
1067	}	1067	}
1068	///** @deprecated */	1068	/** @deprecated */
1069	public FieldBinding getUpdatedFieldBinding(FieldBinding targetField, ReferenceBinding newDeclaringClass) {	1069	public FieldBinding getUpdatedFieldBinding(FieldBinding targetField, ReferenceBinding newDeclaringClass) {
1070	if (this.synthetics == null)	1070	if (this.synthetics == null)
1071	this.synthetics = new HashMap[MAX_SYNTHETICS];	1071	this.synthetics = new HashMap[MAX_SYNTHETICS];




import org.eclipse.jdt.internal.compiler.codegen.BranchLabel;
import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
import org.eclipse.jdt.internal.compiler.codegen.ConstantPool;
import org.eclipse.jdt.internal.compiler.codegen.Opcodes;
import org.eclipse.jdt.internal.compiler.flow.ExceptionHandlingFlowContext;
import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
import org.eclipse.jdt.internal.compiler.flow.InitializationFlowContext;

			falseLabel.place();
			codeStream.iconst_0();
			jumpLabel.place();
			codeStream.fieldAccess0(Opcodes.OPC_putstatic, this.assertionSyntheticFieldBinding, null /* default declaringClass */);
		}
		// generate static fields/initializers/enum constants
		final FieldDeclaration[] fieldDeclarations = declaringType.fields;

						if (fieldDecl.getKind() == AbstractVariableDeclaration.ENUM_CONSTANT) {
							codeStream.dup();
							codeStream.generateInlinedValue(fieldDecl.binding.id);
							codeStream.fieldAccess0(Opcodes.OPC_getstatic, fieldDecl.binding, null /* default declaringClass */);
							codeStream.aastore();
						}
					}
				}
			}
			codeStream.fieldAccess0(Opcodes.OPC_putstatic, declaringType.enumValuesSyntheticfield, null /* default declaringClass */);
			if (remainingFieldCount != 0) {
				// if fields that are not enum constants need to be generated (static initializer/static field)
				for (int i = 0, max = fieldDeclarations.length; i < max; i++) {

Lines 228-234 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ConstructorDeclaration.java (-2 / +2 lines)
228	if ((syntheticArg = syntheticArgs[i]).matchingField != null) {	228	if ((syntheticArg = syntheticArgs[i]).matchingField != null) {
229	codeStream.aload_0();	229	codeStream.aload_0();
230	codeStream.load(syntheticArg);	230	codeStream.load(syntheticArg);
231	codeStream.putfield(syntheticArg.matchingField);	231	codeStream.fieldAccess0(Opcodes.OPC_putfield, syntheticArg.matchingField, null /* default declaringClass */);
232	}	232	}
233	}	233	}
234	syntheticArgs = nestedType.syntheticOuterLocalVariables();	234	syntheticArgs = nestedType.syntheticOuterLocalVariables();
Lines 237-243 Link Here
237	if ((syntheticArg = syntheticArgs[i]).matchingField != null) {	237	if ((syntheticArg = syntheticArgs[i]).matchingField != null) {
238	codeStream.aload_0();	238	codeStream.aload_0();
239	codeStream.load(syntheticArg);	239	codeStream.load(syntheticArg);
240	codeStream.putfield(syntheticArg.matchingField);	240	codeStream.fieldAccess0(Opcodes.OPC_putfield, syntheticArg.matchingField, null /* default declaringClass */);
241	}	241	}
242	}	242	}
243	}	243	}

Lines 101-107 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/AssertStatement.java (-1 / +1 lines)
101		101
102	if (this.assertionSyntheticFieldBinding != null) {	102	if (this.assertionSyntheticFieldBinding != null) {
103	BranchLabel assertionActivationLabel = new BranchLabel(codeStream);	103	BranchLabel assertionActivationLabel = new BranchLabel(codeStream);
104	codeStream.getstatic(this.assertionSyntheticFieldBinding);	104	codeStream.fieldAccess0(Opcodes.OPC_getstatic, this.assertionSyntheticFieldBinding, null /* default declaringClass */);
105	codeStream.ifne(assertionActivationLabel);	105	codeStream.ifne(assertionActivationLabel);
106		106
107	BranchLabel falseLabel;	107	BranchLabel falseLabel;




import org.eclipse.jdt.internal.compiler.codegen.Opcodes;
import org.eclipse.jdt.internal.compiler.flow.FlowContext;
import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.impl.Constant;
import org.eclipse.jdt.internal.compiler.lookup.Binding;
import org.eclipse.jdt.internal.compiler.lookup.BlockScope;

	public Expression receiver;
	public char[] token;
	public FieldBinding binding;															// exact binding resulting from lookup
	protected FieldBinding codegenBinding;									// actual binding used for code generation (if no synthetic accessor)
	public MethodBinding[] syntheticAccessors; // [0]=read accessor [1]=write accessor

	public long nameSourcePosition; //(start<<32)+end
	public TypeBinding actualReceiverType;
	public TypeBinding genericCast;

public FieldReference(char[] source, long pos) {


public void generateAssignment(BlockScope currentScope, CodeStream codeStream, Assignment assignment, boolean valueRequired) {
	int pc = codeStream.position;
	FieldBinding codegenBinding = this.binding.original();
	this.receiver.generateCode(
		currentScope,
		codeStream,
		!codegenBinding.isStatic());
	codeStream.recordPositionsFrom(pc, this.sourceStart);
	assignment.expression.generateCode(currentScope, codeStream, true);
	fieldStore(
		codeStream,
		codegenBinding,
		this.syntheticAccessors == null ? null : this.syntheticAccessors[FieldReference.WRITE],
		valueRequired);
	if (valueRequired) {

		codeStream.recordPositionsFrom(pc, this.sourceStart);
		return;
	}
	FieldBinding codegenBinding = this.binding.original();
	boolean isStatic = codegenBinding.isStatic();
	boolean isThisReceiver = this.receiver instanceof ThisReference;
	Constant fieldConstant = codegenBinding.constant();
	if (fieldConstant != Constant.NotAConstant) {
		if (!isThisReceiver) {
			this.receiver.generateCode(currentScope, codeStream, !isStatic);

			|| (this.genericCast != null)) {
		this.receiver.generateCode(currentScope, codeStream, !isStatic);
		pc = codeStream.position;
		if (codegenBinding.declaringClass == null) { // array length
			codeStream.arraylength();
			if (valueRequired) {
				codeStream.generateImplicitConversion(this.implicitConversion);

			}
		} else {
			if (this.syntheticAccessors == null || this.syntheticAccessors[FieldReference.READ] == null) {
				TypeBinding constantPoolDeclaringClass = getConstantPoolDeclaringClass(currentScope, codegenBinding, this.actualReceiverType, this.receiver.isImplicitThis());
				if (isStatic) {
					codeStream.fieldAccess0(Opcodes.OPC_getstatic, codegenBinding, constantPoolDeclaringClass);
				} else {
					codeStream.fieldAccess0(Opcodes.OPC_getfield, codegenBinding, constantPoolDeclaringClass);
				}
			} else {
				codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[FieldReference.READ], null /* default declaringClass */);

				boolean isUnboxing = (this.implicitConversion & TypeIds.UNBOXING) != 0;
				// conversion only generated if unboxing
				if (isUnboxing) codeStream.generateImplicitConversion(this.implicitConversion);
				switch (isUnboxing ? postConversionType(currentScope).id : codegenBinding.type.id) {
					case T_long :
					case T_double :
						codeStream.pop2();

		if (isThisReceiver) {
			if (isStatic){
				// if no valueRequired, still need possible side-effects of <clinit> invocation, if field belongs to different class
				if (this.binding.original().declaringClass != this.actualReceiverType.erasure()) {
					MethodBinding accessor = this.syntheticAccessors == null ? null : this.syntheticAccessors[FieldReference.READ];
					if (accessor == null) {
						TypeBinding constantPoolDeclaringClass = getConstantPoolDeclaringClass(currentScope, codegenBinding, this.actualReceiverType, this.receiver.isImplicitThis());
						codeStream.fieldAccess0(Opcodes.OPC_getstatic, codegenBinding, constantPoolDeclaringClass);
					} else {
						codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);
					}
					switch (codegenBinding.type.id) {
						case T_long :
						case T_double :
							codeStream.pop2();


public void generateCompoundAssignment(BlockScope currentScope, CodeStream codeStream, Expression expression, int operator, int assignmentImplicitConversion, boolean valueRequired) {
	boolean isStatic;
	FieldBinding codegenBinding = this.binding.original();
	this.receiver.generateCode(currentScope, codeStream, !(isStatic = codegenBinding.isStatic()));
		codeStream,
		!(isStatic = this.codegenBinding.isStatic()));
	if (isStatic) {
		if (this.syntheticAccessors == null || this.syntheticAccessors[FieldReference.READ] == null) {
			TypeBinding constantPoolDeclaringClass = getConstantPoolDeclaringClass(currentScope, codegenBinding, this.actualReceiverType, this.receiver.isImplicitThis());
			codeStream.fieldAccess0(Opcodes.OPC_getstatic, codegenBinding, constantPoolDeclaringClass);
		} else {
			codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[FieldReference.READ], null /* default declaringClass */);
		}
	} else {
		codeStream.dup();
		if (this.syntheticAccessors == null || this.syntheticAccessors[FieldReference.READ] == null) {
			TypeBinding constantPoolDeclaringClass = getConstantPoolDeclaringClass(currentScope, codegenBinding, this.actualReceiverType, this.receiver.isImplicitThis());
			codeStream.fieldAccess0(Opcodes.OPC_getfield, codegenBinding, constantPoolDeclaringClass);
		} else {
			codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[FieldReference.READ], null /* default declaringClass */);
		}

			// cast the value back to the array reference type
			codeStream.generateImplicitConversion(assignmentImplicitConversion);
	}
	fieldStore(codeStream, codegenBinding, this.syntheticAccessors == null ? null : this.syntheticAccessors[FieldReference.WRITE], valueRequired);
		codeStream,
		this.codegenBinding,
		this.syntheticAccessors == null ? null : this.syntheticAccessors[FieldReference.WRITE],
		valueRequired);
	// no need for generic cast as value got dupped
}

public void generatePostIncrement(BlockScope currentScope, CodeStream codeStream, CompoundAssignment postIncrement, boolean valueRequired) {
	boolean isStatic;
	FieldBinding codegenBinding = this.binding.original();
	this.receiver.generateCode(currentScope, codeStream, !(isStatic = codegenBinding.isStatic()));
		codeStream,
		!(isStatic = this.codegenBinding.isStatic()));
	if (isStatic) {
		if (this.syntheticAccessors == null || this.syntheticAccessors[FieldReference.READ] == null) {
			TypeBinding constantPoolDeclaringClass = getConstantPoolDeclaringClass(currentScope, codegenBinding, this.actualReceiverType, this.receiver.isImplicitThis());
			codeStream.fieldAccess0(Opcodes.OPC_getstatic, codegenBinding, constantPoolDeclaringClass);
		} else {
			codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[FieldReference.READ], null /* default declaringClass */);
		}
	} else {
		codeStream.dup();
		if (this.syntheticAccessors == null || this.syntheticAccessors[FieldReference.READ] == null) {
			TypeBinding constantPoolDeclaringClass = getConstantPoolDeclaringClass(currentScope, codegenBinding, this.actualReceiverType, this.receiver.isImplicitThis());
			codeStream.fieldAccess0(Opcodes.OPC_getfield, codegenBinding, constantPoolDeclaringClass);
		} else {
			codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[FieldReference.READ], null /* default declaringClass */);
		}

		codeStream.checkcast(this.genericCast);
		operandType = this.genericCast;
	} else {
		operandType = codegenBinding.type;
	}	
	if (valueRequired) {
		if (isStatic) {
			switch (operandType.id) {
				case TypeIds.T_long :
				case TypeIds.T_double :
					codeStream.dup2();
					break;
				default :
					codeStream.dup();
					break;
			}			
		} else { // Stack:  [owner][old field value]  ---> [old field value][owner][old field value]
			switch (operandType.id) {
				case TypeIds.T_long :
				case TypeIds.T_double :
					codeStream.dup2_x1();
					break;
				default :
					codeStream.dup_x1();
					break;
			}			
		}
	}
	codeStream.generateImplicitConversion(this.implicitConversion);		

	codeStream.sendOperator(postIncrement.operator, this.implicitConversion & TypeIds.COMPILE_TYPE_MASK);
	codeStream.generateImplicitConversion(
		postIncrement.preAssignImplicitConversion);
	fieldStore(codeStream, codegenBinding, this.syntheticAccessors == null ? null : this.syntheticAccessors[FieldReference.WRITE], false);
}

/**

	if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) != 0)	return;

	// if field from parameterized type got found, use the original field at codegen time
	FieldBinding codegenBinding = this.binding.original();

	if (this.binding.isPrivate()) {
		if ((currentScope.enclosingSourceType() != codegenBinding.declaringClass)
				&& this.binding.constant() == Constant.NotAConstant) {
			if (this.syntheticAccessors == null)
				this.syntheticAccessors = new MethodBinding[2];
			this.syntheticAccessors[isReadAccess ? FieldReference.READ : FieldReference.WRITE] =
				((SourceTypeBinding) codegenBinding.declaringClass).addSyntheticMethod(codegenBinding, isReadAccess);
			currentScope.problemReporter().needToEmulateFieldAccess(codegenBinding, this, isReadAccess);
			return;
		}


				.currentCompatibleType);
		if (this.syntheticAccessors == null)
			this.syntheticAccessors = new MethodBinding[2];
		this.syntheticAccessors[isReadAccess ? FieldReference.READ : FieldReference.WRITE] = destinationType.addSyntheticMethod(codegenBinding, isReadAccess);
		currentScope.problemReporter().needToEmulateFieldAccess(codegenBinding, this, isReadAccess);
		return;

	} else if (this.binding.isProtected()) {

					(this.bits & ASTNode.DepthMASK) >> ASTNode.DepthSHIFT);
			if (this.syntheticAccessors == null)
				this.syntheticAccessors = new MethodBinding[2];
			this.syntheticAccessors[isReadAccess ? FieldReference.READ : FieldReference.WRITE] = currentCompatibleType.addSyntheticMethod(codegenBinding, isReadAccess);
			currentScope.problemReporter().needToEmulateFieldAccess(codegenBinding, this, isReadAccess);
			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 (this.binding.declaringClass != this.receiverType
			&& !this.receiverType.isArrayType()
			&& this.binding.declaringClass != null // array.length
			&& this.binding.constant() == Constant.NotAConstant) {
		CompilerOptions options = currentScope.compilerOptions();
		if ((options.targetJDK >= ClassFileConstants.JDK1_2
				&& (options.complianceLevel >= ClassFileConstants.JDK1_4 || !(this.receiver.isImplicitThis() && this.codegenBinding.isStatic()))
				&& this.binding.declaringClass.id != TypeIds.T_JavaLangObject) // no change for Object fields
			|| !this.binding.declaringClass.canBeSeenBy(currentScope)) {

			this.codegenBinding =
				currentScope.enclosingSourceType().getUpdatedFieldBinding(
					this.codegenBinding,
					(ReferenceBinding) this.receiverType.erasure());
		}
	}
}

public int nullStatus(FlowInfo flowInfo) {

		this.receiver.bits |= ASTNode.DisableUnnecessaryCastCheck; // will check later on
		receiverCast = true;
	}
	this.actualReceiverType = this.receiver.resolveType(scope);
	if (this.actualReceiverType == null) {
		this.constant = Constant.NotAConstant;
		return null;
	}
	if (receiverCast) {
		 // due to change of declaring class with receiver type, only identity cast should be notified
		if (((CastExpression)this.receiver).expression.resolvedType == this.actualReceiverType) {
				scope.problemReporter().unnecessaryCast((CastExpression)this.receiver);
		}
	}
	// the case receiverType.isArrayType and token = 'length' is handled by the scope API
	FieldBinding fieldBinding = this.binding = scope.getField(this.actualReceiverType, this.token, this);
	if (!fieldBinding.isValidBinding()) {
		this.constant = Constant.NotAConstant;
		if (this.receiver.resolvedType instanceof ProblemReferenceBinding) {
			// problem already got signaled on receiver, do not report secondary problem
			return null;
		}
		scope.problemReporter().invalidField(this, this.actualReceiverType);
		return null;
	}
	TypeBinding receiverErasure = this.actualReceiverType.erasure();
	if (receiverErasure instanceof ReferenceBinding) {
		if (receiverErasure.findSuperTypeOriginatingFrom(fieldBinding.declaringClass) == null) {
			this.actualReceiverType = fieldBinding.declaringClass; // handle indirect inheritance thru variable secondary bound
		}
	}
	this.receiver.computeConversion(scope, this.actualReceiverType, this.actualReceiverType);
	if (isFieldUseDeprecated(fieldBinding, scope, (this.bits & ASTNode.IsStrictlyAssigned) !=0)) {
		scope.problemReporter().deprecatedField(fieldBinding, this);
	}

		}
		ReferenceBinding declaringClass = this.binding.declaringClass;
		if (!isImplicitThisRcv
				&& declaringClass != this.actualReceiverType
				&& declaringClass.canBeSeenBy(scope)) {
			scope.problemReporter().indirectAccessToStaticField(this, fieldBinding);
		}

}

public void setActualReceiverType(ReferenceBinding receiverType) {
	this.actualReceiverType = receiverType;
}

public void setDepth(int depth) {




					}
					// managing private access
					if ((this.syntheticAccessors == null) || (this.syntheticAccessors[SingleNameReference.READ] == null)) {
						TypeBinding constantPoolDeclaringClass = getConstantPoolDeclaringClass(currentScope, fieldBinding, this.actualReceiverType, true /* implicit this */);
						codeStream.fieldAccess0(Opcodes.OPC_getstatic, fieldBinding, constantPoolDeclaringClass);
					} else {
						codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[SingleNameReference.READ], null /* default declaringClass */);
					}

					}
					// managing private access
					if ((this.syntheticAccessors == null) || (this.syntheticAccessors[SingleNameReference.READ] == null)) {
						TypeBinding constantPoolDeclaringClass = getConstantPoolDeclaringClass(currentScope, fieldBinding, this.actualReceiverType, true /* implicit this */);
						codeStream.fieldAccess0(Opcodes.OPC_getfield, fieldBinding, constantPoolDeclaringClass);
					} else {
						codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[SingleNameReference.READ], null /* default declaringClass */);
					}

			FieldBinding fieldBinding;
			if ((fieldBinding = (FieldBinding) this.codegenBinding).isStatic()) {
				if ((this.syntheticAccessors == null) || (this.syntheticAccessors[SingleNameReference.READ] == null)) {
					TypeBinding constantPoolDeclaringClass = getConstantPoolDeclaringClass(currentScope, fieldBinding, this.actualReceiverType, true /* implicit this */);					
					codeStream.fieldAccess0(Opcodes.OPC_getstatic, fieldBinding, constantPoolDeclaringClass);
				} else {
					codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[SingleNameReference.READ], null /* default declaringClass */);
				}

				}
				codeStream.dup();
				if ((this.syntheticAccessors == null) || (this.syntheticAccessors[SingleNameReference.READ] == null)) {
					TypeBinding constantPoolDeclaringClass = getConstantPoolDeclaringClass(currentScope, fieldBinding, this.actualReceiverType, true /* implicit this */);
					codeStream.fieldAccess0(Opcodes.OPC_getfield, fieldBinding, constantPoolDeclaringClass);
				} else {
					codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[SingleNameReference.READ], null /* default declaringClass */);
				}

			FieldBinding fieldBinding;
			if ((fieldBinding = (FieldBinding) this.codegenBinding).isStatic()) {
				if ((this.syntheticAccessors == null) || (this.syntheticAccessors[SingleNameReference.READ] == null)) {
					TypeBinding constantPoolDeclaringClass = getConstantPoolDeclaringClass(currentScope, fieldBinding, this.actualReceiverType, true /* implicit this */);
					codeStream.fieldAccess0(Opcodes.OPC_getstatic, fieldBinding, constantPoolDeclaringClass);
				} else {
					codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[SingleNameReference.READ], null /* default declaringClass */);
				}

				}
				codeStream.dup();
				if ((this.syntheticAccessors == null) || (this.syntheticAccessors[SingleNameReference.READ] == null)) {
					TypeBinding constantPoolDeclaringClass = getConstantPoolDeclaringClass(currentScope, fieldBinding, this.actualReceiverType, true /* implicit this */);
					codeStream.fieldAccess0(Opcodes.OPC_getfield, fieldBinding, constantPoolDeclaringClass);
				} else {
					codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[SingleNameReference.READ], null /* default declaringClass */);
				}

			currentScope.problemReporter().needToEmulateFieldAccess(codegenField, this, isReadAccess);
			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 // array.length
				&& fieldBinding.constant() == Constant.NotAConstant) {
			CompilerOptions options = currentScope.compilerOptions();
			if ((options.targetJDK >= ClassFileConstants.JDK1_2
					&& (options.complianceLevel >= ClassFileConstants.JDK1_4 || !fieldBinding.isStatic())
					&& fieldBinding.declaringClass.id != TypeIds.T_JavaLangObject) // no change for Object fields
					|| !fieldBinding.declaringClass.canBeSeenBy(currentScope)) {

					this.codegenBinding =
					    currentScope.enclosingSourceType().getUpdatedFieldBinding(
						       codegenField,
						        (ReferenceBinding)this.actualReceiverType.erasure());
			}
		}
	}
}





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

import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.codegen.*;
import org.eclipse.jdt.internal.compiler.flow.*;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.impl.Constant;
import org.eclipse.jdt.internal.compiler.lookup.*;

public abstract class Reference extends Expression  {

public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
	return flowInfo;
}

public FieldBinding fieldBinding() {
	//this method should be sent one FIELD-tagged references
	//  (ref.bits & BindingIds.FIELD != 0)()
	return null ;
}

public void fieldStore(CodeStream codeStream, FieldBinding fieldBinding, MethodBinding syntheticWriteAccessor, boolean valueRequired) {
	int pc = codeStream.position;
	if (fieldBinding.isStatic()) {
		if (valueRequired) {
			switch (fieldBinding.type.id) {
				case TypeIds.T_long :
				case TypeIds.T_double :
					codeStream.dup2();
					break;
				default : 
					codeStream.dup();
					break;
			}
		}
		if (syntheticWriteAccessor == null) {
			codeStream.fieldAccess0(Opcodes.OPC_putstatic, fieldBinding, null /* default declaringClass */);
		} else {
			codeStream.invoke(Opcodes.OPC_invokestatic, syntheticWriteAccessor, null /* default declaringClass */);
		}
	} else { // Stack:  [owner][new field value]  ---> [new field value][owner][new field value]
		if (valueRequired) {
			switch (fieldBinding.type.id) {
				case TypeIds.T_long :
				case TypeIds.T_double :
					codeStream.dup2_x1();
					break;
				default : 
					codeStream.dup_x1();
					break;
			}
		}
		if (syntheticWriteAccessor == null) {
			codeStream.fieldAccess0(Opcodes.OPC_putfield, fieldBinding, null /* default declaringClass */);
		} else {
			codeStream.invoke(Opcodes.OPC_invokestatic, syntheticWriteAccessor, null /* default declaringClass */);
		}
	}
	codeStream.recordPositionsFrom(pc, this.sourceStart);
}

public abstract void generateAssignment(BlockScope currentScope, CodeStream codeStream, Assignment assignment, boolean valueRequired);

public abstract void generateCompoundAssignment(BlockScope currentScope, CodeStream codeStream, Expression expression, int operator, int assignmentImplicitConversion, boolean valueRequired);




					if (scopeModifiers == -1) scopeModifiers = scope.getDeclarationModifiers();
					scope.problemReporter().javadocInvalidValueReference(fieldRef.sourceStart, fieldRef.sourceEnd, scopeModifiers);
				}
				else if (fieldRef.actualReceiverType != null) {
					if (scope.enclosingSourceType().isCompatibleWith(fieldRef.actualReceiverType)) {
						fieldRef.bits |= ASTNode.SuperAccess;
					}
					fieldRef.methodBinding = scope.findMethod((ReferenceBinding)fieldRef.actualReceiverType, fieldRef.token, new TypeBinding[0], fieldRef);
				}
			}


			}

			// Verify type references
			if (!hasProblems && fieldRef.binding != null && fieldRef.binding.isValidBinding() && fieldRef.actualReceiverType instanceof ReferenceBinding) {
				ReferenceBinding resolvedType = (ReferenceBinding) fieldRef.actualReceiverType;
				verifyTypeReference(fieldRef, fieldRef.receiver, scope, source15, resolvedType, fieldRef.binding.modifiers);
			}


Lines 193-199 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/MessageSend.java (-2 / +2 lines)
193	return this.genericTypeArguments;	193	return this.genericTypeArguments;
194	}	194	}
195		195
196	protected TypeBinding getConstantPoolDeclaringClass(BlockScope currentScope) {	196	public static TypeBinding getConstantPoolDeclaringClass(BlockScope currentScope, MethodBinding methodBinding, TypeBinding actualReceiverType, boolean isReceiverImplicitThis, boolean hasGenericCast) {
197	// constantpool declaringClass	197	// constantpool declaringClass
198	MethodBinding codegenBinding = this.binding.original();	198	MethodBinding codegenBinding = this.binding.original();
199	TypeBinding constantPoolDeclaringClass = codegenBinding.declaringClass;	199	TypeBinding constantPoolDeclaringClass = codegenBinding.declaringClass;
Lines 209-215 Link Here
209	// for runtime compatibility on 1.2 VMs : change the declaring class of the binding	209	// for runtime compatibility on 1.2 VMs : change the declaring class of the binding
210	// NOTE: from target 1.2 on, method's declaring class is touched if any different from receiver type	210	// NOTE: from target 1.2 on, method's declaring class is touched if any different from receiver type
211	// and not from Object or implicit static method call.	211	// and not from Object or implicit static method call.
212	if (constantPoolDeclaringClass != this.actualReceiverType && this.receiverGenericCast == null && !this.actualReceiverType.isArrayType()) {	212	if (constantPoolDeclaringClass != this.actualReceiverType.erasure() && this.receiverGenericCast == null && !this.actualReceiverType.isArrayType()) {
213	CompilerOptions options = currentScope.compilerOptions();	213	CompilerOptions options = currentScope.compilerOptions();
214	if ((options.targetJDK >= ClassFileConstants.JDK1_2	214	if ((options.targetJDK >= ClassFileConstants.JDK1_2
215	&& (options.complianceLevel >= ClassFileConstants.JDK1_4 \|\| !(this.receiver.isImplicitThis() && codegenBinding.isStatic()))	215	&& (options.complianceLevel >= ClassFileConstants.JDK1_4 \|\| !(this.receiver.isImplicitThis() && codegenBinding.isStatic()))





		this.constant = Constant.NotAConstant;
		if (this.receiver == null) {
			this.actualReceiverType = scope.enclosingReceiverType();
		} else if (scope.kind == Scope.CLASS_SCOPE) {
			this.actualReceiverType = this.receiver.resolveType((ClassScope) scope);
		} else {
			this.actualReceiverType = this.receiver.resolveType((BlockScope)scope);
		}
		if (this.actualReceiverType == null) {
			return null;
		}

		Binding fieldBinding = (this.receiver != null && this.receiver.isThis())
			? scope.classScope().getBinding(this.token, this.bits & RestrictiveFlagMASK, this, true /*resolve*/)
			: scope.getField(this.actualReceiverType, this.token, this);
		if (!fieldBinding.isValidBinding()) {
			// implicit lookup may discover issues due to static/constructor contexts. javadoc must be resilient
			switch (fieldBinding.problemId()) {

				// problem already got signaled on receiver, do not report secondary problem
				return null;
			}
			if (this.actualReceiverType instanceof ReferenceBinding) {
				ReferenceBinding refBinding = (ReferenceBinding) this.actualReceiverType;
				MethodBinding possibleMethod = this.receiver.isThis()
					? scope.getImplicitMethod(this.token, Binding.NO_TYPES, this)
					: scope.getMethod(refBinding, this.token, Binding.NO_TYPES, this);

				} else {
					ProblemMethodBinding problemMethodBinding = (ProblemMethodBinding) possibleMethod;
					if (problemMethodBinding.closestMatch == null) {
						scope.problemReporter().javadocInvalidField(this, fieldBinding, this.actualReceiverType, scope.getDeclarationModifiers());
					} else {
						this.methodBinding = problemMethodBinding.closestMatch;
					}




							codeStream.pop();
						}
					} else {
						SyntheticMethodBinding accessor = this.syntheticReadAccessors == null ? null : this.syntheticReadAccessors[this.syntheticReadAccessors.length - 1];
							this.syntheticReadAccessors == null
								? null
								: this.syntheticReadAccessors[this.syntheticReadAccessors.length - 1];
						if (accessor == null) {
							if (isStatic) {
								codeStream.fieldAccess(Opcodes.OPC_getstatic, lastFieldBinding, null /* default declaringClass */);
							} else {
								codeStream.fieldAccess(Opcodes.OPC_getfield, lastFieldBinding, null /* default declaringClass */);
							}
						} else {
							codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);

			: this.syntheticReadAccessors[this.syntheticReadAccessors.length - 1];
	if (lastFieldBinding.isStatic()) {
		if (accessor == null) {
			codeStream.fieldAccess(Opcodes.OPC_getstatic, lastFieldBinding, null /* default declaringClass */);
		} else {
			codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);
		}
	} else {
		codeStream.dup();
		if (accessor == null) {
			codeStream.fieldAccess(Opcodes.OPC_getfield, lastFieldBinding, null /* default declaringClass */);
		} else {
			codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);
		}

			: this.syntheticReadAccessors[this.syntheticReadAccessors.length - 1];
	if (lastFieldBinding.isStatic()) {
		if (accessor == null) {
			codeStream.fieldAccess(Opcodes.OPC_getstatic, lastFieldBinding, null /* default declaringClass */);
		} else {
			codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);
		}
	} else {
		codeStream.dup();
		if (accessor == null) {
			codeStream.fieldAccess(Opcodes.OPC_getfield, lastFieldBinding, null /* default declaringClass */);
		} else {
			codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);
		}

						MethodBinding accessor = this.syntheticReadAccessors == null ? null : this.syntheticReadAccessors[i];
						if (accessor == null) {
							if (lastFieldBinding.isStatic()) {
								codeStream.fieldAccess(Opcodes.OPC_getstatic, lastFieldBinding, null /* default declaringClass */);
							} else {
								codeStream.fieldAccess(Opcodes.OPC_getfield, lastFieldBinding, null /* default declaringClass */);
							}
						} else {
							codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);

								if (((FieldBinding)this.binding).original().declaringClass != this.actualReceiverType.erasure()) {
									MethodBinding accessor = this.syntheticReadAccessors == null ? null : this.syntheticReadAccessors[i];
									if (accessor == null) {
										codeStream.fieldAccess(Opcodes.OPC_getstatic, lastFieldBinding, null /* default declaringClass */);
									} else {
										codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);
									}

Lines 104-112 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/FieldDeclaration.java (-2 / +2 lines)
104	this.initialization.generateCode(currentScope, codeStream, true);	104	this.initialization.generateCode(currentScope, codeStream, true);
105	// store into field	105	// store into field
106	if (isStatic) {	106	if (isStatic) {
107	codeStream.putstatic(this.binding);	107	codeStream.fieldAccess0(Opcodes.OPC_putstatic, this.binding, null /* default declaringClass */);
108	} else {	108	} else {
109	codeStream.putfield(this.binding);	109	codeStream.fieldAccess0(Opcodes.OPC_putfield, this.binding, null /* default declaringClass */);
110	}	110	}
111	}	111	}
112	codeStream.recordPositionsFrom(pc, this.sourceStart);	112	codeStream.recordPositionsFrom(pc, this.sourceStart);




import org.eclipse.jdt.internal.compiler.ast.OperatorIds;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.flow.UnconditionalFlowInfo;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.impl.Constant;
import org.eclipse.jdt.internal.compiler.lookup.*;
import org.eclipse.jdt.internal.compiler.problem.AbortMethod;

	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_fdiv;
}

public void fieldAccess0(byte opcode, FieldBinding fieldBinding, TypeBinding declaringClass) {
	if (declaringClass == null) declaringClass = fieldBinding.declaringClass;
	if (declaringClass.leafComponentType().isNestedType()) {
		this.classFile.recordInnerClasses(declaringClass);
	}
	TypeBinding returnType = fieldBinding.type;
	int returnTypeSize;
	switch (returnType.id) {
		case TypeIds.T_long :
		case TypeIds.T_double :
			returnTypeSize = 2;
			break;
		default :
			returnTypeSize = 1;
			break;
	}
	this.fieldAccess(opcode, returnTypeSize, declaringClass.constantPoolName(), fieldBinding.name, returnType.signature());
}

private void fieldAccess(byte opcode, int returnTypeSize, char[] declaringClass, char[] fieldName, char[] signature) {
	this.countLabels = 0;
	switch(opcode) {
		case Opcodes.OPC_getfield :
			if (returnTypeSize == 2) {
				this.stackDepth++;
			}
			break;
		case Opcodes.OPC_getstatic :
			if (returnTypeSize == 2) {
				this.stackDepth += 2;
			} else {
				this.stackDepth++;
			}
			break;
		case Opcodes.OPC_putfield :
			if (returnTypeSize == 2) {
				this.stackDepth -= 3;
			} else {
				this.stackDepth -= 2;
			}
			break;
		case Opcodes.OPC_putstatic :
			if (returnTypeSize == 2) {
				this.stackDepth -= 2;
			} else {
				this.stackDepth--;
			}
	}
	if (this.stackDepth > this.stackMax) {
		this.stackMax = this.stackDepth;
	}
	if (this.classFileOffset + 2 >= this.bCodeStream.length) {
		resizeByteArray();
	}
	this.position++;
	this.bCodeStream[this.classFileOffset++] = opcode;
	writeUnsignedShort(this.constantPool.literalIndexForField(declaringClass, fieldName, signature));
}

public void fload(int iArg) {
	this.countLabels = 0;
	this.stackDepth++;

	} else {
		BranchLabel endLabel = new BranchLabel(this);
		if (syntheticFieldBinding != null) { // non interface case
			fieldAccess0(Opcodes.OPC_getstatic, syntheticFieldBinding, null /* default declaringClass */);
			dup();
			ifnonnull(endLabel);
			pop();


		if (syntheticFieldBinding != null) { // non interface case
			dup();
			fieldAccess0(Opcodes.OPC_putstatic, syntheticFieldBinding, null /* default declaringClass */);
		}
		goto_(endLabel);


	invokeAccessibleObjectSetAccessible();
}

private void generateFieldAccess(byte opcode, int returnTypeSize, char[] declaringClass, char[] name, char[] signature) {
	this.countLabels = 0;
	switch(opcode) {
		case Opcodes.OPC_getfield :
			if (returnTypeSize == 2) {
				this.stackDepth++;
			}
			break;
		case Opcodes.OPC_getstatic :
			if (returnTypeSize == 2) {
				this.stackDepth += 2;
			} else {
				this.stackDepth++;
			}
			break;
		case Opcodes.OPC_putfield :
			if (returnTypeSize == 2) {
				this.stackDepth -= 3;
			} else {
				this.stackDepth -= 2;
			}
			break;
		case Opcodes.OPC_putstatic :
			if (returnTypeSize == 2) {
				this.stackDepth -= 2;
			} else {
				this.stackDepth--;
			}
	}
	if (this.stackDepth > this.stackMax) {
		this.stackMax = this.stackDepth;
	}
	if (this.classFileOffset + 2 >= this.bCodeStream.length) {
		resizeByteArray();
	}
	this.position++;
	this.bCodeStream[this.classFileOffset++] = opcode;
	writeUnsignedShort(this.constantPool.literalIndexForField(declaringClass, name, signature));
}

private void generateFieldAccess(byte opcode, int returnTypeSize, ReferenceBinding binding, char[] name, TypeBinding type) {
	if (binding.isNestedType()) {
		this.classFile.recordInnerClasses(binding);
	}
	TypeBinding leafComponentType = type.leafComponentType();
	if (leafComponentType.isNestedType()) {
		this.classFile.recordInnerClasses(leafComponentType);
	}
	this.generateFieldAccess(opcode, returnTypeSize, binding.constantPoolName(), name, type.signature());
}

/**
 * Generates the sequence of instructions which will perform the conversion of the expression
 * on the stack into a different type (e.g. long l = someInt; --> i2l must be inserted).

	} else if (mappingSequence[0] instanceof FieldBinding) {
		FieldBinding fieldBinding = (FieldBinding) mappingSequence[0];
		aload_0();
		fieldAccess0(Opcodes.OPC_getfield, fieldBinding, null /* default declaringClass */);
	} else {
		load((LocalVariableBinding) mappingSequence[0]);
	}
	for (int i = 1, length = mappingSequence.length; i < length; i++) {
		if (mappingSequence[i] instanceof FieldBinding) {
			FieldBinding fieldBinding = (FieldBinding) mappingSequence[i];
			fieldAccess0(Opcodes.OPC_getfield, fieldBinding, null /* default declaringClass */);
		} else {
			invoke(Opcodes.OPC_invokestatic, (MethodBinding) mappingSequence[i], null /* default declaringClass */);
		}

//}
public void generateSyntheticBodyForEnumValues(SyntheticMethodBinding methodBinding) {
	ClassScope scope = ((SourceTypeBinding)methodBinding.declaringClass).scope;
	FieldBinding enumValuesSyntheticfield = scope.referenceContext.enumValuesSyntheticfield;
	initializeMaxLocals(methodBinding);
	TypeBinding enumArray = methodBinding.returnType;
	fieldAccess0(Opcodes.OPC_getstatic, scope.referenceContext.enumValuesSyntheticfield, null /* default declaringClass */);
	getstatic(enumValuesSyntheticfield);
	dup();
	astore_0();
	iconst_0();

public void generateSyntheticBodyForFieldReadAccess(SyntheticMethodBinding accessBinding) {
	initializeMaxLocals(accessBinding);
	FieldBinding fieldBinding = accessBinding.targetReadField;
	if (fieldBinding.isStatic()) {
		fieldAccess0(Opcodes.OPC_getstatic, fieldBinding, null /* default declaringClass */);
	} else {
		aload_0();
		fieldAccess0(Opcodes.OPC_getfield, fieldBinding, null /* default declaringClass */);
	}
	switch (fieldBinding.type.id) {
//		case T_void :

	FieldBinding fieldBinding = accessBinding.targetWriteField;
	if (fieldBinding.isStatic()) {
		load(fieldBinding.type, 0);
		fieldAccess0(Opcodes.OPC_putstatic, fieldBinding, null /* default declaringClass */);
	} else {
		aload_0();
		load(fieldBinding.type, 1);
		fieldAccess0(Opcodes.OPC_putfield, fieldBinding, null /* default declaringClass */);
	}
	return_();
}

	initializeMaxLocals(methodBinding);
	final BranchLabel nullLabel = new BranchLabel(this);
	FieldBinding syntheticFieldBinding = methodBinding.targetReadField;
	fieldAccess0(Opcodes.OPC_getstatic, syntheticFieldBinding, null /* default declaringClass */);
	dup();
	ifnull(nullLabel);
	areturn();

				final ExceptionLabel anyExceptionHandler = new ExceptionLabel(this, TypeBinding.LONG /* represents NoSuchFieldError*/);
				anyExceptionHandler.placeStart();
				aload_0();
				fieldAccess0(Opcodes.OPC_getstatic, fieldBinding, null /* default declaringClass */);
				invokeEnumOrdinal(enumBinding.constantPoolName());
				this.generateInlinedValue(fieldBinding.id + 1); // zero should not be returned see bug 141810
				iastore();

	}
	aload_0();
	dup();
	fieldAccess0(Opcodes.OPC_putstatic, syntheticFieldBinding, null /* default declaringClass */);
	areturn();
	removeVariable(localVariableBinding);
}

	return contents;
}

protected static TypeBinding getConstantPoolDeclaringClass(BlockScope currentScope, FieldBinding fieldBinding, TypeBinding actualReceiverType, boolean isImplicitThisReceiver) {
	FieldBinding codegenBinding = fieldBinding.original();
	ReferenceBinding constantPoolDeclaringClass = codegenBinding.declaringClass;
	// 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 (constantPoolDeclaringClass != actualReceiverType.erasure()
			&& !actualReceiverType.isArrayType()
			&& constantPoolDeclaringClass != null // array.length
			&& codegenBinding.constant() == Constant.NotAConstant) {
		CompilerOptions options = currentScope.compilerOptions();
		if ((options.targetJDK >= ClassFileConstants.JDK1_2
					&& (options.complianceLevel >= ClassFileConstants.JDK1_4 || !(isImplicitThisReceiver && codegenBinding.isStatic()))
					&& constantPoolDeclaringClass.id != TypeIds.T_JavaLangObject) // no change for Object fields
				|| !constantPoolDeclaringClass.canBeSeenBy(currentScope)) {

			return actualReceiverType.erasure();
		}
	}	
	return constantPoolDeclaringClass;
}

protected int getPosition() {
	return this.position;
}

public void getstatic(FieldBinding fieldBinding) {
	int returnTypeSize = 1;
	if ((fieldBinding.type.id == TypeIds.T_double) || (fieldBinding.type.id == TypeIds.T_long)) {
		returnTypeSize = 2;
	}
	generateFieldAccess(
			Opcodes.OPC_getstatic,
			returnTypeSize,
			fieldBinding.declaringClass,
			fieldBinding.name,
			fieldBinding.type);
}

public void getTYPE(int baseTypeID) {
	this.countLabels = 0;
	switch (baseTypeID) {
		case TypeIds.T_byte :
			// getstatic: java.lang.Byte.TYPE
			fieldAccess(
					Opcodes.OPC_getstatic,
					1, // return type size
					ConstantPool.JavaLangByteConstantPoolName,
					ConstantPool.TYPE,
					ConstantPool.JavaLangClassSignature);
			break;
		case TypeIds.T_short :
			// getstatic: java.lang.Short.TYPE
			fieldAccess(
					Opcodes.OPC_getstatic,
					1, // return type size
					ConstantPool.JavaLangShortConstantPoolName,
					ConstantPool.TYPE,
					ConstantPool.JavaLangClassSignature);
			break;
		case TypeIds.T_char :
			// getstatic: java.lang.Character.TYPE
			fieldAccess(
					Opcodes.OPC_getstatic,
					1, // return type size
					ConstantPool.JavaLangCharacterConstantPoolName,
					ConstantPool.TYPE,
					ConstantPool.JavaLangClassSignature);
			break;
		case TypeIds.T_int :
			// getstatic: java.lang.Integer.TYPE
			fieldAccess(
					Opcodes.OPC_getstatic,
					1, // return type size
					ConstantPool.JavaLangIntegerConstantPoolName,
					ConstantPool.TYPE,
					ConstantPool.JavaLangClassSignature);
			break;
		case TypeIds.T_long :
			// getstatic: java.lang.Long.TYPE
			fieldAccess(
					Opcodes.OPC_getstatic,
					1, // return type size
					ConstantPool.JavaLangLongConstantPoolName,
					ConstantPool.TYPE,
					ConstantPool.JavaLangClassSignature);
			break;
		case TypeIds.T_float :
			// getstatic: java.lang.Float.TYPE
			fieldAccess(
					Opcodes.OPC_getstatic,
					1, // return type size
					ConstantPool.JavaLangFloatConstantPoolName,
					ConstantPool.TYPE,
					ConstantPool.JavaLangClassSignature);
			break;
		case TypeIds.T_double :
			// getstatic: java.lang.Double.TYPE
			fieldAccess(
					Opcodes.OPC_getstatic,
					1, // return type size
					ConstantPool.JavaLangDoubleConstantPoolName,
					ConstantPool.TYPE,
					ConstantPool.JavaLangClassSignature);
			break;
		case TypeIds.T_boolean :
			// getstatic: java.lang.Boolean.TYPE
			fieldAccess(
					Opcodes.OPC_getstatic,
					1, // return type size
					ConstantPool.JavaLangBooleanConstantPoolName,
					ConstantPool.TYPE,
					ConstantPool.JavaLangClassSignature);
			break;
		case TypeIds.T_void :
			// getstatic: java.lang.Void.TYPE
			fieldAccess(
					Opcodes.OPC_getstatic,
					1, // return type size
					ConstantPool.JavaLangVoidConstantPoolName,
					ConstantPool.TYPE,
					ConstantPool.JavaLangClassSignature);

	writeUnsignedShort(this.constantPool.literalIndexForType(typeBinding));
}

protected void invoke(byte opcode, int receiverAndArgsSize, int returnTypeSize, char[] declaringClass, char[] selector, char[] signature) {
	this.countLabels = 0;
	if (opcode == Opcodes.OPC_invokeinterface) {
		// invokeinterface
		if (this.classFileOffset + 4 >= this.bCodeStream.length) {
			resizeByteArray();
		}
		this.position +=3;
		this.bCodeStream[this.classFileOffset++] = opcode;
		writeUnsignedShort(this.constantPool.literalIndexForMethod(declaringClass, selector, signature, true));
		this.bCodeStream[this.classFileOffset++] = (byte) receiverAndArgsSize;
		this.bCodeStream[this.classFileOffset++] = 0;
	} else {
		// invokespecial
		// invokestatic
		// invokevirtual
		if (this.classFileOffset + 2 >= this.bCodeStream.length) {
			resizeByteArray();
		}
		this.position++;
		this.bCodeStream[this.classFileOffset++] = opcode;
		writeUnsignedShort(this.constantPool.literalIndexForMethod(declaringClass, selector, signature, false));
	}
	this.stackDepth += returnTypeSize - receiverAndArgsSize;
	if (this.stackDepth > this.stackMax) {
		this.stackMax = this.stackDepth;
	}
}

public void invoke(byte opcode, MethodBinding methodBinding, TypeBinding declaringClass) {
	if (declaringClass == null) declaringClass = methodBinding.declaringClass;
    if (declaringClass.isNestedType()) {

			methodBinding.signature(this.classFile));
}

protected void invoke(byte opcode, int receiverAndArgsSize, int returnTypeSize, char[] declaringClass, char[] selector, char[] signature) {
	this.countLabels = 0;
	if (opcode == Opcodes.OPC_invokeinterface) {
		// invokeinterface
		if (this.classFileOffset + 4 >= this.bCodeStream.length) {
			resizeByteArray();
		}
		this.position +=3;
		this.bCodeStream[this.classFileOffset++] = opcode;
		writeUnsignedShort(this.constantPool.literalIndexForMethod(declaringClass, selector, signature, true));
		this.bCodeStream[this.classFileOffset++] = (byte) receiverAndArgsSize;
		this.bCodeStream[this.classFileOffset++] = 0;
	} else {
		// invokespecial
		// invokestatic
		// invokevirtual
		if (this.classFileOffset + 2 >= this.bCodeStream.length) {
			resizeByteArray();
		}
		this.position++;
		this.bCodeStream[this.classFileOffset++] = opcode;
		writeUnsignedShort(this.constantPool.literalIndexForMethod(declaringClass, selector, signature, false));
	}
	this.stackDepth += returnTypeSize - receiverAndArgsSize;
	if (this.stackDepth > this.stackMax) {
		this.stackMax = this.stackDepth;
	}
}

protected void invokeAccessibleObjectSetAccessible() {
	// invokevirtual: java.lang.reflect.AccessibleObject.setAccessible(Z)V;
	invoke(

	load(localBinding.type, localBinding.resolvedPosition);
}

protected final void load(TypeBinding typeBinding, int resolvedPosition) {
	this.countLabels = 0;
	// Using dedicated int bytecode
	switch(typeBinding.id) {

		this.stackMax = this.stackDepth;
}

public void putfield(FieldBinding fieldBinding) {
	int returnTypeSize = 1;
	if ((fieldBinding.type.id == TypeIds.T_double) || (fieldBinding.type.id == TypeIds.T_long)) {
		returnTypeSize = 2;
	}
	generateFieldAccess(
			Opcodes.OPC_putfield,
			returnTypeSize,
			fieldBinding.declaringClass,
			fieldBinding.name,
			fieldBinding.type);
}

public void putstatic(FieldBinding fieldBinding) {
	int returnTypeSize = 1;
	if ((fieldBinding.type.id == TypeIds.T_double) || (fieldBinding.type.id == TypeIds.T_long)) {
		returnTypeSize = 2;
	}
	generateFieldAccess(
			Opcodes.OPC_putstatic,
			returnTypeSize,
			fieldBinding.declaringClass,
			fieldBinding.name,
			fieldBinding.type);
}

public void record(LocalVariableBinding local) {
	if ((this.generateAttributes & (ClassFileConstants.ATTR_VARS
			| ClassFileConstants.ATTR_STACK_MAP_TABLE

Lines 273-279 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/codegen/StackMapFrameCodeStream.java (-2 / +2 lines)
273	// use in CLDC mode	273	// use in CLDC mode
274	BranchLabel endLabel = new BranchLabel(this);	274	BranchLabel endLabel = new BranchLabel(this);
275	if (syntheticFieldBinding != null) { // non interface case	275	if (syntheticFieldBinding != null) { // non interface case
276	getstatic(syntheticFieldBinding);	276	fieldAccess0(Opcodes.OPC_getstatic, syntheticFieldBinding, null /* default declaringClass */);
277	dup();	277	dup();
278	ifnonnull(endLabel);	278	ifnonnull(endLabel);
279	pop();	279	pop();
Lines 316-322 Link Here
316		316
317	if (syntheticFieldBinding != null) { // non interface case	317	if (syntheticFieldBinding != null) { // non interface case
318	dup();	318	dup();
319	putstatic(syntheticFieldBinding);	319	fieldAccess0(Opcodes.OPC_putstatic, syntheticFieldBinding, null /* default declaringClass */);
320	}	320	}
321	int fromPC = this.position;	321	int fromPC = this.position;
322	goto_(endLabel);	322	goto_(endLabel);




import org.eclipse.jdt.internal.compiler.ast.Expression;
import org.eclipse.jdt.internal.compiler.ast.FieldReference;
import org.eclipse.jdt.internal.compiler.ast.IntLiteral;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
import org.eclipse.jdt.internal.compiler.codegen.Opcodes;
import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.impl.Constant;
import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
import org.eclipse.jdt.internal.compiler.lookup.ParameterizedFieldBinding;
import org.eclipse.jdt.internal.compiler.lookup.ProblemFieldBinding;
import org.eclipse.jdt.internal.compiler.lookup.ProblemReasons;
import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeIds;

public class CodeSnippetFieldReference extends FieldReference implements ProblemReasons, EvaluationConstants {


	this.evaluationContext = evaluationContext;
}
public void generateAssignment(BlockScope currentScope, CodeStream codeStream, Assignment assignment, boolean valueRequired) {
	FieldBinding codegenBinding = this.binding.original();
	if (codegenBinding.canBeSeenBy(this.actualReceiverType, this, currentScope)) {
		this.receiver.generateCode(currentScope, codeStream, !codegenBinding.isStatic());
		assignment.expression.generateCode(currentScope, codeStream, true);
		fieldStore(codeStream, codegenBinding, null, valueRequired);
	} else {
		codeStream.generateEmulationForField(codegenBinding);
		this.receiver.generateCode(currentScope, codeStream, !codegenBinding.isStatic());
		if (codegenBinding.isStatic()) { // need a receiver?
			codeStream.aconst_null();
		}
		assignment.expression.generateCode(currentScope, codeStream, true);
		if (valueRequired) {
			switch (codegenBinding.type.id) {
				case TypeIds.T_long :
				case TypeIds.T_double :
					codeStream.dup2_x2();
					break;
				default :
					codeStream.dup_x2();
					break;
			}			
		}
		codeStream.generateEmulatedWriteAccessForField(codegenBinding);
	}
	if (valueRequired){
		codeStream.generateImplicitConversion(assignment.implicitConversion);

 * @param valueRequired boolean
 */
public void generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired) {

	int pc = codeStream.position;
	if (this.constant != Constant.NotAConstant) {
		if (valueRequired) {
			codeStream.generateConstant(this.constant, this.implicitConversion);
		}
	} else {
		FieldBinding codegenBinding = this.binding.original();
		boolean isStatic = codegenBinding.isStatic();
		this.receiver.generateCode(currentScope, codeStream, !isStatic);
		if (valueRequired) {
			Constant fieldConstant = codegenBinding.constant();
			if (fieldConstant == Constant.NotAConstant) {
				if (codegenBinding.declaringClass == null) { // array length
					codeStream.arraylength();
				} else {
					if (codegenBinding.canBeSeenBy(this.actualReceiverType, this, currentScope)) {
						TypeBinding someReceiverType = this.delegateThis != null ? this.delegateThis.type : this.actualReceiverType;
						TypeBinding constantPoolDeclaringClass = getConstantPoolDeclaringClass(currentScope, codegenBinding, someReceiverType, this.receiver.isImplicitThis());
						if (isStatic) {
							codeStream.fieldAccess0(Opcodes.OPC_getstatic , codegenBinding, constantPoolDeclaringClass);
						} else {
							codeStream.fieldAccess0(Opcodes.OPC_getfield, codegenBinding, constantPoolDeclaringClass);
						}
					} else {
						if (isStatic) {
							// we need a null on the stack to use the reflect emulation
							codeStream.aconst_null();
						}
						codeStream.generateEmulatedReadAccessForField(codegenBinding);
					}
				}
				codeStream.generateImplicitConversion(this.implicitConversion);

}

public void generateCompoundAssignment(BlockScope currentScope, CodeStream codeStream, Expression expression, int operator, int assignmentImplicitConversion, boolean valueRequired) {

	boolean isStatic;
	FieldBinding codegenBinding = this.binding.original();
	if (codegenBinding.canBeSeenBy(this.actualReceiverType, this, currentScope)) {
		this.receiver.generateCode(currentScope, codeStream, !(isStatic = codegenBinding.isStatic()));
		TypeBinding someReceiverType = this.delegateThis != null ? this.delegateThis.type : this.actualReceiverType;
		TypeBinding constantPoolDeclaringClass = getConstantPoolDeclaringClass(currentScope, codegenBinding, someReceiverType, this.receiver.isImplicitThis());
		if (isStatic) {
			codeStream.fieldAccess0(Opcodes.OPC_getstatic, codegenBinding, constantPoolDeclaringClass);
		} else {
			codeStream.dup();
			codeStream.fieldAccess0(Opcodes.OPC_getfield, codegenBinding, constantPoolDeclaringClass);
		}
		int operationTypeID;
		switch(operationTypeID = (this.implicitConversion & IMPLICIT_CONVERSION_MASK) >> 4) {

				// cast the value back to the array reference type
				codeStream.generateImplicitConversion(assignmentImplicitConversion);
		}
		fieldStore(codeStream, codegenBinding, null, valueRequired);
	} else {
		this.receiver.generateCode(currentScope, codeStream, !(isStatic = codegenBinding.isStatic()));
		if (isStatic) {
			// used to store the value
			codeStream.generateEmulationForField(codegenBinding);
			codeStream.aconst_null();

			// used to retrieve the actual value
			codeStream.aconst_null();
			codeStream.generateEmulatedReadAccessForField(codegenBinding);
		} else {
			// used to store the value
			codeStream.generateEmulationForField(this.binding);


			// used to retrieve the actual value
			codeStream.dup();
			codeStream.generateEmulatedReadAccessForField(codegenBinding);
		}
		int operationTypeID;
		if ((operationTypeID = (this.implicitConversion & IMPLICIT_CONVERSION_MASK) >> 4) == T_JavaLangString) {

		// current stack is:
		// field receiver value
		if (valueRequired) {
			if ((codegenBinding.type == TypeBinding.LONG) || (codegenBinding.type == TypeBinding.DOUBLE)) {
				codeStream.dup2_x2();
			} else {
				codeStream.dup_x2();

		}
		// current stack is:
		// value field receiver value
		codeStream.generateEmulatedWriteAccessForField(codegenBinding);
	}
}
public void generatePostIncrement(BlockScope currentScope, CodeStream codeStream, CompoundAssignment postIncrement, boolean valueRequired) {
	boolean isStatic;
	FieldBinding codegenBinding = this.binding.original();
	if (codegenBinding.canBeSeenBy(this.actualReceiverType, this, currentScope)) {
		super.generatePostIncrement(currentScope, codeStream, postIncrement, valueRequired);
	} else {
		this.receiver.generateCode(currentScope, codeStream, !(isStatic = codegenBinding.isStatic()));
		if (isStatic) {
			codeStream.aconst_null();
		}
		// the actual stack is: receiver
		codeStream.dup();
		// the actual stack is: receiver receiver
		codeStream.generateEmulatedReadAccessForField(codegenBinding);
		// the actual stack is: receiver value
		// receiver value
		// value receiver value 							dup_x1 or dup2_x1 if value required
		// value value receiver value					dup_x1 or dup2_x1
		// value value receiver							pop or pop2
		// value value receiver field						generateEmulationForField
		// value value field receiver 					swap
		// value field receiver value field receiver 	dup2_x1 or dup2_x2
		// value field receiver value 				 	pop2
		// value field receiver newvalue 				generate constant + op
		// value 												store
		int typeID;
		switch (typeID = codegenBinding.type.id) {
			case TypeIds.T_long :
			case TypeIds.T_double :
				if (valueRequired) {
					codeStream.dup2_x1();
				}
				codeStream.dup2_x1();
				codeStream.pop2();
				break;
			default :
				if (valueRequired) {
					codeStream.dup_x1();
				}
				codeStream.dup_x1();
				codeStream.pop();
				break;
		if ((this.codegenBinding.type == TypeBinding.LONG) || (this.codegenBinding.type == TypeBinding.DOUBLE)) {
			codeStream.dup2_x1();
			codeStream.pop2();
		} else {
			codeStream.dup_x1();
			codeStream.pop();
		}
		codeStream.generateEmulationForField(codegenBinding);
		codeStream.swap();
		switch (typeID) {
			case TypeIds.T_long :
			case TypeIds.T_double :
				codeStream.dup2_x2();
				break;
			default :
				codeStream.dup2_x1();
				break;
		}
		codeStream.pop2();

		codeStream.generateConstant(postIncrement.expression.constant, this.implicitConversion);
		codeStream.sendOperator(postIncrement.operator, codegenBinding.type.id);
		codeStream.generateImplicitConversion(postIncrement.preAssignImplicitConversion);
		codeStream.generateEmulatedWriteAccessForField(codegenBinding);
	}
}
/*

	// The private access will be managed through the code generation

	if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) != 0) return;

	// if field from parameterized type got found, use the original field at codegen time
	if (this.binding instanceof ParameterizedFieldBinding) {
	    ParameterizedFieldBinding parameterizedField = (ParameterizedFieldBinding) this.binding;
	    this.codegenBinding = parameterizedField.originalField;
	    // extra cast needed if field type was type variable
	    if (this.codegenBinding.type.isTypeVariable()) {
	        TypeVariableBinding variableReturnType = (TypeVariableBinding) this.codegenBinding.type;
	        if (variableReturnType.firstBound != parameterizedField.type) { // no need for extra cast if same as first bound anyway
			    this.genericCast = parameterizedField.type.erasure();
	        }
	    }
	} else {
	    this.codegenBinding = this.binding;
	}

	// 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
	TypeBinding someReceiverType = this.delegateThis != null ? this.delegateThis.type : this.receiverType;
	if (this.binding.declaringClass != someReceiverType
			&& !someReceiverType.isArrayType()
			&& this.binding.declaringClass != null // array.length
			&& this.binding.constant() == Constant.NotAConstant) {

		CompilerOptions options = currentScope.compilerOptions();
		if ((options.targetJDK >= ClassFileConstants.JDK1_2
				&& (options.complianceLevel >= ClassFileConstants.JDK1_4 || !this.receiver.isImplicitThis() || !this.codegenBinding.isStatic())
				&& this.binding.declaringClass.id != T_JavaLangObject) // no change for Object fields
			|| !this.binding.declaringClass.canBeSeenBy(currentScope)) {

			this.codegenBinding =
				currentScope.enclosingSourceType().getUpdatedFieldBinding(
					this.codegenBinding,
					(ReferenceBinding) someReceiverType.erasure());
		}
	}
}
public TypeBinding resolveType(BlockScope scope) {
	// Answer the signature type of the field.

	// and initialized with a (compile time) constant

	// regular receiver reference
	this.actualReceiverType = this.receiver.resolveType(scope);
	if (this.actualReceiverType == null){
		this.constant = Constant.NotAConstant;
		return null;
	}
	// the case receiverType.isArrayType and token = 'length' is handled by the scope API
	this.binding = scope.getField(this.actualReceiverType, this.token, this);
	FieldBinding firstAttempt = this.binding;
	boolean isNotVisible = false;
	if (!this.binding.isValidBinding()) {

					this.delegateThis = scope.getField(scope.enclosingSourceType(), DELEGATE_THIS, this);
					if (this.delegateThis == null){  // if not found then internal error, field should have been found
						this.constant = Constant.NotAConstant;
						scope.problemReporter().invalidField(this, this.actualReceiverType);
						return null;
					}
				} else {
					this.constant = Constant.NotAConstant;
					scope.problemReporter().invalidField(this, this.actualReceiverType);
					return null;
				}
			CodeSnippetScope localScope = new CodeSnippetScope(scope);
			this.binding = localScope.getFieldForCodeSnippet(this.delegateThis.type, this.token, this);
		}
	}

	if (!this.binding.isValidBinding()) {
		this.constant = Constant.NotAConstant;
		if (isNotVisible) {
			this.binding = firstAttempt;
		}
		scope.problemReporter().invalidField(this, this.actualReceiverType);
		return null;
	}





import org.eclipse.jdt.internal.compiler.ast.SingleNameReference;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
import org.eclipse.jdt.internal.compiler.codegen.Opcodes;
import org.eclipse.jdt.internal.compiler.flow.FlowContext;
import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.impl.Constant;
import org.eclipse.jdt.internal.compiler.lookup.Binding;
import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
import org.eclipse.jdt.internal.compiler.lookup.ClassScope;
import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;
import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
import org.eclipse.jdt.internal.compiler.lookup.ParameterizedFieldBinding;
import org.eclipse.jdt.internal.compiler.lookup.ProblemBinding;
import org.eclipse.jdt.internal.compiler.lookup.ProblemFieldBinding;
import org.eclipse.jdt.internal.compiler.lookup.ProblemReasons;
import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
import org.eclipse.jdt.internal.compiler.lookup.Scope;
import org.eclipse.jdt.internal.compiler.lookup.TagBits;
import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
import org.eclipse.jdt.internal.compiler.lookup.VariableBinding;

/**
 * A single name reference inside a code snippet can denote a field of a remote

				Constant fieldConstant = fieldBinding.constant();
				if (fieldConstant == Constant.NotAConstant) { // directly use inlined value for constant fields
					if (fieldBinding.canBeSeenBy(getReceiverType(currentScope), this, currentScope)) {
						TypeBinding constantPoolDeclaringClass = getConstantPoolDeclaringClass(currentScope, fieldBinding, this.actualReceiverType, true /* implicit this */);
						if (fieldBinding.isStatic()) {
							codeStream.fieldAccess0(Opcodes.OPC_getstatic, fieldBinding, constantPoolDeclaringClass);
						} else {
							if ((this.bits & DepthMASK) != 0) {
								ReferenceBinding targetType = currentScope.enclosingSourceType().enclosingTypeAt((this.bits & DepthMASK) >> DepthSHIFT);
								Object[] emulationPath = currentScope.getEmulationPath(targetType, true /*only exact match*/, false/*consider enclosing arg*/);

							} else {
								generateReceiver(codeStream);
							}
							codeStream.fieldAccess0(Opcodes.OPC_getfield, fieldBinding, constantPoolDeclaringClass);
						// managing private access
						if (isStatic) {
							codeStream.getstatic(fieldBinding);
						} else {
							codeStream.getfield(fieldBinding);
						}
					} else {
						// managing private access

			FieldBinding fieldBinding = (FieldBinding) this.codegenBinding;
			if (fieldBinding.isStatic()) {
				if (fieldBinding.canBeSeenBy(getReceiverType(currentScope), this, currentScope)) {
					codeStream.fieldAccess(Opcodes.OPC_getstatic, fieldBinding, null /* default declaringClass */);
				} else {
					// used to store the value
					codeStream.generateEmulationForField(fieldBinding);

						generateReceiver(codeStream);
					}
					codeStream.dup();
					codeStream.fieldAccess(Opcodes.OPC_getfield, fieldBinding, null /* default declaringClass */);
				} else {
					if ((this.bits & DepthMASK) != 0) {
						// internal error, per construction we should have found it

public void generateReceiver(CodeStream codeStream) {
	codeStream.aload_0();
	if (this.delegateThis != null) {
		codeStream.fieldAccess0(Opcodes.OPC_getfield, this.delegateThis, null /* default declaringClass */); // delegate field access
	}
}
/**

Lines 12-17 Link Here

(-)eval/org/eclipse/jdt/internal/eval/CodeSnippetThisReference.java (-1 / +2 lines)
12		12
13	import org.eclipse.jdt.internal.compiler.ast.ThisReference;	13	import org.eclipse.jdt.internal.compiler.ast.ThisReference;
14	import org.eclipse.jdt.internal.compiler.codegen.CodeStream;	14	import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
		15	import org.eclipse.jdt.internal.compiler.codegen.Opcodes;
15	import org.eclipse.jdt.internal.compiler.impl.Constant;	16	import org.eclipse.jdt.internal.compiler.impl.Constant;
16	import org.eclipse.jdt.internal.compiler.lookup.BlockScope;	17	import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
17	import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;	18	import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
Lines 58-64 Link Here
58	int pc = codeStream.position;	59	int pc = codeStream.position;
59	if (valueRequired) {	60	if (valueRequired) {
60	codeStream.aload_0();	61	codeStream.aload_0();
61	codeStream.getfield(this.delegateThis);	62	codeStream.fieldAccess0(Opcodes.OPC_getfield, this.delegateThis, null /* default declaringClass */); // delegate field access
62	}	63	}
63	codeStream.recordPositionsFrom(pc, this.sourceStart);	64	codeStream.recordPositionsFrom(pc, this.sourceStart);
64	}	65	}

Lines 107-115 Link Here

(-)eval/org/eclipse/jdt/internal/eval/CodeSnippetQualifiedNameReference.java (-19 / +13 lines)
107	} else {	107	} else {
108	if (lastFieldBinding.canBeSeenBy(getReceiverType(currentScope), this, currentScope)) {	108	if (lastFieldBinding.canBeSeenBy(getReceiverType(currentScope), this, currentScope)) {
109	if (lastFieldBinding.isStatic()) {	109	if (lastFieldBinding.isStatic()) {
110	codeStream.getstatic(lastFieldBinding);	110	codeStream.fieldAccess0(Opcodes.OPC_getstatic, lastFieldBinding, null /* default declaringClass */);
111	} else {	111	} else {
112	codeStream.getfield(lastFieldBinding);	112	codeStream.fieldAccess0(Opcodes.OPC_getfield, lastFieldBinding, null /* default declaringClass */);
113	}	113	}
114	} else {	114	} else {
115	codeStream.generateEmulatedReadAccessForField(lastFieldBinding);	115	codeStream.generateEmulatedReadAccessForField(lastFieldBinding);
Lines 131-140 Link Here
131	FieldBinding lastFieldBinding = generateReadSequence(currentScope, codeStream);	131	FieldBinding lastFieldBinding = generateReadSequence(currentScope, codeStream);
132	if (lastFieldBinding.canBeSeenBy(getReceiverType(currentScope), this, currentScope)) {	132	if (lastFieldBinding.canBeSeenBy(getReceiverType(currentScope), this, currentScope)) {
133	if (lastFieldBinding.isStatic()){	133	if (lastFieldBinding.isStatic()){
134	codeStream.getstatic(lastFieldBinding);	134	codeStream.fieldAccess0(Opcodes.OPC_getstatic, lastFieldBinding, null /* default declaringClass */);
135	} else {	135	} else {
136	codeStream.dup();	136	codeStream.dup();
137	codeStream.getfield(lastFieldBinding);	137	codeStream.fieldAccess0(Opcodes.OPC_getfield, lastFieldBinding, null /* default declaringClass */);
138	}	138	}
139	// the last field access is a write access	139	// the last field access is a write access
140	// perform the actual compound operation	140	// perform the actual compound operation
Lines 162-181 Link Here
162	// actual assignment	162	// actual assignment
163	fieldStore(codeStream, lastFieldBinding, null, valueRequired);	163	fieldStore(codeStream, lastFieldBinding, null, valueRequired);
164	} else {	164	} else {
		165	codeStream.generateEmulationForField(lastFieldBinding);
		166	codeStream.swap();
165	if (lastFieldBinding.isStatic()){	167	if (lastFieldBinding.isStatic()){
166	codeStream.generateEmulationForField(lastFieldBinding);
167	codeStream.swap();
168	codeStream.aconst_null();	168	codeStream.aconst_null();
169	codeStream.swap();	169	codeStream.swap();
170
171	codeStream.generateEmulatedReadAccessForField(lastFieldBinding);
172	} else {	170	} else {
173	codeStream.generateEmulationForField(lastFieldBinding);
174	codeStream.swap();
175	codeStream.dup();	171	codeStream.dup();
176
177	codeStream.generateEmulatedReadAccessForField(lastFieldBinding);
178	}	172	}
		173	codeStream.generateEmulatedReadAccessForField(lastFieldBinding);
179	// the last field access is a write access	174	// the last field access is a write access
180	// perform the actual compound operation	175	// perform the actual compound operation
181	int operationTypeID;	176	int operationTypeID;
Lines 215-234 Link Here
215		210
216	FieldBinding lastFieldBinding = generateReadSequence(currentScope, codeStream);	211	FieldBinding lastFieldBinding = generateReadSequence(currentScope, codeStream);
217	if (lastFieldBinding.canBeSeenBy(getReceiverType(currentScope), this, currentScope)) {	212	if (lastFieldBinding.canBeSeenBy(getReceiverType(currentScope), this, currentScope)) {
218	SyntheticMethodBinding accessor =	213	SyntheticMethodBinding accessor = this.syntheticReadAccessors == null
219	this.syntheticReadAccessors == null
220	? null	214	? null
221	: this.syntheticReadAccessors[this.syntheticReadAccessors.length - 1];	215	: this.syntheticReadAccessors[this.syntheticReadAccessors.length - 1];
222	if (lastFieldBinding.isStatic()) {	216	if (lastFieldBinding.isStatic()) {
223	if (accessor == null) {	217	if (accessor == null) {
224	codeStream.getstatic(lastFieldBinding);	218	codeStream.fieldAccess0(Opcodes.OPC_getstatic, lastFieldBinding, null /* default declaringClass */);
225	} else {	219	} else {
226	codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);	220	codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);
227	}	221	}
228	} else {	222	} else {
229	codeStream.dup();	223	codeStream.dup();
230	if (accessor == null) {	224	if (accessor == null) {
231	codeStream.getfield(lastFieldBinding);	225	codeStream.fieldAccess0(Opcodes.OPC_getfield, lastFieldBinding, null /* default declaringClass */);
232	} else {	226	} else {
233	codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);	227	codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);
234	}	228	}
Lines 380-388 Link Here
380	}	374	}
381	codeStream.generateConstant(fieldConstant, 0);	375	codeStream.generateConstant(fieldConstant, 0);
382	} else if (lastFieldBinding.isStatic()) {	376	} else if (lastFieldBinding.isStatic()) {
383	codeStream.getstatic(lastFieldBinding);	377	codeStream.fieldAccess0(Opcodes.OPC_getstatic, lastFieldBinding, null /* default declaringClass */);
384	} else {	378	} else {
385	codeStream.getfield(lastFieldBinding);	379	codeStream.fieldAccess0(Opcodes.OPC_getfield, lastFieldBinding, null /* default declaringClass */);
386	}	380	}
387	} else {	381	} else {
388	codeStream.generateEmulatedReadAccessForField(lastFieldBinding);	382	codeStream.generateEmulatedReadAccessForField(lastFieldBinding);
Lines 410-416 Link Here
410	public void generateReceiver(CodeStream codeStream) {	404	public void generateReceiver(CodeStream codeStream) {
411	codeStream.aload_0();	405	codeStream.aload_0();
412	if (this.delegateThis != null) {	406	if (this.delegateThis != null) {
413	codeStream.getfield(this.delegateThis); // delegated field access	407	codeStream.fieldAccess0(Opcodes.OPC_getfield, this.delegateThis, null /* default declaringClass */); // delegated field access
414	}	408	}
415	}	409	}
416	public TypeBinding getOtherFieldBindings(BlockScope scope) {	410	public TypeBinding getOtherFieldBindings(BlockScope scope) {





	public TypeBinding resolveType(BlockScope scope) {

		this.actualReceiverType = this.receiver.resolveType(scope);

		if ((this.actualReceiverType == null || !this.actualReceiverType.isValidBinding()) && this.receiver instanceof MessageSend) {
			MessageSend messageSend = (MessageSend) this.receiver;
			if(messageSend.receiver instanceof ThisReference) {
				Expression[] arguments = messageSend.arguments;

			}
		}

		if (this.actualReceiverType == null || this.actualReceiverType.isBaseType() || !this.actualReceiverType.isValidBinding())
			throw new CompletionNodeFound();
		else
			throw new CompletionNodeFound(this, this.actualReceiverType, scope);
		// array types are passed along to find the length field
	}
}

Lines 93-103 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionOnJavadocFieldReference.java (-3 / +3 lines)
93		93
94	// Resolve only receiver	94	// Resolve only receiver
95	if (this.receiver == null) {	95	if (this.receiver == null) {
96	this.receiverType = scope.enclosingSourceType();	96	this.actualReceiverType = scope.enclosingSourceType();
97	} else if (scope.kind == Scope.CLASS_SCOPE) {	97	} else if (scope.kind == Scope.CLASS_SCOPE) {
98	this.receiverType = this.receiver.resolveType((ClassScope) scope);	98	this.actualReceiverType = this.receiver.resolveType((ClassScope) scope);
99	} else {	99	} else {
100	this.receiverType = this.receiver.resolveType((BlockScope)scope);	100	this.actualReceiverType = this.receiver.resolveType((BlockScope)scope);
101	}	101	}
102	return null;	102	return null;
103	}	103	}




				long completionPosition = fieldRef.nameSourcePosition;
				this.javadocTagPosition = fieldRef.tagSourceStart;

				if (fieldRef.actualReceiverType != null && fieldRef.actualReceiverType.isValidBinding()) {
					ReferenceBinding receiverType = (ReferenceBinding) fieldRef.actualReceiverType;
					int rangeStart = (int) (completionPosition >>> 32);
					if (fieldRef.receiver.isThis()) {
						if (fieldRef.completeInText()) {

							null,
							-1,
							-1);
						if (fieldRef.actualReceiverType instanceof ReferenceBinding) {
							ReferenceBinding refBinding = (ReferenceBinding)fieldRef.actualReceiverType;
							if (this.completionToken == null
									|| CharOperation.prefixEquals(this.completionToken, refBinding.sourceName)
									|| (this.options.camelCaseMatch && CharOperation.camelCaseMatch(this.completionToken, refBinding.sourceName))) {

Return to bug 247612

Lines 391-405 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedNameReference.java (-13 / +10 lines)
391	codeStream.pop();	391	codeStream.pop();
392	}	392	}
393	} else {	393	} else {
394	SyntheticMethodBinding accessor =	394	SyntheticMethodBinding accessor = this.syntheticReadAccessors == null ? null : this.syntheticReadAccessors[this.syntheticReadAccessors.length - 1];
395	this.syntheticReadAccessors == null
396	? null
397	: this.syntheticReadAccessors[this.syntheticReadAccessors.length - 1];
398	if (accessor == null) {	395	if (accessor == null) {
399	if (isStatic) {	396	if (isStatic) {
400	codeStream.getstatic(lastFieldBinding);	397	codeStream.fieldAccess(Opcodes.OPC_getstatic, lastFieldBinding, null /* default declaringClass */);
401	} else {	398	} else {
402	codeStream.getfield(lastFieldBinding);	399	codeStream.fieldAccess(Opcodes.OPC_getfield, lastFieldBinding, null /* default declaringClass */);
403	}	400	}
404	} else {	401	} else {
405	codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);	402	codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);
Lines 451-464 Link Here
451	: this.syntheticReadAccessors[this.syntheticReadAccessors.length - 1];	448	: this.syntheticReadAccessors[this.syntheticReadAccessors.length - 1];
452	if (lastFieldBinding.isStatic()) {	449	if (lastFieldBinding.isStatic()) {
453	if (accessor == null) {	450	if (accessor == null) {
454	codeStream.getstatic(lastFieldBinding);	451	codeStream.fieldAccess(Opcodes.OPC_getstatic, lastFieldBinding, null /* default declaringClass */);
455	} else {	452	} else {
456	codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);	453	codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);
457	}	454	}
458	} else {	455	} else {
459	codeStream.dup();	456	codeStream.dup();
460	if (accessor == null) {	457	if (accessor == null) {
461	codeStream.getfield(lastFieldBinding);	458	codeStream.fieldAccess(Opcodes.OPC_getfield, lastFieldBinding, null /* default declaringClass */);
462	} else {	459	} else {
463	codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);	460	codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);
464	}	461	}
Lines 500-513 Link Here
500	: this.syntheticReadAccessors[this.syntheticReadAccessors.length - 1];	497	: this.syntheticReadAccessors[this.syntheticReadAccessors.length - 1];
501	if (lastFieldBinding.isStatic()) {	498	if (lastFieldBinding.isStatic()) {
502	if (accessor == null) {	499	if (accessor == null) {
503	codeStream.getstatic(lastFieldBinding);	500	codeStream.fieldAccess(Opcodes.OPC_getstatic, lastFieldBinding, null /* default declaringClass */);
504	} else {	501	} else {
505	codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);	502	codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);
506	}	503	}
507	} else {	504	} else {
508	codeStream.dup();	505	codeStream.dup();
509	if (accessor == null) {	506	if (accessor == null) {
510	codeStream.getfield(lastFieldBinding);	507	codeStream.fieldAccess(Opcodes.OPC_getfield, lastFieldBinding, null /* default declaringClass */);
511	} else {	508	} else {
512	codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);	509	codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);
513	}	510	}
Lines 624-632 Link Here
624	MethodBinding accessor = this.syntheticReadAccessors == null ? null : this.syntheticReadAccessors[i];	621	MethodBinding accessor = this.syntheticReadAccessors == null ? null : this.syntheticReadAccessors[i];
625	if (accessor == null) {	622	if (accessor == null) {
626	if (lastFieldBinding.isStatic()) {	623	if (lastFieldBinding.isStatic()) {
627	codeStream.getstatic(lastFieldBinding);	624	codeStream.fieldAccess(Opcodes.OPC_getstatic, lastFieldBinding, null /* default declaringClass */);
628	} else {	625	} else {
629	codeStream.getfield(lastFieldBinding);	626	codeStream.fieldAccess(Opcodes.OPC_getfield, lastFieldBinding, null /* default declaringClass */);
630	}	627	}
631	} else {	628	} else {
632	codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);	629	codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);
Lines 640-646 Link Here
640	if (((FieldBinding)this.binding).original().declaringClass != this.actualReceiverType.erasure()) {	637	if (((FieldBinding)this.binding).original().declaringClass != this.actualReceiverType.erasure()) {
641	MethodBinding accessor = this.syntheticReadAccessors == null ? null : this.syntheticReadAccessors[i];	638	MethodBinding accessor = this.syntheticReadAccessors == null ? null : this.syntheticReadAccessors[i];
642	if (accessor == null) {	639	if (accessor == null) {
643	codeStream.getstatic(lastFieldBinding);	640	codeStream.fieldAccess(Opcodes.OPC_getstatic, lastFieldBinding, null /* default declaringClass */);
644	} else {	641	} else {
645	codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);	642	codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);
646	}	643	}

Lines 376-382 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/SingleNameReference.java (-26 / +12 lines)
376	}	376	}
377	// managing private access	377	// managing private access
378	if ((this.syntheticAccessors == null) \|\| (this.syntheticAccessors[SingleNameReference.READ] == null)) {	378	if ((this.syntheticAccessors == null) \|\| (this.syntheticAccessors[SingleNameReference.READ] == null)) {
379	codeStream.getstatic(fieldBinding);	379	TypeBinding constantPoolDeclaringClass = getConstantPoolDeclaringClass(currentScope, fieldBinding, this.actualReceiverType, true /* implicit this */);
		380	codeStream.fieldAccess0(Opcodes.OPC_getstatic, fieldBinding, constantPoolDeclaringClass);
380	} else {	381	} else {
381	codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[SingleNameReference.READ], null /* default declaringClass */);	382	codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[SingleNameReference.READ], null /* default declaringClass */);
382	}	383	}
Lines 398-404 Link Here
398	}	399	}
399	// managing private access	400	// managing private access
400	if ((this.syntheticAccessors == null) \|\| (this.syntheticAccessors[SingleNameReference.READ] == null)) {	401	if ((this.syntheticAccessors == null) \|\| (this.syntheticAccessors[SingleNameReference.READ] == null)) {
401	codeStream.getfield(fieldBinding);	402	TypeBinding constantPoolDeclaringClass = getConstantPoolDeclaringClass(currentScope, fieldBinding, this.actualReceiverType, true /* implicit this */);
		403	codeStream.fieldAccess0(Opcodes.OPC_getfield, fieldBinding, constantPoolDeclaringClass);
402	} else {	404	} else {
403	codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[SingleNameReference.READ], null /* default declaringClass */);	405	codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[SingleNameReference.READ], null /* default declaringClass */);
404	}	406	}
Lines 473-479 Link Here
473	FieldBinding fieldBinding;	475	FieldBinding fieldBinding;
474	if ((fieldBinding = (FieldBinding) this.codegenBinding).isStatic()) {	476	if ((fieldBinding = (FieldBinding) this.codegenBinding).isStatic()) {
475	if ((this.syntheticAccessors == null) \|\| (this.syntheticAccessors[SingleNameReference.READ] == null)) {	477	if ((this.syntheticAccessors == null) \|\| (this.syntheticAccessors[SingleNameReference.READ] == null)) {
476	codeStream.getstatic(fieldBinding);	478	TypeBinding constantPoolDeclaringClass = getConstantPoolDeclaringClass(currentScope, fieldBinding, this.actualReceiverType, true /* implicit this */);
		479	codeStream.fieldAccess0(Opcodes.OPC_getstatic, fieldBinding, constantPoolDeclaringClass);
477	} else {	480	} else {
478	codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[SingleNameReference.READ], null /* default declaringClass */);	481	codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[SingleNameReference.READ], null /* default declaringClass */);
479	}	482	}
Lines 487-493 Link Here
487	}	490	}
488	codeStream.dup();	491	codeStream.dup();
489	if ((this.syntheticAccessors == null) \|\| (this.syntheticAccessors[SingleNameReference.READ] == null)) {	492	if ((this.syntheticAccessors == null) \|\| (this.syntheticAccessors[SingleNameReference.READ] == null)) {
490	codeStream.getfield(fieldBinding);	493	TypeBinding constantPoolDeclaringClass = getConstantPoolDeclaringClass(currentScope, fieldBinding, this.actualReceiverType, true /* implicit this */);
		494	codeStream.fieldAccess0(Opcodes.OPC_getfield, fieldBinding, constantPoolDeclaringClass);
491	} else {	495	} else {
492	codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[SingleNameReference.READ], null /* default declaringClass */);	496	codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[SingleNameReference.READ], null /* default declaringClass */);
493	}	497	}
Lines 586-592 Link Here
586	FieldBinding fieldBinding;	590	FieldBinding fieldBinding;
587	if ((fieldBinding = (FieldBinding) this.codegenBinding).isStatic()) {	591	if ((fieldBinding = (FieldBinding) this.codegenBinding).isStatic()) {
588	if ((this.syntheticAccessors == null) \|\| (this.syntheticAccessors[SingleNameReference.READ] == null)) {	592	if ((this.syntheticAccessors == null) \|\| (this.syntheticAccessors[SingleNameReference.READ] == null)) {
589	codeStream.getstatic(fieldBinding);	593	TypeBinding constantPoolDeclaringClass = getConstantPoolDeclaringClass(currentScope, fieldBinding, this.actualReceiverType, true /* implicit this */);
		594	codeStream.fieldAccess0(Opcodes.OPC_getstatic, fieldBinding, constantPoolDeclaringClass);
590	} else {	595	} else {
591	codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[SingleNameReference.READ], null /* default declaringClass */);	596	codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[SingleNameReference.READ], null /* default declaringClass */);
592	}	597	}
Lines 600-606 Link Here
600	}	605	}
601	codeStream.dup();	606	codeStream.dup();
602	if ((this.syntheticAccessors == null) \|\| (this.syntheticAccessors[SingleNameReference.READ] == null)) {	607	if ((this.syntheticAccessors == null) \|\| (this.syntheticAccessors[SingleNameReference.READ] == null)) {
603	codeStream.getfield(fieldBinding);	608	TypeBinding constantPoolDeclaringClass = getConstantPoolDeclaringClass(currentScope, fieldBinding, this.actualReceiverType, true /* implicit this */);
		609	codeStream.fieldAccess0(Opcodes.OPC_getfield, fieldBinding, constantPoolDeclaringClass);
604	} else {	610	} else {
605	codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[SingleNameReference.READ], null /* default declaringClass */);	611	codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[SingleNameReference.READ], null /* default declaringClass */);
606	}	612	}
Lines 723-748 Link Here
723	currentScope.problemReporter().needToEmulateFieldAccess(codegenField, this, isReadAccess);	729	currentScope.problemReporter().needToEmulateFieldAccess(codegenField, this, isReadAccess);
724	return;	730	return;
725	}	731	}
726	// if the binding declaring class is not visible, need special action
727	// for runtime compatibility on 1.2 VMs : change the declaring class of the binding
728	// NOTE: from target 1.2 on, field's declaring class is touched if any different from receiver type
729	// and not from Object or implicit static field access.
730	if (fieldBinding.declaringClass != this.actualReceiverType
731	&& !this.actualReceiverType.isArrayType()
732	&& fieldBinding.declaringClass != null // array.length
733	&& fieldBinding.constant() == Constant.NotAConstant) {
734	CompilerOptions options = currentScope.compilerOptions();
735	if ((options.targetJDK >= ClassFileConstants.JDK1_2
736	&& (options.complianceLevel >= ClassFileConstants.JDK1_4 \|\| !fieldBinding.isStatic())
737	&& fieldBinding.declaringClass.id != TypeIds.T_JavaLangObject) // no change for Object fields
738	\|\| !fieldBinding.declaringClass.canBeSeenBy(currentScope)) {
739
740	this.codegenBinding =
741	currentScope.enclosingSourceType().getUpdatedFieldBinding(
742	codegenField,
743	(ReferenceBinding)this.actualReceiverType.erasure());
744	}
745	}
746	}	732	}
747	}	733	}
748		734

Lines 10-17 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/Reference.java (-10 / +24 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.ast;	11	package org.eclipse.jdt.internal.compiler.ast;
12		12
		13	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
13	import org.eclipse.jdt.internal.compiler.codegen.*;	14	import org.eclipse.jdt.internal.compiler.codegen.*;
14	import org.eclipse.jdt.internal.compiler.flow.*;	15	import org.eclipse.jdt.internal.compiler.flow.*;
		16	import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
		17	import org.eclipse.jdt.internal.compiler.impl.Constant;
15	import org.eclipse.jdt.internal.compiler.lookup.*;	18	import org.eclipse.jdt.internal.compiler.lookup.*;
16		19
17	public abstract class Reference extends Expression {	20	public abstract class Reference extends Expression {
Lines 26-67 Link Here
26	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	29	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
27	return flowInfo;	30	return flowInfo;
28	}	31	}
		32
29	public FieldBinding fieldBinding() {	33	public FieldBinding fieldBinding() {
30	//this method should be sent one FIELD-tagged references	34	//this method should be sent one FIELD-tagged references
31	// (ref.bits & BindingIds.FIELD != 0)()	35	// (ref.bits & BindingIds.FIELD != 0)()
32	return null ;	36	return null ;
33	}	37	}
		38
34	public void fieldStore(CodeStream codeStream, FieldBinding fieldBinding, MethodBinding syntheticWriteAccessor, boolean valueRequired) {	39	public void fieldStore(CodeStream codeStream, FieldBinding fieldBinding, MethodBinding syntheticWriteAccessor, boolean valueRequired) {
35	int pc = codeStream.position;	40	int pc = codeStream.position;
36	if (fieldBinding.isStatic()) {	41	if (fieldBinding.isStatic()) {
37	if (valueRequired) {	42	if (valueRequired) {
38	if ((fieldBinding.type == TypeBinding.LONG) \|\| (fieldBinding.type == TypeBinding.DOUBLE)) {	43	switch (fieldBinding.type.id) {
39	codeStream.dup2();	44	case TypeIds.T_long :
40	} else {	45	case TypeIds.T_double :
41	codeStream.dup();	46	codeStream.dup2();
		47	break;
		48	default :
		49	codeStream.dup();
		50	break;
42	}	51	}
43	}	52	}
44	if (syntheticWriteAccessor == null) {	53	if (syntheticWriteAccessor == null) {
45	codeStream.putstatic(fieldBinding);	54	codeStream.fieldAccess0(Opcodes.OPC_putstatic, fieldBinding, null /* default declaringClass */);
46	} else {	55	} else {
47	codeStream.invoke(Opcodes.OPC_invokestatic, syntheticWriteAccessor, null /* default declaringClass */);	56	codeStream.invoke(Opcodes.OPC_invokestatic, syntheticWriteAccessor, null /* default declaringClass */);
48	}	57	}
49	} else { // Stack: [owner][new field value] ---> [new field value][owner][new field value]	58	} else { // Stack: [owner][new field value] ---> [new field value][owner][new field value]
50	if (valueRequired) {	59	if (valueRequired) {
51	if ((fieldBinding.type == TypeBinding.LONG) \|\| (fieldBinding.type == TypeBinding.DOUBLE)) {	60	switch (fieldBinding.type.id) {
52	codeStream.dup2_x1();	61	case TypeIds.T_long :
53	} else {	62	case TypeIds.T_double :
54	codeStream.dup_x1();	63	codeStream.dup2_x1();
		64	break;
		65	default :
		66	codeStream.dup_x1();
		67	break;
55	}	68	}
56	}	69	}
57	if (syntheticWriteAccessor == null) {	70	if (syntheticWriteAccessor == null) {
58	codeStream.putfield(fieldBinding);	71	codeStream.fieldAccess0(Opcodes.OPC_putfield, fieldBinding, null /* default declaringClass */);
59	} else {	72	} else {
60	codeStream.invoke(Opcodes.OPC_invokestatic, syntheticWriteAccessor, null /* default declaringClass */);	73	codeStream.invoke(Opcodes.OPC_invokestatic, syntheticWriteAccessor, null /* default declaringClass */);
61	}	74	}
62	}	75	}
63	codeStream.recordPositionsFrom(pc, this.sourceStart);	76	codeStream.recordPositionsFrom(pc, this.sourceStart);
64	}	77	}
		78
65	public abstract void generateAssignment(BlockScope currentScope, CodeStream codeStream, Assignment assignment, boolean valueRequired);	79	public abstract void generateAssignment(BlockScope currentScope, CodeStream codeStream, Assignment assignment, boolean valueRequired);
66		80
67	public abstract void generateCompoundAssignment(BlockScope currentScope, CodeStream codeStream, Expression expression, int operator, int assignmentImplicitConversion, boolean valueRequired);	81	public abstract void generateCompoundAssignment(BlockScope currentScope, CodeStream codeStream, Expression expression, int operator, int assignmentImplicitConversion, boolean valueRequired);

Lines 373-383 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/Javadoc.java (-5 / +5 lines)
373	if (scopeModifiers == -1) scopeModifiers = scope.getDeclarationModifiers();	373	if (scopeModifiers == -1) scopeModifiers = scope.getDeclarationModifiers();
374	scope.problemReporter().javadocInvalidValueReference(fieldRef.sourceStart, fieldRef.sourceEnd, scopeModifiers);	374	scope.problemReporter().javadocInvalidValueReference(fieldRef.sourceStart, fieldRef.sourceEnd, scopeModifiers);
375	}	375	}
376	else if (fieldRef.receiverType != null) {	376	else if (fieldRef.actualReceiverType != null) {
377	if (scope.enclosingSourceType().isCompatibleWith(fieldRef.receiverType)) {	377	if (scope.enclosingSourceType().isCompatibleWith(fieldRef.actualReceiverType)) {
378	fieldRef.bits \|= ASTNode.SuperAccess;	378	fieldRef.bits \|= ASTNode.SuperAccess;
379	}	379	}
380	fieldRef.methodBinding = scope.findMethod((ReferenceBinding)fieldRef.receiverType, fieldRef.token, new TypeBinding[0], fieldRef);	380	fieldRef.methodBinding = scope.findMethod((ReferenceBinding)fieldRef.actualReceiverType, fieldRef.token, new TypeBinding[0], fieldRef);
381	}	381	}
382	}	382	}
383		383
Lines 390-397 Link Here
390	}	390	}
391		391
392	// Verify type references	392	// Verify type references
393	if (!hasProblems && fieldRef.binding != null && fieldRef.binding.isValidBinding() && fieldRef.receiverType instanceof ReferenceBinding) {	393	if (!hasProblems && fieldRef.binding != null && fieldRef.binding.isValidBinding() && fieldRef.actualReceiverType instanceof ReferenceBinding) {
394	ReferenceBinding resolvedType = (ReferenceBinding) fieldRef.receiverType;	394	ReferenceBinding resolvedType = (ReferenceBinding) fieldRef.actualReceiverType;
395	verifyTypeReference(fieldRef, fieldRef.receiver, scope, source15, resolvedType, fieldRef.binding.modifiers);	395	verifyTypeReference(fieldRef, fieldRef.receiver, scope, source15, resolvedType, fieldRef.binding.modifiers);
396	}	396	}
397		397

Lines 41-59 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/JavadocFieldReference.java (-8 / +8 lines)
41		41
42	this.constant = Constant.NotAConstant;	42	this.constant = Constant.NotAConstant;
43	if (this.receiver == null) {	43	if (this.receiver == null) {
44	this.receiverType = scope.enclosingReceiverType();	44	this.actualReceiverType = scope.enclosingReceiverType();
45	} else if (scope.kind == Scope.CLASS_SCOPE) {	45	} else if (scope.kind == Scope.CLASS_SCOPE) {
46	this.receiverType = this.receiver.resolveType((ClassScope) scope);	46	this.actualReceiverType = this.receiver.resolveType((ClassScope) scope);
47	} else {	47	} else {
48	this.receiverType = this.receiver.resolveType((BlockScope)scope);	48	this.actualReceiverType = this.receiver.resolveType((BlockScope)scope);
49	}	49	}
50	if (this.receiverType == null) {	50	if (this.actualReceiverType == null) {
51	return null;	51	return null;
52	}	52	}
53		53
54	Binding fieldBinding = (this.receiver != null && this.receiver.isThis())	54	Binding fieldBinding = (this.receiver != null && this.receiver.isThis())
55	? scope.classScope().getBinding(this.token, this.bits & RestrictiveFlagMASK, this, true /resolve/)	55	? scope.classScope().getBinding(this.token, this.bits & RestrictiveFlagMASK, this, true /resolve/)
56	: scope.getField(this.receiverType, this.token, this);	56	: scope.getField(this.actualReceiverType, this.token, this);
57	if (!fieldBinding.isValidBinding()) {	57	if (!fieldBinding.isValidBinding()) {
58	// implicit lookup may discover issues due to static/constructor contexts. javadoc must be resilient	58	// implicit lookup may discover issues due to static/constructor contexts. javadoc must be resilient
59	switch (fieldBinding.problemId()) {	59	switch (fieldBinding.problemId()) {
Lines 72-79 Link Here
72	// problem already got signaled on receiver, do not report secondary problem	72	// problem already got signaled on receiver, do not report secondary problem
73	return null;	73	return null;
74	}	74	}
75	if (this.receiverType instanceof ReferenceBinding) {	75	if (this.actualReceiverType instanceof ReferenceBinding) {
76	ReferenceBinding refBinding = (ReferenceBinding) this.receiverType;	76	ReferenceBinding refBinding = (ReferenceBinding) this.actualReceiverType;
77	MethodBinding possibleMethod = this.receiver.isThis()	77	MethodBinding possibleMethod = this.receiver.isThis()
78	? scope.getImplicitMethod(this.token, Binding.NO_TYPES, this)	78	? scope.getImplicitMethod(this.token, Binding.NO_TYPES, this)
79	: scope.getMethod(refBinding, this.token, Binding.NO_TYPES, this);	79	: scope.getMethod(refBinding, this.token, Binding.NO_TYPES, this);
Lines 82-88 Link Here
82	} else {	82	} else {
83	ProblemMethodBinding problemMethodBinding = (ProblemMethodBinding) possibleMethod;	83	ProblemMethodBinding problemMethodBinding = (ProblemMethodBinding) possibleMethod;
84	if (problemMethodBinding.closestMatch == null) {	84	if (problemMethodBinding.closestMatch == null) {
85	scope.problemReporter().javadocInvalidField(this, fieldBinding, this.receiverType, scope.getDeclarationModifiers());	85	scope.problemReporter().javadocInvalidField(this, fieldBinding, this.actualReceiverType, scope.getDeclarationModifiers());
86	} else {	86	} else {
87	this.methodBinding = problemMethodBinding.closestMatch;	87	this.methodBinding = problemMethodBinding.closestMatch;
88	}	88	}

Lines 53-61 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionOnMemberAccess.java (-4 / +4 lines)
53		53
54	public TypeBinding resolveType(BlockScope scope) {	54	public TypeBinding resolveType(BlockScope scope) {
55		55
56	this.receiverType = this.receiver.resolveType(scope);	56	this.actualReceiverType = this.receiver.resolveType(scope);
57		57
58	if ((this.receiverType == null \|\| !this.receiverType.isValidBinding()) && this.receiver instanceof MessageSend) {	58	if ((this.actualReceiverType == null \|\| !this.actualReceiverType.isValidBinding()) && this.receiver instanceof MessageSend) {
59	MessageSend messageSend = (MessageSend) this.receiver;	59	MessageSend messageSend = (MessageSend) this.receiver;
60	if(messageSend.receiver instanceof ThisReference) {	60	if(messageSend.receiver instanceof ThisReference) {
61	Expression[] arguments = messageSend.arguments;	61	Expression[] arguments = messageSend.arguments;
Lines 73-82 Link Here
73	}	73	}
74	}	74	}
75		75
76	if (this.receiverType == null \|\| this.receiverType.isBaseType() \|\| !this.receiverType.isValidBinding())	76	if (this.actualReceiverType == null \|\| this.actualReceiverType.isBaseType() \|\| !this.actualReceiverType.isValidBinding())
77	throw new CompletionNodeFound();	77	throw new CompletionNodeFound();
78	else	78	else
79	throw new CompletionNodeFound(this, this.receiverType, scope);	79	throw new CompletionNodeFound(this, this.actualReceiverType, scope);
80	// array types are passed along to find the length field	80	// array types are passed along to find the length field
81	}	81	}
82	}	82	}

Lines 1927-1934 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/CompletionEngine.java (-4 / +4 lines)
1927	long completionPosition = fieldRef.nameSourcePosition;	1927	long completionPosition = fieldRef.nameSourcePosition;
1928	this.javadocTagPosition = fieldRef.tagSourceStart;	1928	this.javadocTagPosition = fieldRef.tagSourceStart;
1929		1929
1930	if (fieldRef.receiverType != null && fieldRef.receiverType.isValidBinding()) {	1930	if (fieldRef.actualReceiverType != null && fieldRef.actualReceiverType.isValidBinding()) {
1931	ReferenceBinding receiverType = (ReferenceBinding) fieldRef.receiverType;	1931	ReferenceBinding receiverType = (ReferenceBinding) fieldRef.actualReceiverType;
1932	int rangeStart = (int) (completionPosition >>> 32);	1932	int rangeStart = (int) (completionPosition >>> 32);
1933	if (fieldRef.receiver.isThis()) {	1933	if (fieldRef.receiver.isThis()) {
1934	if (fieldRef.completeInText()) {	1934	if (fieldRef.completeInText()) {
Lines 1984-1991 Link Here
1984	null,	1984	null,
1985	-1,	1985	-1,
1986	-1);	1986	-1);
1987	if (fieldRef.receiverType instanceof ReferenceBinding) {	1987	if (fieldRef.actualReceiverType instanceof ReferenceBinding) {
1988	ReferenceBinding refBinding = (ReferenceBinding)fieldRef.receiverType;	1988	ReferenceBinding refBinding = (ReferenceBinding)fieldRef.actualReceiverType;
1989	if (this.completionToken == null	1989	if (this.completionToken == null
1990	\|\| CharOperation.prefixEquals(this.completionToken, refBinding.sourceName)	1990	\|\| CharOperation.prefixEquals(this.completionToken, refBinding.sourceName)
1991	\|\| (this.options.camelCaseMatch && CharOperation.camelCaseMatch(this.completionToken, refBinding.sourceName))) {	1991	\|\| (this.options.camelCaseMatch && CharOperation.camelCaseMatch(this.completionToken, refBinding.sourceName))) {