Attachment #98656 for bug #228109

View | Details | Raw Unified | Return to bug 228109
Collapse All | Expand All




		"	^^^^^\n" + 
		"Cannot refer to the static enum field X.VALUE within an initializer\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 9)\n" + 
		"	VALUE = null;\n" + 
		"	^^^^^\n" + 
		"The final field X.VALUE cannot be assigned\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 9)\n" + 
		"	ASD = 5;\n" + 
		"	^^^\n" + 
		"Cannot refer to the static enum field X.ASD within an initializer\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 10)\n" + 
		"	X.VALUE = null;\n" + 
		"	  ^^^^^\n" + 
		"Cannot refer to the static enum field X.VALUE within an initializer\n" + 
		"----------\n" + 
		"4. ERROR in X.java (at line 11)\n" + 
		"	X.ASD = 5;\n" + 
		"	  ^^^\n" + 
		"Cannot refer to the static enum field X.ASD within an initializer\n" + 
		"----------\n");
}	
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=101713 - variation

		"	BLEU = null;\n" + 
		"	^^^^\n" + 
		"Cannot refer to the static enum field X.BLEU within an initializer\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 6)\n" + 
		"	BLEU = null;\n" + 
		"	^^^^\n" + 
		"The final field X.BLEU cannot be assigned\n" + 
		"----------\n");
}	
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=101713 - variation

		"	      ^^^^\n" + 
		"Cannot refer to the static enum field X.BLEU within an initializer\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 6)\n" + 
		"	X x = BLEU.BLANC; // ko\n" + 
		"	           ^^^^^\n" + 
		"Cannot refer to the static enum field X.BLANC within an initializer\n" + 
		"----------\n" + 
		"3. WARNING in X.java (at line 6)\n" + 
		"	X x = BLEU.BLANC; // ko\n" + 
		"	           ^^^^^\n" + 
		"The static field X.BLANC should be accessed in a static way\n" + 
		"----------\n" + 
		"4. ERROR in X.java (at line 7)\n" + 
		"	X x2 = BLEU; // ko\n" + 
		"	       ^^^^\n" + 
		"Cannot refer to the static enum field X.BLEU within an initializer\n" + 
		"----------\n" + 
		"5. WARNING in X.java (at line 10)\n" + 
		"	X x = BLEU.BLANC; // ok\n" + 
		"	           ^^^^^\n" + 
		"The static field X.BLANC should be accessed in a static way\n" + 
		"----------\n" + 
		"6. ERROR in X.java (at line 13)\n" + 
		"	X dummy = BLEU; // ko\n" + 
		"	          ^^^^\n" + 
		"Cannot refer to the static enum field X.BLEU within an initializer\n" + 
		"----------\n" + 
		"7. ERROR in X.java (at line 16)\n" + 
		"	X x = BLEU.BLANC; // ko\n" + 
		"	      ^^^^\n" + 
		"Cannot refer to the static enum field X.BLEU within an initializer\n" + 
		"----------\n" + 
		"8. ERROR in X.java (at line 16)\n" + 
		"	X x = BLEU.BLANC; // ko\n" + 
		"	           ^^^^^\n" + 
		"Cannot refer to the static enum field X.BLANC within an initializer\n" + 
		"----------\n" + 
		"9. WARNING in X.java (at line 16)\n" + 
		"	X x = BLEU.BLANC; // ko\n" + 
		"	           ^^^^^\n" + 
		"The static field X.BLANC should be accessed in a static way\n" + 
		"----------\n" + 
		"10. ERROR in X.java (at line 17)\n" + 
		"	X x2 = BLEU; // ko\n" + 
		"	       ^^^^\n" + 
		"Cannot refer to the static enum field X.BLEU within an initializer\n" + 

		"	             ^\n" + 
		"Cannot refer to the static enum field X.B within an initializer\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 5)\n" + 
		"	final X a2 = B.A;\n" + 
		"	               ^\n" + 
		"Cannot refer to the static enum field X.A within an initializer\n" + 
		"----------\n" + 
		"4. WARNING in X.java (at line 5)\n" + 
		"	final X a2 = B.A;\n" + 
		"	               ^\n" + 
		"The static field X.A should be accessed in a static way\n" + 

			"}\n",
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 8)\n" + 
		"	private static String error;\n" + 
		"	                      ^^^^^\n" + 
		"The field X.error is never read locally\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 8)\n" + 
		"	error = \"error\";\n" + 
		"	^^^^^\n" + 
		"Cannot refer to the static enum field X.error within an initializer\n" + 

		false,
		null);
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=228109
public void test153() {
	this.runNegativeTest(
		new String[] {
				"TestEnum.java",
				"public enum TestEnum {\n" + 
				"	RED, GREEN, BLUE; \n" + 
				"    static int test = 0;  \n" + 
				"\n" + 
				"    TestEnum() {\n" + 
				"        TestEnum.test=10;\n" + 
				"    }\n" + 
				"}\n"
		},
		"----------\n" + 
		"1. ERROR in TestEnum.java (at line 6)\n" + 
		"	TestEnum.test=10;\n" + 
		"	         ^^^^\n" + 
		"Cannot refer to the static enum field TestEnum.test within an initializer\n" + 
		"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=228109 - variation
public void test154() {
	this.runNegativeTest(
		new String[] {
				"TestEnum2.java",
				"public enum TestEnum2 {\n" + 
				"	; \n" + 
				"   static int test = 0;  \n" + 
				"	TestEnum2() {\n" + 
				"        TestEnum2.test=11;\n" + 
				"   }\n" + 
				"}\n" +
				"class X {\n" + 
				"	static int test = 0;\n" + 
				"	X() {\n" + 
				"		X.test = 13;\n" + 
				"	}\n" + 
				"}\n"
		},
		"----------\n" + 
		"1. ERROR in TestEnum2.java (at line 5)\n" + 
		"	TestEnum2.test=11;\n" + 
		"	          ^^^^\n" + 
		"Cannot refer to the static enum field TestEnum2.test within an initializer\n" + 
		"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=228109 - variation
public void test155() {
	this.runConformTest(
		new String[] {
				"TestEnum.java",
				"public enum TestEnum {\n" + 
				"	RED, GREEN, BLUE; \n" + 
				"    static int test = 0;  \n" + 
				"}\n" + 
				"\n" + 
				"enum TestEnum2 {\n" + 
				"	; \n" + 
				"    TestEnum2() {\n" + 
				"        TestEnum.test=12;\n" + 
				"    }\n" + 
				"}\n"
		},
		"");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=228109 - variation
public void test156() {
	this.runConformTest(
		new String[] {
				"TestEnum.java",
				"public enum TestEnum {\n" + 
				"	RED, GREEN, BLUE; \n" + 
				"    static int test = 0;  \n" + 
				"\n" + 
				"    TestEnum() {\n" + 
				"        new Object() {\n" +
				"			{ TestEnum.test=10; }\n" + 
				"		};\n" +
				"    }\n" + 
				"}\n"
		},
		"");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=228109 - variation
public void test157() {
	this.runNegativeTest(
		new String[] {
				"Foo.java",
				"enum Foo {\n" + 
				"	ONE, TWO, THREE;\n" + 
				"	static int val = 10;\n" + 
				"	Foo () {\n" + 
				"		this(Foo.val);\n" +
				"		System.out.println(Foo.val);\n" + 
				"	}\n" + 
				"	Foo(int i){}\n" +
				"	{\n" + 
				"		System.out.println(Foo.val);\n" + 
				"	}\n" + 
				"	int field = Foo.val;\n" + 
				"}\n"
		},
		"----------\n" + 
		"1. ERROR in Foo.java (at line 5)\n" + 
		"	this(Foo.val);\n" + 
		"	         ^^^\n" + 
		"Cannot refer to the static enum field Foo.val within an initializer\n" + 
		"----------\n" + 
		"2. ERROR in Foo.java (at line 6)\n" + 
		"	System.out.println(Foo.val);\n" + 
		"	                       ^^^\n" + 
		"Cannot refer to the static enum field Foo.val within an initializer\n" + 
		"----------\n" + 
		"3. ERROR in Foo.java (at line 10)\n" + 
		"	System.out.println(Foo.val);\n" + 
		"	                       ^^^\n" + 
		"Cannot refer to the static enum field Foo.val within an initializer\n" + 
		"----------\n" + 
		"4. ERROR in Foo.java (at line 12)\n" + 
		"	int field = Foo.val;\n" + 
		"	                ^^^\n" + 
		"Cannot refer to the static enum field Foo.val within an initializer\n" + 
		"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=228109 - variation
public void test158() {
	this.runNegativeTest(
		new String[] {
				"Foo.java",
				"enum Foo {\n" + 
				"	ONE, TWO, THREE;\n" + 
				"	static int val = 10;\n" + 
				"	Foo () {\n" + 
				"		this(val);\n" +
				"		System.out.println(val);\n" + 
				"	}\n" + 
				"	Foo(int i){}\n" +
				"	{\n" + 
				"		System.out.println(val);\n" + 
				"	}\n" + 
				"	int field = val;\n" + 
				"}\n"
		},
		"----------\n" + 
		"1. ERROR in Foo.java (at line 5)\n" + 
		"	this(val);\n" + 
		"	     ^^^\n" + 
		"Cannot refer to the static enum field Foo.val within an initializer\n" + 
		"----------\n" + 
		"2. ERROR in Foo.java (at line 6)\n" + 
		"	System.out.println(val);\n" + 
		"	                   ^^^\n" + 
		"Cannot refer to the static enum field Foo.val within an initializer\n" + 
		"----------\n" + 
		"3. ERROR in Foo.java (at line 10)\n" + 
		"	System.out.println(val);\n" + 
		"	                   ^^^\n" + 
		"Cannot refer to the static enum field Foo.val within an initializer\n" + 
		"----------\n" + 
		"4. ERROR in Foo.java (at line 12)\n" + 
		"	int field = val;\n" + 
		"	            ^^^\n" + 
		"Cannot refer to the static enum field Foo.val within an initializer\n" + 
		"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=228109 - variation
public void test159() {
	this.runNegativeTest(
		new String[] {
				"Foo.java",
				"enum Foo {\n" + 
				"	ONE, TWO, THREE;\n" + 
				"	static int val = 10;\n" + 
				"	Foo () {\n" + 
				"		this(get().val);\n" +
				"		System.out.println(get().val);\n" + 
				"	}\n" + 
				"	Foo(int i){}\n" +
				"	{\n" + 
				"		System.out.println(get().val);\n" + 
				"	}\n" + 
				"	int field = get().val;\n" + 
				"	Foo get() { return ONE; }\n" + 
				"}\n"
		},
		"----------\n" + 
		"1. ERROR in Foo.java (at line 5)\n" + 
		"	this(get().val);\n" + 
		"	     ^^^\n" + 
		"Cannot refer to an instance method while explicitly invoking a constructor\n" + 
		"----------\n" + 
		"2. WARNING in Foo.java (at line 5)\n" + 
		"	this(get().val);\n" + 
		"	           ^^^\n" + 
		"The static field Foo.val should be accessed in a static way\n" + 
		"----------\n" + 
		"3. ERROR in Foo.java (at line 5)\n" + 
		"	this(get().val);\n" + 
		"	           ^^^\n" + 
		"Cannot refer to the static enum field Foo.val within an initializer\n" + 
		"----------\n" + 
		"4. WARNING in Foo.java (at line 6)\n" + 
		"	System.out.println(get().val);\n" + 
		"	                         ^^^\n" + 
		"The static field Foo.val should be accessed in a static way\n" + 
		"----------\n" + 
		"5. ERROR in Foo.java (at line 6)\n" + 
		"	System.out.println(get().val);\n" + 
		"	                         ^^^\n" + 
		"Cannot refer to the static enum field Foo.val within an initializer\n" + 
		"----------\n" + 
		"6. WARNING in Foo.java (at line 10)\n" + 
		"	System.out.println(get().val);\n" + 
		"	                         ^^^\n" + 
		"The static field Foo.val should be accessed in a static way\n" + 
		"----------\n" + 
		"7. ERROR in Foo.java (at line 10)\n" + 
		"	System.out.println(get().val);\n" + 
		"	                         ^^^\n" + 
		"Cannot refer to the static enum field Foo.val within an initializer\n" + 
		"----------\n" + 
		"8. WARNING in Foo.java (at line 12)\n" + 
		"	int field = get().val;\n" + 
		"	                  ^^^\n" + 
		"The static field Foo.val should be accessed in a static way\n" + 
		"----------\n" + 
		"9. ERROR in Foo.java (at line 12)\n" + 
		"	int field = get().val;\n" + 
		"	                  ^^^\n" + 
		"Cannot refer to the static enum field Foo.val within an initializer\n" + 
		"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=228109 - variation
public void test160() {
	this.runNegativeTest(
		new String[] {
				"Foo.java",
				"enum Foo {\n" + 
				"	ONE, TWO, THREE;\n" + 
				"	static int val = 10;\n" + 
				"	Foo () {\n" + 
				"		this(get().val = 1);\n" + 
				"		System.out.println(get().val = 2);\n" + 
				"	}\n" + 
				"	Foo(int i){}\n" + 
				"	{\n" + 
				"		System.out.println(get().val = 3);\n" + 
				"	}\n" + 
				"	int field = get().val = 4;\n" + 
				"	Foo get() { return ONE; }\n" + 
				"}\n"
		},
		"----------\n" + 
		"1. ERROR in Foo.java (at line 5)\n" + 
		"	this(get().val = 1);\n" + 
		"	     ^^^\n" + 
		"Cannot refer to an instance method while explicitly invoking a constructor\n" + 
		"----------\n" + 
		"2. WARNING in Foo.java (at line 5)\n" + 
		"	this(get().val = 1);\n" + 
		"	           ^^^\n" + 
		"The static field Foo.val should be accessed in a static way\n" + 
		"----------\n" + 
		"3. ERROR in Foo.java (at line 5)\n" + 
		"	this(get().val = 1);\n" + 
		"	           ^^^\n" + 
		"Cannot refer to the static enum field Foo.val within an initializer\n" + 
		"----------\n" + 
		"4. WARNING in Foo.java (at line 6)\n" + 
		"	System.out.println(get().val = 2);\n" + 
		"	                         ^^^\n" + 
		"The static field Foo.val should be accessed in a static way\n" + 
		"----------\n" + 
		"5. ERROR in Foo.java (at line 6)\n" + 
		"	System.out.println(get().val = 2);\n" + 
		"	                         ^^^\n" + 
		"Cannot refer to the static enum field Foo.val within an initializer\n" + 
		"----------\n" + 
		"6. WARNING in Foo.java (at line 10)\n" + 
		"	System.out.println(get().val = 3);\n" + 
		"	                         ^^^\n" + 
		"The static field Foo.val should be accessed in a static way\n" + 
		"----------\n" + 
		"7. ERROR in Foo.java (at line 10)\n" + 
		"	System.out.println(get().val = 3);\n" + 
		"	                         ^^^\n" + 
		"Cannot refer to the static enum field Foo.val within an initializer\n" + 
		"----------\n" + 
		"8. WARNING in Foo.java (at line 12)\n" + 
		"	int field = get().val = 4;\n" + 
		"	                  ^^^\n" + 
		"The static field Foo.val should be accessed in a static way\n" + 
		"----------\n" + 
		"9. ERROR in Foo.java (at line 12)\n" + 
		"	int field = get().val = 4;\n" + 
		"	                  ^^^\n" + 
		"Cannot refer to the static enum field Foo.val within an initializer\n" + 
		"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=228109 - variation
public void test161() {
	this.runConformTest(
		new String[] {
				"EnumTest1.java",
				"enum EnumTest1 {\n" + 
				"	;\n" + 
				"	static int foo = EnumTest2.bar;\n" + 
				"}\n" + 
				"enum EnumTest2 {\n" + 
				"	;\n" + 
				"	static int bar = EnumTest1.foo;\n" + 
				"}\n"
		},
		"");
}
}





import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.internal.compiler.ASTVisitor;
import org.eclipse.jdt.internal.compiler.impl.*;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
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.FieldBinding;
import org.eclipse.jdt.internal.compiler.lookup.InvocationSite;
import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
import org.eclipse.jdt.internal.compiler.lookup.MethodScope;
import org.eclipse.jdt.internal.compiler.lookup.ProblemReasons;
import org.eclipse.jdt.internal.compiler.lookup.ProblemReferenceBinding;
import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
import org.eclipse.jdt.internal.compiler.lookup.Scope;
import org.eclipse.jdt.internal.compiler.lookup.SourceTypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.TagBits;
import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeIds;

public class FieldReference extends Reference implements InvocationSite {


	public TypeBinding genericCast;
	
public FieldReference(char[] source, long pos) {
	this.token = source;
	this.nameSourcePosition = pos;
	//by default the position are the one of the field (not true for super access)
	this.sourceStart = (int) (pos >>> 32);
	this.sourceEnd = (int) (pos & 0x00000000FFFFFFFFL);
	this.bits |= Binding.FIELD;

}

public FlowInfo analyseAssignment(BlockScope currentScope, 	FlowContext flowContext, 	FlowInfo flowInfo, Assignment assignment, boolean isCompound) {
	// compound assignment extra work
	if (isCompound) { // check the variable part is initialized if blank final
		if (this.binding.isBlankFinal()
			&& this.receiver.isThis()
			&& currentScope.needBlankFinalFieldInitializationCheck(this.binding)
			&& (!flowInfo.isDefinitelyAssigned(this.binding))) {
			currentScope.problemReporter().uninitializedBlankFinalField(this.binding, this);
			// we could improve error msg here telling "cannot use compound assignment on final blank field"
		}
		manageSyntheticAccessIfNecessary(currentScope, flowInfo, true /*read-access*/);
	}
	flowInfo =
		this.receiver
			.analyseCode(currentScope, flowContext, flowInfo, !this.binding.isStatic())
			.unconditionalInits();
	if (assignment.expression != null) {
		flowInfo =

	manageSyntheticAccessIfNecessary(currentScope, flowInfo, false /*write-access*/);

	// check if assigning a final field 
	if (this.binding.isFinal()) {
		// in a context where it can be assigned?
		if (this.binding.isBlankFinal()
			&& !isCompound
			&& this.receiver.isThis()
			&& !(this.receiver instanceof QualifiedThisReference)
			&& ((this.receiver.bits & ASTNode.ParenthesizedMASK) == 0) // (this).x is forbidden
			&& currentScope.allowBlankFinalFieldAssignment(this.binding)) {
			if (flowInfo.isPotentiallyAssigned(this.binding)) {
				currentScope.problemReporter().duplicateInitializationOfBlankFinalField(
					this.binding,
					this);
			} else {
				flowContext.recordSettingFinal(this.binding, this, flowInfo);
			}
			flowInfo.markAsDefinitelyAssigned(this.binding);
		} else {
			// assigning a final field outside an initializer or constructor or wrong reference
			currentScope.problemReporter().cannotAssignToFinalField(this.binding, this);
		}
	}
	return flowInfo;

}

public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
	boolean nonStatic = !this.binding.isStatic();
	this.receiver.analyseCode(currentScope, flowContext, flowInfo, nonStatic);
	if (nonStatic) {
		this.receiver.checkNPE(currentScope, flowContext, flowInfo);
	}
	
	if (valueRequired || currentScope.compilerOptions().complianceLevel >= ClassFileConstants.JDK1_4) {

	    // extra cast needed if method return type is type variable
		if (originalBinding != this.binding 
				&& originalType != this.binding.type
				&& runtimeTimeType.id != TypeIds.T_JavaLangObject
				&& (originalType.tagBits & TagBits.HasTypeVariable) != 0) {
	    	TypeBinding targetType = (!compileTimeType.isBaseType() && runtimeTimeType.isBaseType()) 
	    		? compileTimeType  // unboxing: checkcast before conversion

}

public FieldBinding fieldBinding() {
	return this.binding;
}

public void generateAssignment(BlockScope currentScope, CodeStream codeStream, Assignment assignment, boolean valueRequired) {
	int pc = codeStream.position;
	this.receiver.generateCode(
		currentScope,
		codeStream,
		!this.codegenBinding.isStatic());

	fieldStore(
		codeStream,
		this.codegenBinding,
		this.syntheticAccessors == null ? null : this.syntheticAccessors[FieldReference.WRITE],
		valueRequired);
	if (valueRequired) {
		codeStream.generateImplicitConversion(assignment.implicitConversion);

 */
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);
		}
		codeStream.recordPositionsFrom(pc, this.sourceStart);
		return;

	Constant fieldConstant = this.codegenBinding.constant();
	if (fieldConstant != Constant.NotAConstant) {
		if (!isThisReceiver) {
			this.receiver.generateCode(currentScope, codeStream, !isStatic);
			if (!isStatic){
				codeStream.invokeObjectGetClass();
				codeStream.pop();
			}
		}
		if (valueRequired) {
			codeStream.generateConstant(fieldConstant, this.implicitConversion);
		}
		codeStream.recordPositionsFrom(pc, this.sourceStart);
		return;
	}
	if (valueRequired 
			|| (!isThisReceiver && currentScope.compilerOptions().complianceLevel >= ClassFileConstants.JDK1_4)
			|| ((this.implicitConversion & TypeIds.UNBOXING) != 0)
			|| (this.genericCast != null)) {
		this.receiver.generateCode(currentScope, codeStream, !isStatic);
		pc = codeStream.position;
		if (this.codegenBinding.declaringClass == null) { // array length
			codeStream.arraylength();
			if (valueRequired) {
				codeStream.generateImplicitConversion(this.implicitConversion);
			} else {
				// could occur if !valueRequired but compliance >= 1.4
				codeStream.pop();
			}
		} else {
			if (this.syntheticAccessors == null || this.syntheticAccessors[FieldReference.READ] == null) {
				if (isStatic) {
					codeStream.getstatic(this.codegenBinding);
				} else {
					codeStream.getfield(this.codegenBinding);
				}
			} else {
				codeStream.invokestatic(this.syntheticAccessors[FieldReference.READ]);
			}
			// required cast must occur even if no value is required
			if (this.genericCast != null) codeStream.checkcast(this.genericCast);
			if (valueRequired) {
				codeStream.generateImplicitConversion(this.implicitConversion);
			} else {
				boolean isUnboxing = (this.implicitConversion & TypeIds.UNBOXING) != 0;
				// conversion only generated if unboxing
				if (isUnboxing) codeStream.generateImplicitConversion(this.implicitConversion);
				switch (isUnboxing ? postConversionType(currentScope).id : this.codegenBinding.type.id) {
					case T_long :
					case T_double :

			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.receiverType.erasure()) {
					MethodBinding accessor = this.syntheticAccessors == null ? null : this.syntheticAccessors[FieldReference.READ]; 
					if (accessor == null) {
						codeStream.getstatic(this.codegenBinding);
					} else {

				}
			}
		} else {
			this.receiver.generateCode(currentScope, codeStream, !isStatic);				
			if (!isStatic){
				codeStream.invokeObjectGetClass(); // perform null check
				codeStream.pop();


public void generateCompoundAssignment(BlockScope currentScope, CodeStream codeStream, Expression expression, int operator, int assignmentImplicitConversion, boolean valueRequired) {
	boolean isStatic;
	this.receiver.generateCode(
		currentScope,
		codeStream,
		!(isStatic = this.codegenBinding.isStatic()));
	if (isStatic) {
		if (this.syntheticAccessors == null || this.syntheticAccessors[FieldReference.READ] == null) {
			codeStream.getstatic(this.codegenBinding);
		} else {
			codeStream.invokestatic(this.syntheticAccessors[FieldReference.READ]);
		}
	} else {
		codeStream.dup();
		if (this.syntheticAccessors == null || this.syntheticAccessors[FieldReference.READ] == null) {
			codeStream.getfield(this.codegenBinding);
		} else {
			codeStream.invokestatic(this.syntheticAccessors[FieldReference.READ]);
		}
	}
	int operationTypeID;
	switch(operationTypeID = (this.implicitConversion & TypeIds.IMPLICIT_CONVERSION_MASK) >> 4) {
		case T_JavaLangString :
		case T_JavaLangObject :
		case T_undefined :

			if (this.genericCast != null)
				codeStream.checkcast(this.genericCast);				
			// promote the array reference to the suitable operation type
			codeStream.generateImplicitConversion(this.implicitConversion);
			// generate the increment value (will by itself  be promoted to the operation value)
			if (expression == IntLiteral.One) { // prefix operation
				codeStream.generateConstant(expression.constant, this.implicitConversion);
			} else {
				expression.generateCode(currentScope, codeStream, true);
			}

	fieldStore(
		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;
	this.receiver.generateCode(
		currentScope,
		codeStream,
		!(isStatic = this.codegenBinding.isStatic()));
	if (isStatic) {
		if (this.syntheticAccessors == null || this.syntheticAccessors[FieldReference.READ] == null) {
			codeStream.getstatic(this.codegenBinding);
		} else {
			codeStream.invokestatic(this.syntheticAccessors[FieldReference.READ]);
		}
	} else {
		codeStream.dup();
		if (this.syntheticAccessors == null || this.syntheticAccessors[FieldReference.READ] == null) {
			codeStream.getfield(this.codegenBinding);
		} else {
			codeStream.invokestatic(this.syntheticAccessors[FieldReference.READ]);
		}
	}
	if (valueRequired) {

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

/**

	return null;
}
public boolean isSuperAccess() {
	return this.receiver.isSuper();
}

public boolean isTypeAccess() {
	return this.receiver != null && this.receiver.isTypeReference();
}

/*

	// if field from parameterized type got found, use the original field at codegen time
	this.codegenBinding = this.binding.original();
	
	if (this.binding.isPrivate()) {
		if ((currentScope.enclosingSourceType() != this.codegenBinding.declaringClass) 
				&& this.binding.constant() == Constant.NotAConstant) {
			if (this.syntheticAccessors == null)
				this.syntheticAccessors = new MethodBinding[2];
			this.syntheticAccessors[isReadAccess ? FieldReference.READ : FieldReference.WRITE] = 
				((SourceTypeBinding) this.codegenBinding.declaringClass).addSyntheticMethod(this.codegenBinding, isReadAccess);
			currentScope.problemReporter().needToEmulateFieldAccess(this.codegenBinding, this, isReadAccess);
			return;
		}

	} else if (this.receiver instanceof QualifiedSuperReference) { // qualified super

		// qualified super need emulation always
		SourceTypeBinding destinationType =
			(SourceTypeBinding) (((QualifiedSuperReference) this.receiver)
				.currentCompatibleType);
		if (this.syntheticAccessors == null)
			this.syntheticAccessors = new MethodBinding[2];
		this.syntheticAccessors[isReadAccess ? FieldReference.READ : FieldReference.WRITE] = destinationType.addSyntheticMethod(this.codegenBinding, isReadAccess);
		currentScope.problemReporter().needToEmulateFieldAccess(this.codegenBinding, this, isReadAccess);
		return;

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

		SourceTypeBinding enclosingSourceType;
		if (((this.bits & ASTNode.DepthMASK) != 0)
			&& this.binding.declaringClass.getPackage()
				!= (enclosingSourceType = currentScope.enclosingSourceType()).getPackage()) {

			SourceTypeBinding currentCompatibleType =
				(SourceTypeBinding) enclosingSourceType.enclosingTypeAt(
					(this.bits & ASTNode.DepthMASK) >> ASTNode.DepthSHIFT);
			if (this.syntheticAccessors == null)
				this.syntheticAccessors = new MethodBinding[2];
			this.syntheticAccessors[isReadAccess ? FieldReference.READ : FieldReference.WRITE] = currentCompatibleType.addSyntheticMethod(this.codegenBinding, isReadAccess);
			currentScope.problemReporter().needToEmulateFieldAccess(this.codegenBinding, this, isReadAccess);
			return;
		}

			&& 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 =

	TypeBinding convertedType = this.resolvedType;
	if (this.genericCast != null) 
		convertedType = this.genericCast;
	int runtimeType = (this.implicitConversion & TypeIds.IMPLICIT_CONVERSION_MASK) >> 4;
	switch (runtimeType) {
		case T_boolean :
			convertedType = TypeBinding.BOOLEAN;

			break;
		default :
	}		
	if ((this.implicitConversion & TypeIds.BOXING) != 0) {
		convertedType = scope.environment().computeBoxingType(convertedType);
	}
	return convertedType;
}

public StringBuffer printExpression(int indent, StringBuffer output) {
	return this.receiver.printExpression(0, output).append('.').append(this.token);
}

public TypeBinding resolveType(BlockScope scope) {

	//always ignore receiver cast, since may affect constant pool reference
	boolean receiverCast = false;
	if (this.receiver instanceof CastExpression) {
		this.receiver.bits |= ASTNode.DisableUnnecessaryCastCheck; // will check later on
		receiverCast = true;
	}
	this.receiverType = this.receiver.resolveType(scope);
	if (this.receiverType == null) {
		this.constant = Constant.NotAConstant;
		return null;
	}
	if (receiverCast) {

		}
	}		
	// the case receiverType.isArrayType and token = 'length' is handled by the scope API
	FieldBinding fieldBinding = this.codegenBinding = this.binding = scope.getField(this.receiverType, 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;

		}
	}
	this.receiver.computeConversion(scope, this.receiverType, this.receiverType);
	if (isFieldUseDeprecated(fieldBinding, scope, (this.bits & ASTNode.IsStrictlyAssigned) !=0)) {
		scope.problemReporter().deprecatedField(fieldBinding, this);
	}
	boolean isImplicitThisRcv = this.receiver.isImplicitThis();
	this.constant = isImplicitThisRcv ? fieldBinding.constant() : Constant.NotAConstant;
	if (fieldBinding.isStatic()) {
		// static field accessed through receiver? legal but unoptimal (optional warning)
		if (!(isImplicitThisRcv
				|| (this.receiver instanceof NameReference 
					&& (((NameReference) this.receiver).bits & Binding.TYPE) != 0))) {
			scope.problemReporter().nonStaticAccessToStaticField(this, fieldBinding);
		}
		ReferenceBinding declaringClass = this.binding.declaringClass;
		if (!isImplicitThisRcv
				&& declaringClass != this.receiverType
				&& declaringClass.canBeSeenBy(scope)) {
			scope.problemReporter().indirectAccessToStaticField(this, fieldBinding);
		}
		// check if accessing enum static field in initializer
		if (declaringClass.isEnum()) {
			MethodScope methodScope = scope.methodScope();
			SourceTypeBinding sourceType = scope.enclosingSourceType();
			if (this.constant == Constant.NotAConstant
					&& !methodScope.isStatic
					&& (sourceType == declaringClass || sourceType.superclass == declaringClass) // enum constant body
					&& methodScope.isInsideInitializerOrConstructor()) {
				scope.problemReporter().enumStaticFieldUsedDuringInitialization(this.binding, this);
			}
		}		
	}
	TypeBinding fieldType = fieldBinding.type;
	if (fieldType != null) {
		if ((this.bits & ASTNode.IsStrictlyAssigned) == 0) {
			fieldType = fieldType.capture(scope, this.sourceEnd);	// perform capture conversion if read access
		}
		this.resolvedType = fieldType;

}

public void setDepth(int depth) {
	this.bits &= ~ASTNode.DepthMASK; // flush previous depth if any			
	if (depth > 0) {
		this.bits |= (depth & 0xFF) << ASTNode.DepthSHIFT; // encoded on 8 bits
	}
}



public void traverse(ASTVisitor visitor, BlockScope scope) {
	if (visitor.visit(this, scope)) {
		this.receiver.traverse(visitor, scope);
	}
	visitor.endVisit(this, scope);
}




		case Binding.FIELD : // assigning to a field
			manageSyntheticAccessIfNecessary(currentScope, flowInfo, false /*write-access*/);

			FieldBinding fieldBinding = (FieldBinding) this.binding;
			ReferenceBinding declaringClass = fieldBinding.declaringClass;
			// check if accessing enum static field in initializer
			if (declaringClass.isEnum()) {
				MethodScope methodScope = currentScope.methodScope();
				SourceTypeBinding sourceType = currentScope.enclosingSourceType();
				if (fieldBinding.isStatic()
						&& this.constant == Constant.NotAConstant
						&& !methodScope.isStatic
						&& (sourceType == declaringClass || sourceType.superclass == declaringClass) // enum constant body
						&& methodScope.isInsideInitializerOrConstructor()) {
					currentScope.problemReporter().enumStaticFieldUsedDuringInitialization(fieldBinding, this);
				}
			}					
			// check if assigning a final field
			FieldBinding fieldBinding = (FieldBinding) this.binding;
			if (fieldBinding.isFinal()) {
				// inside a context where allowed
				if (!isCompound && fieldBinding.isBlankFinal() && currentScope.allowBlankFinalFieldAssignment(fieldBinding)) {

			if (valueRequired || currentScope.compilerOptions().complianceLevel >= ClassFileConstants.JDK1_4) {
				manageSyntheticAccessIfNecessary(currentScope, flowInfo, true /*read-access*/);
			}
			FieldBinding fieldBinding = (FieldBinding) this.binding;
			ReferenceBinding declaringClass = fieldBinding.declaringClass;
			// check if accessing enum static field in initializer
			if (declaringClass.isEnum()) {
				MethodScope methodScope = currentScope.methodScope();
				SourceTypeBinding sourceType = currentScope.enclosingSourceType();
				if (fieldBinding.isStatic()
						&& this.constant == Constant.NotAConstant
						&& !methodScope.isStatic
						&& (sourceType == declaringClass || sourceType.superclass == declaringClass) // enum constant body
						&& methodScope.isInsideInitializerOrConstructor()) {
					currentScope.problemReporter().enumStaticFieldUsedDuringInitialization(fieldBinding, this);
				}
			}				
			// check if reading a final blank field
			FieldBinding fieldBinding = (FieldBinding) this.binding;
			if (fieldBinding.isBlankFinal() && currentScope.needBlankFinalFieldInitializationCheck(fieldBinding)) {
				if (!flowInfo.isDefinitelyAssigned(fieldBinding)) {
					currentScope.problemReporter().uninitializedBlankFinalField(fieldBinding, this);


public TypeBinding checkFieldAccess(BlockScope scope) {
	FieldBinding fieldBinding = (FieldBinding) this.binding;
	this.constant = fieldBinding.constant();
	
	this.bits &= ~ASTNode.RestrictiveFlagMASK; // clear bits
	this.bits |= Binding.FIELD;
	MethodScope methodScope = scope.methodScope();
	if (fieldBinding.isStatic()) {
		// check if accessing enum static field in initializer
		ReferenceBinding declaringClass = fieldBinding.declaringClass;
		if (declaringClass.isEnum()) {
			SourceTypeBinding sourceType = scope.enclosingSourceType();
			if (this.constant == Constant.NotAConstant
					&& !methodScope.isStatic
					&& (sourceType == declaringClass || sourceType.superclass == declaringClass) // enum constant body
					&& methodScope.isInsideInitializerOrConstructor()) {
				scope.problemReporter().enumStaticFieldUsedDuringInitialization(fieldBinding, this);
			}
		}		
	} else {
		if (scope.compilerOptions().getSeverity(CompilerOptions.UnqualifiedFieldAccess) != ProblemSeverities.Ignore) {
			scope.problemReporter().unqualifiedFieldAccess(this, fieldBinding);
		}		
		// must check for the static status....
		if (methodScope.isStatic) {
			scope.problemReporter().staticFieldAccessToNonStaticVariable(this, fieldBinding);
			this.constant = Constant.NotAConstant;
			return fieldBinding.type;
		}
	}
	this.constant = fieldBinding.constant();

	if (isFieldUseDeprecated(fieldBinding, scope, (this.bits & ASTNode.IsStrictlyAssigned) !=0))
		scope.problemReporter().deprecatedField(fieldBinding, this);

						this.constant = (this.bits & ASTNode.IsStrictlyAssigned) == 0 ? variable.constant() : Constant.NotAConstant;
					} else {
						// a field
						FieldBinding field = (FieldBinding) this.binding;
						if (!field.isStatic() && scope.compilerOptions().getSeverity(CompilerOptions.UnqualifiedFieldAccess) != ProblemSeverities.Ignore) {
							scope.problemReporter().unqualifiedFieldAccess(this, field);
						}
						variableType = checkFieldAccess(scope);
					}
					// perform capture conversion if read access




			if (needValue || complyTo14) {
				manageSyntheticAccessIfNecessary(currentScope, lastFieldBinding, this.actualReceiverType, 0, flowInfo);
			}
			if (this.indexOfFirstFieldBinding == 1) { // was an implicit reference to the first field binding
				ReferenceBinding declaringClass = lastFieldBinding.declaringClass;
				// check if accessing enum static field in initializer					
				if (declaringClass.isEnum()) {
					MethodScope methodScope = currentScope.methodScope();
					SourceTypeBinding sourceType = methodScope.enclosingSourceType();
					if (lastFieldBinding.isStatic()
							&& (sourceType == declaringClass || sourceType.superclass == declaringClass) // enum constant body
							&& lastFieldBinding.constant() == Constant.NotAConstant
							&& !methodScope.isStatic
							&& methodScope.isInsideInitializerOrConstructor()) {
						currentScope.problemReporter().enumStaticFieldUsedDuringInitialization(lastFieldBinding, this);
					}
				}				
			}
			// check if final blank field
			if (lastFieldBinding.isBlankFinal()
				    && this.otherBindings != null // the last field binding is only assigned

			}
			if (this.indexOfFirstFieldBinding == 1) { // was an implicit reference to the first field binding
				FieldBinding fieldBinding = (FieldBinding) this.binding;
				ReferenceBinding declaringClass = fieldBinding.declaringClass;
				// check if accessing enum static field in initializer					
				if (declaringClass.isEnum()) {
					MethodScope methodScope = currentScope.methodScope();
					SourceTypeBinding sourceType = methodScope.enclosingSourceType();
					if (fieldBinding.isStatic()
							&& (sourceType == declaringClass || sourceType.superclass == declaringClass) // enum constant body
							&& fieldBinding.constant() == Constant.NotAConstant
							&& !methodScope.isStatic
							&& methodScope.isInsideInitializerOrConstructor()) {
						currentScope.problemReporter().enumStaticFieldUsedDuringInitialization(fieldBinding, this);
					}
				}				
				// check if reading a final blank field
				if (fieldBinding.isBlankFinal()
						&& currentScope.needBlankFinalFieldInitializationCheck(fieldBinding)

				scope.problemReporter().staticFieldAccessToNonStaticVariable(this, field);
				return null;
			 }
		} else if (this.indexOfFirstFieldBinding > 1 
			// indirect static reference ?
			if (this.indexOfFirstFieldBinding > 1 
					&& field.declaringClass != this.actualReceiverType
					&& field.declaringClass.canBeSeenBy(scope)) {
			scope.problemReporter().indirectAccessToStaticField(this, field);
			}
		}
		// only last field is actually a write access if any
		if (isFieldUseDeprecated(field, scope, (this.bits & ASTNode.IsStrictlyAssigned) != 0 && this.indexOfFirstFieldBinding == length))

			}

			if (field.isStatic()) {
				// check if accessing enum static field in initializer
				ReferenceBinding declaringClass = field.declaringClass;
				if (declaringClass.isEnum()) {
					MethodScope methodScope = scope.methodScope();
					SourceTypeBinding sourceType = methodScope.enclosingSourceType();
					if ((sourceType == declaringClass || sourceType.superclass == declaringClass) // enum constant body
							&& field.constant() == Constant.NotAConstant
							&& !methodScope.isStatic
							&& methodScope.isInsideInitializerOrConstructor()) {
						scope.problemReporter().enumStaticFieldUsedDuringInitialization(field, this);
					}
				}					
				// static field accessed through receiver? legal but unoptimal (optional warning)
				scope.problemReporter().nonStaticAccessToStaticField(this, field, index);
				// indirect static reference ?

							&& (!fieldBinding.isStatic() || methodScope.isStatic)) {
						scope.problemReporter().forwardReference(this, 0, methodScope.enclosingSourceType());
					}
					if (fieldBinding.isStatic()) {
						ReferenceBinding declaringClass = fieldBinding.declaringClass;
						// check if accessing enum static field in initializer					
						if (declaringClass.isEnum()) {
							SourceTypeBinding sourceType = methodScope.enclosingSourceType();
							if ((sourceType == declaringClass || sourceType.superclass == declaringClass) // enum constant body
									&& fieldBinding.constant() == Constant.NotAConstant
									&& !methodScope.isStatic
									&& methodScope.isInsideInitializerOrConstructor()) {
								scope.problemReporter().enumStaticFieldUsedDuringInitialization(fieldBinding, this);
							}
						}						
					} else if (this.indexOfFirstFieldBinding == 1 && scope.compilerOptions().getSeverity(CompilerOptions.UnqualifiedFieldAccess) != ProblemSeverities.Ignore) {
						scope.problemReporter().unqualifiedFieldAccess(this, fieldBinding);
					}
					this.bits &= ~ASTNode.RestrictiveFlagMASK; // clear bits

Return to bug 228109

Lines 89-109 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/SingleNameReference.java (-36 / +19 lines)
89	case Binding.FIELD : // assigning to a field	89	case Binding.FIELD : // assigning to a field
90	manageSyntheticAccessIfNecessary(currentScope, flowInfo, false /write-access/);	90	manageSyntheticAccessIfNecessary(currentScope, flowInfo, false /write-access/);
91		91
92	FieldBinding fieldBinding = (FieldBinding) this.binding;
93	ReferenceBinding declaringClass = fieldBinding.declaringClass;
94	// check if accessing enum static field in initializer
95	if (declaringClass.isEnum()) {
96	MethodScope methodScope = currentScope.methodScope();
97	SourceTypeBinding sourceType = currentScope.enclosingSourceType();
98	if (fieldBinding.isStatic()
99	&& this.constant == Constant.NotAConstant
100	&& !methodScope.isStatic
101	&& (sourceType == declaringClass \|\| sourceType.superclass == declaringClass) // enum constant body
102	&& methodScope.isInsideInitializerOrConstructor()) {
103	currentScope.problemReporter().enumStaticFieldUsedDuringInitialization(fieldBinding, this);
104	}
105	}
106	// check if assigning a final field	92	// check if assigning a final field
		93	FieldBinding fieldBinding = (FieldBinding) this.binding;
107	if (fieldBinding.isFinal()) {	94	if (fieldBinding.isFinal()) {
108	// inside a context where allowed	95	// inside a context where allowed
109	if (!isCompound && fieldBinding.isBlankFinal() && currentScope.allowBlankFinalFieldAssignment(fieldBinding)) {	96	if (!isCompound && fieldBinding.isBlankFinal() && currentScope.allowBlankFinalFieldAssignment(fieldBinding)) {
Lines 158-178 Link Here
158	if (valueRequired \|\| currentScope.compilerOptions().complianceLevel >= ClassFileConstants.JDK1_4) {	145	if (valueRequired \|\| currentScope.compilerOptions().complianceLevel >= ClassFileConstants.JDK1_4) {
159	manageSyntheticAccessIfNecessary(currentScope, flowInfo, true /read-access/);	146	manageSyntheticAccessIfNecessary(currentScope, flowInfo, true /read-access/);
160	}	147	}
161	FieldBinding fieldBinding = (FieldBinding) this.binding;
162	ReferenceBinding declaringClass = fieldBinding.declaringClass;
163	// check if accessing enum static field in initializer
164	if (declaringClass.isEnum()) {
165	MethodScope methodScope = currentScope.methodScope();
166	SourceTypeBinding sourceType = currentScope.enclosingSourceType();
167	if (fieldBinding.isStatic()
168	&& this.constant == Constant.NotAConstant
169	&& !methodScope.isStatic
170	&& (sourceType == declaringClass \|\| sourceType.superclass == declaringClass) // enum constant body
171	&& methodScope.isInsideInitializerOrConstructor()) {
172	currentScope.problemReporter().enumStaticFieldUsedDuringInitialization(fieldBinding, this);
173	}
174	}
175	// check if reading a final blank field	148	// check if reading a final blank field
		149	FieldBinding fieldBinding = (FieldBinding) this.binding;
176	if (fieldBinding.isBlankFinal() && currentScope.needBlankFinalFieldInitializationCheck(fieldBinding)) {	150	if (fieldBinding.isBlankFinal() && currentScope.needBlankFinalFieldInitializationCheck(fieldBinding)) {
177	if (!flowInfo.isDefinitelyAssigned(fieldBinding)) {	151	if (!flowInfo.isDefinitelyAssigned(fieldBinding)) {
178	currentScope.problemReporter().uninitializedBlankFinalField(fieldBinding, this);	152	currentScope.problemReporter().uninitializedBlankFinalField(fieldBinding, this);
Lines 198-217 Link Here
198		172
199	public TypeBinding checkFieldAccess(BlockScope scope) {	173	public TypeBinding checkFieldAccess(BlockScope scope) {
200	FieldBinding fieldBinding = (FieldBinding) this.binding;	174	FieldBinding fieldBinding = (FieldBinding) this.binding;
		175	this.constant = fieldBinding.constant();
201		176
202	this.bits &= ~ASTNode.RestrictiveFlagMASK; // clear bits	177	this.bits &= ~ASTNode.RestrictiveFlagMASK; // clear bits
203	this.bits \|= Binding.FIELD;	178	this.bits \|= Binding.FIELD;
204	MethodScope methodScope = scope.methodScope();	179	MethodScope methodScope = scope.methodScope();
205	boolean isStatic = fieldBinding.isStatic();	180	if (fieldBinding.isStatic()) {
206	if (!isStatic) {	181	// check if accessing enum static field in initializer
		182	ReferenceBinding declaringClass = fieldBinding.declaringClass;
		183	if (declaringClass.isEnum()) {
		184	SourceTypeBinding sourceType = scope.enclosingSourceType();
		185	if (this.constant == Constant.NotAConstant
		186	&& !methodScope.isStatic
		187	&& (sourceType == declaringClass \|\| sourceType.superclass == declaringClass) // enum constant body
		188	&& methodScope.isInsideInitializerOrConstructor()) {
		189	scope.problemReporter().enumStaticFieldUsedDuringInitialization(fieldBinding, this);
		190	}
		191	}
		192	} else {
		193	if (scope.compilerOptions().getSeverity(CompilerOptions.UnqualifiedFieldAccess) != ProblemSeverities.Ignore) {
		194	scope.problemReporter().unqualifiedFieldAccess(this, fieldBinding);
		195	}
207	// must check for the static status....	196	// must check for the static status....
208	if (methodScope.isStatic) {	197	if (methodScope.isStatic) {
209	scope.problemReporter().staticFieldAccessToNonStaticVariable(this, fieldBinding);	198	scope.problemReporter().staticFieldAccessToNonStaticVariable(this, fieldBinding);
210	this.constant = Constant.NotAConstant;
211	return fieldBinding.type;	199	return fieldBinding.type;
212	}	200	}
213	}	201	}
214	this.constant = fieldBinding.constant();
215		202
216	if (isFieldUseDeprecated(fieldBinding, scope, (this.bits & ASTNode.IsStrictlyAssigned) !=0))	203	if (isFieldUseDeprecated(fieldBinding, scope, (this.bits & ASTNode.IsStrictlyAssigned) !=0))
217	scope.problemReporter().deprecatedField(fieldBinding, this);	204	scope.problemReporter().deprecatedField(fieldBinding, this);
Lines 858-867 Link Here
858	this.constant = (this.bits & ASTNode.IsStrictlyAssigned) == 0 ? variable.constant() : Constant.NotAConstant;	845	this.constant = (this.bits & ASTNode.IsStrictlyAssigned) == 0 ? variable.constant() : Constant.NotAConstant;
859	} else {	846	} else {
860	// a field	847	// a field
861	FieldBinding field = (FieldBinding) this.binding;
862	if (!field.isStatic() && scope.compilerOptions().getSeverity(CompilerOptions.UnqualifiedFieldAccess) != ProblemSeverities.Ignore) {
863	scope.problemReporter().unqualifiedFieldAccess(this, field);
864	}
865	variableType = checkFieldAccess(scope);	848	variableType = checkFieldAccess(scope);
866	}	849	}
867	// perform capture conversion if read access	850	// perform capture conversion if read access

Lines 70-90 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedNameReference.java (-36 / +27 lines)
70	if (needValue \|\| complyTo14) {	70	if (needValue \|\| complyTo14) {
71	manageSyntheticAccessIfNecessary(currentScope, lastFieldBinding, this.actualReceiverType, 0, flowInfo);	71	manageSyntheticAccessIfNecessary(currentScope, lastFieldBinding, this.actualReceiverType, 0, flowInfo);
72	}	72	}
73	if (this.indexOfFirstFieldBinding == 1) { // was an implicit reference to the first field binding
74	ReferenceBinding declaringClass = lastFieldBinding.declaringClass;
75	// check if accessing enum static field in initializer
76	if (declaringClass.isEnum()) {
77	MethodScope methodScope = currentScope.methodScope();
78	SourceTypeBinding sourceType = methodScope.enclosingSourceType();
79	if (lastFieldBinding.isStatic()
80	&& (sourceType == declaringClass \|\| sourceType.superclass == declaringClass) // enum constant body
81	&& lastFieldBinding.constant() == Constant.NotAConstant
82	&& !methodScope.isStatic
83	&& methodScope.isInsideInitializerOrConstructor()) {
84	currentScope.problemReporter().enumStaticFieldUsedDuringInitialization(lastFieldBinding, this);
85	}
86	}
87	}
88	// check if final blank field	73	// check if final blank field
89	if (lastFieldBinding.isBlankFinal()	74	if (lastFieldBinding.isBlankFinal()
90	&& this.otherBindings != null // the last field binding is only assigned	75	&& this.otherBindings != null // the last field binding is only assigned
Lines 225-243 Link Here
225	}	210	}
226	if (this.indexOfFirstFieldBinding == 1) { // was an implicit reference to the first field binding	211	if (this.indexOfFirstFieldBinding == 1) { // was an implicit reference to the first field binding
227	FieldBinding fieldBinding = (FieldBinding) this.binding;	212	FieldBinding fieldBinding = (FieldBinding) this.binding;
228	ReferenceBinding declaringClass = fieldBinding.declaringClass;
229	// check if accessing enum static field in initializer
230	if (declaringClass.isEnum()) {
231	MethodScope methodScope = currentScope.methodScope();
232	SourceTypeBinding sourceType = methodScope.enclosingSourceType();
233	if (fieldBinding.isStatic()
234	&& (sourceType == declaringClass \|\| sourceType.superclass == declaringClass) // enum constant body
235	&& fieldBinding.constant() == Constant.NotAConstant
236	&& !methodScope.isStatic
237	&& methodScope.isInsideInitializerOrConstructor()) {
238	currentScope.problemReporter().enumStaticFieldUsedDuringInitialization(fieldBinding, this);
239	}
240	}
241	// check if reading a final blank field	213	// check if reading a final blank field
242	if (fieldBinding.isBlankFinal()	214	if (fieldBinding.isBlankFinal()
243	&& currentScope.needBlankFinalFieldInitializationCheck(fieldBinding)	215	&& currentScope.needBlankFinalFieldInitializationCheck(fieldBinding)
Lines 739-751 Link Here
739	scope.problemReporter().staticFieldAccessToNonStaticVariable(this, field);	711	scope.problemReporter().staticFieldAccessToNonStaticVariable(this, field);
740	return null;	712	return null;
741	}	713	}
742	} else {	714	} else if (this.indexOfFirstFieldBinding > 1
743	// indirect static reference ?
744	if (this.indexOfFirstFieldBinding > 1
745	&& field.declaringClass != this.actualReceiverType	715	&& field.declaringClass != this.actualReceiverType
746	&& field.declaringClass.canBeSeenBy(scope)) {	716	&& field.declaringClass.canBeSeenBy(scope)) {
747	scope.problemReporter().indirectAccessToStaticField(this, field);	717	scope.problemReporter().indirectAccessToStaticField(this, field);
748	}
749	}	718	}
750	// only last field is actually a write access if any	719	// only last field is actually a write access if any
751	if (isFieldUseDeprecated(field, scope, (this.bits & ASTNode.IsStrictlyAssigned) != 0 && this.indexOfFirstFieldBinding == length))	720	if (isFieldUseDeprecated(field, scope, (this.bits & ASTNode.IsStrictlyAssigned) != 0 && this.indexOfFirstFieldBinding == length))
Lines 808-813 Link Here
808	}	777	}
809		778
810	if (field.isStatic()) {	779	if (field.isStatic()) {
		780	// check if accessing enum static field in initializer
		781	ReferenceBinding declaringClass = field.declaringClass;
		782	if (declaringClass.isEnum()) {
		783	MethodScope methodScope = scope.methodScope();
		784	SourceTypeBinding sourceType = methodScope.enclosingSourceType();
		785	if ((sourceType == declaringClass \|\| sourceType.superclass == declaringClass) // enum constant body
		786	&& field.constant() == Constant.NotAConstant
		787	&& !methodScope.isStatic
		788	&& methodScope.isInsideInitializerOrConstructor()) {
		789	scope.problemReporter().enumStaticFieldUsedDuringInitialization(field, this);
		790	}
		791	}
811	// static field accessed through receiver? legal but unoptimal (optional warning)	792	// static field accessed through receiver? legal but unoptimal (optional warning)
812	scope.problemReporter().nonStaticAccessToStaticField(this, field, index);	793	scope.problemReporter().nonStaticAccessToStaticField(this, field, index);
813	// indirect static reference ?	794	// indirect static reference ?
Lines 1029-1037 Link Here
1029	&& (!fieldBinding.isStatic() \|\| methodScope.isStatic)) {	1010	&& (!fieldBinding.isStatic() \|\| methodScope.isStatic)) {
1030	scope.problemReporter().forwardReference(this, 0, methodScope.enclosingSourceType());	1011	scope.problemReporter().forwardReference(this, 0, methodScope.enclosingSourceType());
1031	}	1012	}
1032	if (!fieldBinding.isStatic()	1013	if (fieldBinding.isStatic()) {
1033	&& this.indexOfFirstFieldBinding == 1	1014	ReferenceBinding declaringClass = fieldBinding.declaringClass;
1034	&& scope.compilerOptions().getSeverity(CompilerOptions.UnqualifiedFieldAccess) != ProblemSeverities.Ignore) {	1015	// check if accessing enum static field in initializer
		1016	if (declaringClass.isEnum()) {
		1017	SourceTypeBinding sourceType = methodScope.enclosingSourceType();
		1018	if ((sourceType == declaringClass \|\| sourceType.superclass == declaringClass) // enum constant body
		1019	&& fieldBinding.constant() == Constant.NotAConstant
		1020	&& !methodScope.isStatic
		1021	&& methodScope.isInsideInitializerOrConstructor()) {
		1022	scope.problemReporter().enumStaticFieldUsedDuringInitialization(fieldBinding, this);
		1023	}
		1024	}
		1025	} else if (this.indexOfFirstFieldBinding == 1 && scope.compilerOptions().getSeverity(CompilerOptions.UnqualifiedFieldAccess) != ProblemSeverities.Ignore) {
1035	scope.problemReporter().unqualifiedFieldAccess(this, fieldBinding);	1026	scope.problemReporter().unqualifiedFieldAccess(this, fieldBinding);
1036	}	1027	}
1037	this.bits &= ~ASTNode.RestrictiveFlagMASK; // clear bits	1028	this.bits &= ~ASTNode.RestrictiveFlagMASK; // clear bits

Lines 3860-3879 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/EnumTest.java (-27 / +348 lines)
3860	" ^^^^^\n" +	3860	" ^^^^^\n" +
3861	"Cannot refer to the static enum field X.VALUE within an initializer\n" +	3861	"Cannot refer to the static enum field X.VALUE within an initializer\n" +
3862	"----------\n" +	3862	"----------\n" +
3863	"2. ERROR in X.java (at line 8)\n" +	3863	"2. ERROR in X.java (at line 9)\n" +
3864	" VALUE = null;\n" +
3865	" ^^^^^\n" +
3866	"The final field X.VALUE cannot be assigned\n" +
3867	"----------\n" +
3868	"3. ERROR in X.java (at line 9)\n" +
3869	" ASD = 5;\n" +	3864	" ASD = 5;\n" +
3870	" ^^^\n" +	3865	" ^^^\n" +
3871	"Cannot refer to the static enum field X.ASD within an initializer\n" +	3866	"Cannot refer to the static enum field X.ASD within an initializer\n" +
3872	"----------\n" +	3867	"----------\n" +
3873	"4. ERROR in X.java (at line 10)\n" +	3868	"3. ERROR in X.java (at line 10)\n" +
3874	" X.VALUE = null;\n" +	3869	" X.VALUE = null;\n" +
3875	" ^^^^^\n" +	3870	" ^^^^^\n" +
3876	"The final field X.VALUE cannot be assigned\n" +	3871	"Cannot refer to the static enum field X.VALUE within an initializer\n" +
		3872	"----------\n" +
		3873	"4. ERROR in X.java (at line 11)\n" +
		3874	" X.ASD = 5;\n" +
		3875	" ^^^\n" +
		3876	"Cannot refer to the static enum field X.ASD within an initializer\n" +
3877	"----------\n");	3877	"----------\n");
3878	}	3878	}
3879	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=101713 - variation	3879	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=101713 - variation
Lines 3895-3905 Link Here
3895	" BLEU = null;\n" +	3895	" BLEU = null;\n" +
3896	" ^^^^\n" +	3896	" ^^^^\n" +
3897	"Cannot refer to the static enum field X.BLEU within an initializer\n" +	3897	"Cannot refer to the static enum field X.BLEU within an initializer\n" +
3898	"----------\n" +
3899	"2. ERROR in X.java (at line 6)\n" +
3900	" BLEU = null;\n" +
3901	" ^^^^\n" +
3902	"The final field X.BLEU cannot be assigned\n" +
3903	"----------\n");	3898	"----------\n");
3904	}	3899	}
3905	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=101713 - variation	3900	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=101713 - variation
Lines 3933-3969 Link Here
3933	" ^^^^\n" +	3928	" ^^^^\n" +
3934	"Cannot refer to the static enum field X.BLEU within an initializer\n" +	3929	"Cannot refer to the static enum field X.BLEU within an initializer\n" +
3935	"----------\n" +	3930	"----------\n" +
3936	"2. WARNING in X.java (at line 6)\n" +	3931	"2. ERROR in X.java (at line 6)\n" +
		3932	" X x = BLEU.BLANC; // ko\n" +
		3933	" ^^^^^\n" +
		3934	"Cannot refer to the static enum field X.BLANC within an initializer\n" +
		3935	"----------\n" +
		3936	"3. WARNING in X.java (at line 6)\n" +
3937	" X x = BLEU.BLANC; // ko\n" +	3937	" X x = BLEU.BLANC; // ko\n" +
3938	" ^^^^^\n" +	3938	" ^^^^^\n" +
3939	"The static field X.BLANC should be accessed in a static way\n" +	3939	"The static field X.BLANC should be accessed in a static way\n" +
3940	"----------\n" +	3940	"----------\n" +
3941	"3. ERROR in X.java (at line 7)\n" +	3941	"4. ERROR in X.java (at line 7)\n" +
3942	" X x2 = BLEU; // ko\n" +	3942	" X x2 = BLEU; // ko\n" +
3943	" ^^^^\n" +	3943	" ^^^^\n" +
3944	"Cannot refer to the static enum field X.BLEU within an initializer\n" +	3944	"Cannot refer to the static enum field X.BLEU within an initializer\n" +
3945	"----------\n" +	3945	"----------\n" +
3946	"4. WARNING in X.java (at line 10)\n" +	3946	"5. WARNING in X.java (at line 10)\n" +
3947	" X x = BLEU.BLANC; // ok\n" +	3947	" X x = BLEU.BLANC; // ok\n" +
3948	" ^^^^^\n" +	3948	" ^^^^^\n" +
3949	"The static field X.BLANC should be accessed in a static way\n" +	3949	"The static field X.BLANC should be accessed in a static way\n" +
3950	"----------\n" +	3950	"----------\n" +
3951	"5. ERROR in X.java (at line 13)\n" +	3951	"6. ERROR in X.java (at line 13)\n" +
3952	" X dummy = BLEU; // ko\n" +	3952	" X dummy = BLEU; // ko\n" +
3953	" ^^^^\n" +	3953	" ^^^^\n" +
3954	"Cannot refer to the static enum field X.BLEU within an initializer\n" +	3954	"Cannot refer to the static enum field X.BLEU within an initializer\n" +
3955	"----------\n" +	3955	"----------\n" +
3956	"6. ERROR in X.java (at line 16)\n" +	3956	"7. ERROR in X.java (at line 16)\n" +
3957	" X x = BLEU.BLANC; // ko\n" +	3957	" X x = BLEU.BLANC; // ko\n" +
3958	" ^^^^\n" +	3958	" ^^^^\n" +
3959	"Cannot refer to the static enum field X.BLEU within an initializer\n" +	3959	"Cannot refer to the static enum field X.BLEU within an initializer\n" +
3960	"----------\n" +	3960	"----------\n" +
3961	"7. WARNING in X.java (at line 16)\n" +	3961	"8. ERROR in X.java (at line 16)\n" +
		3962	" X x = BLEU.BLANC; // ko\n" +
		3963	" ^^^^^\n" +
		3964	"Cannot refer to the static enum field X.BLANC within an initializer\n" +
		3965	"----------\n" +
		3966	"9. WARNING in X.java (at line 16)\n" +
3962	" X x = BLEU.BLANC; // ko\n" +	3967	" X x = BLEU.BLANC; // ko\n" +
3963	" ^^^^^\n" +	3968	" ^^^^^\n" +
3964	"The static field X.BLANC should be accessed in a static way\n" +	3969	"The static field X.BLANC should be accessed in a static way\n" +
3965	"----------\n" +	3970	"----------\n" +
3966	"8. ERROR in X.java (at line 17)\n" +	3971	"10. ERROR in X.java (at line 17)\n" +
3967	" X x2 = BLEU; // ko\n" +	3972	" X x2 = BLEU; // ko\n" +
3968	" ^^^^\n" +	3973	" ^^^^\n" +
3969	"Cannot refer to the static enum field X.BLEU within an initializer\n" +	3974	"Cannot refer to the static enum field X.BLEU within an initializer\n" +
Lines 4063-4069 Link Here
4063	" ^\n" +	4068	" ^\n" +
4064	"Cannot refer to the static enum field X.B within an initializer\n" +	4069	"Cannot refer to the static enum field X.B within an initializer\n" +
4065	"----------\n" +	4070	"----------\n" +
4066	"3. WARNING in X.java (at line 5)\n" +	4071	"3. ERROR in X.java (at line 5)\n" +
		4072	" final X a2 = B.A;\n" +
		4073	" ^\n" +
		4074	"Cannot refer to the static enum field X.A within an initializer\n" +
		4075	"----------\n" +
		4076	"4. WARNING in X.java (at line 5)\n" +
4067	" final X a2 = B.A;\n" +	4077	" final X a2 = B.A;\n" +
4068	" ^\n" +	4078	" ^\n" +
4069	"The static field X.A should be accessed in a static way\n" +	4079	"The static field X.A should be accessed in a static way\n" +
Lines 4087-4098 Link Here
4087	"}\n",	4097	"}\n",
4088	},	4098	},
4089	"----------\n" +	4099	"----------\n" +
4090	"1. WARNING in X.java (at line 5)\n" +	4100	"1. ERROR in X.java (at line 8)\n" +
4091	" private static String error;\n" +
4092	" ^^^^^\n" +
4093	"The field X.error is never read locally\n" +
4094	"----------\n" +
4095	"2. ERROR in X.java (at line 8)\n" +
4096	" error = \"error\";\n" +	4101	" error = \"error\";\n" +
4097	" ^^^^^\n" +	4102	" ^^^^^\n" +
4098	"Cannot refer to the static enum field X.error within an initializer\n" +	4103	"Cannot refer to the static enum field X.error within an initializer\n" +
Lines 5262-5265 Link Here
5262	false,	5267	false,
5263	null);	5268	null);
5264	}	5269	}
		5270	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=228109
		5271	public void test153() {
		5272	this.runNegativeTest(
		5273	new String[] {
		5274	"TestEnum.java",
		5275	"public enum TestEnum {\n" +
		5276	" RED, GREEN, BLUE; \n" +
		5277	" static int test = 0; \n" +
		5278	"\n" +
		5279	" TestEnum() {\n" +
		5280	" TestEnum.test=10;\n" +
		5281	" }\n" +
		5282	"}\n"
		5283	},
		5284	"----------\n" +
		5285	"1. ERROR in TestEnum.java (at line 6)\n" +
		5286	" TestEnum.test=10;\n" +
		5287	" ^^^^\n" +
		5288	"Cannot refer to the static enum field TestEnum.test within an initializer\n" +
		5289	"----------\n");
		5290	}
		5291	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=228109 - variation
		5292	public void test154() {
		5293	this.runNegativeTest(
		5294	new String[] {
		5295	"TestEnum2.java",
		5296	"public enum TestEnum2 {\n" +
		5297	" ; \n" +
		5298	" static int test = 0; \n" +
		5299	" TestEnum2() {\n" +
		5300	" TestEnum2.test=11;\n" +
		5301	" }\n" +
		5302	"}\n" +
		5303	"class X {\n" +
		5304	" static int test = 0;\n" +
		5305	" X() {\n" +
		5306	" X.test = 13;\n" +
		5307	" }\n" +
		5308	"}\n"
		5309	},
		5310	"----------\n" +
		5311	"1. ERROR in TestEnum2.java (at line 5)\n" +
		5312	" TestEnum2.test=11;\n" +
		5313	" ^^^^\n" +
		5314	"Cannot refer to the static enum field TestEnum2.test within an initializer\n" +
		5315	"----------\n");
		5316	}
		5317	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=228109 - variation
		5318	public void test155() {
		5319	this.runConformTest(
		5320	new String[] {
		5321	"TestEnum.java",
		5322	"public enum TestEnum {\n" +
		5323	" RED, GREEN, BLUE; \n" +
		5324	" static int test = 0; \n" +
		5325	"}\n" +
		5326	"\n" +
		5327	"enum TestEnum2 {\n" +
		5328	" ; \n" +
		5329	" TestEnum2() {\n" +
		5330	" TestEnum.test=12;\n" +
		5331	" }\n" +
		5332	"}\n"
		5333	},
5334	"");
5335	}
5336	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=228109 - variation
5337	public void test156() {
5338	this.runConformTest(
5339	new String[] {
5340	"TestEnum.java",
5341	"public enum TestEnum {\n" +
5342	" RED, GREEN, BLUE; \n" +
5343	" static int test = 0; \n" +
5344	"\n" +
5345	" TestEnum() {\n" +
5346	" new Object() {\n" +
5347	" { TestEnum.test=10; }\n" +
5348	" };\n" +
5349	" }\n" +
5350	"}\n"
5351	},
5352	"");
5353	}
5354	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=228109 - variation
5355	public void test157() {
5356	this.runNegativeTest(
5357	new String[] {
5358	"Foo.java",
5359	"enum Foo {\n" +
5360	" ONE, TWO, THREE;\n" +
5361	" static int val = 10;\n" +
5362	" Foo () {\n" +
5363	" this(Foo.val);\n" +
5364	" System.out.println(Foo.val);\n" +
5365	" }\n" +
5366	" Foo(int i){}\n" +
5367	" {\n" +
5368	" System.out.println(Foo.val);\n" +
5369	" }\n" +
5370	" int field = Foo.val;\n" +
5371	"}\n"
5372	},
5373	"----------\n" +
5374	"1. ERROR in Foo.java (at line 5)\n" +
5375	" this(Foo.val);\n" +
5376	" ^^^\n" +
5377	"Cannot refer to the static enum field Foo.val within an initializer\n" +
5378	"----------\n" +
5379	"2. ERROR in Foo.java (at line 6)\n" +
5380	" System.out.println(Foo.val);\n" +
5381	" ^^^\n" +
5382	"Cannot refer to the static enum field Foo.val within an initializer\n" +
5383	"----------\n" +
5384	"3. ERROR in Foo.java (at line 10)\n" +
5385	" System.out.println(Foo.val);\n" +
5386	" ^^^\n" +
5387	"Cannot refer to the static enum field Foo.val within an initializer\n" +
5388	"----------\n" +
5389	"4. ERROR in Foo.java (at line 12)\n" +
5390	" int field = Foo.val;\n" +
5391	" ^^^\n" +
5392	"Cannot refer to the static enum field Foo.val within an initializer\n" +
5393	"----------\n");
5394	}
5395	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=228109 - variation
5396	public void test158() {
5397	this.runNegativeTest(
5398	new String[] {
5399	"Foo.java",
5400	"enum Foo {\n" +
5401	" ONE, TWO, THREE;\n" +
5402	" static int val = 10;\n" +
5403	" Foo () {\n" +
5404	" this(val);\n" +
5405	" System.out.println(val);\n" +
5406	" }\n" +
5407	" Foo(int i){}\n" +
5408	" {\n" +
5409	" System.out.println(val);\n" +
5410	" }\n" +
5411	" int field = val;\n" +
5412	"}\n"
5413	},
5414	"----------\n" +
5415	"1. ERROR in Foo.java (at line 5)\n" +
5416	" this(val);\n" +
5417	" ^^^\n" +
5418	"Cannot refer to the static enum field Foo.val within an initializer\n" +
5419	"----------\n" +
5420	"2. ERROR in Foo.java (at line 6)\n" +
5421	" System.out.println(val);\n" +
5422	" ^^^\n" +
5423	"Cannot refer to the static enum field Foo.val within an initializer\n" +
5424	"----------\n" +
5425	"3. ERROR in Foo.java (at line 10)\n" +
5426	" System.out.println(val);\n" +
5427	" ^^^\n" +
5428	"Cannot refer to the static enum field Foo.val within an initializer\n" +
5429	"----------\n" +
5430	"4. ERROR in Foo.java (at line 12)\n" +
5431	" int field = val;\n" +
5432	" ^^^\n" +
5433	"Cannot refer to the static enum field Foo.val within an initializer\n" +
5434	"----------\n");
5435	}
5436	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=228109 - variation
5437	public void test159() {
5438	this.runNegativeTest(
5439	new String[] {
5440	"Foo.java",
5441	"enum Foo {\n" +
5442	" ONE, TWO, THREE;\n" +
5443	" static int val = 10;\n" +
5444	" Foo () {\n" +
5445	" this(get().val);\n" +
5446	" System.out.println(get().val);\n" +
5447	" }\n" +
5448	" Foo(int i){}\n" +
5449	" {\n" +
5450	" System.out.println(get().val);\n" +
5451	" }\n" +
5452	" int field = get().val;\n" +
5453	" Foo get() { return ONE; }\n" +
5454	"}\n"
5455	},
5456	"----------\n" +
5457	"1. ERROR in Foo.java (at line 5)\n" +
5458	" this(get().val);\n" +
5459	" ^^^\n" +
5460	"Cannot refer to an instance method while explicitly invoking a constructor\n" +
5461	"----------\n" +
5462	"2. WARNING in Foo.java (at line 5)\n" +
5463	" this(get().val);\n" +
5464	" ^^^\n" +
5465	"The static field Foo.val should be accessed in a static way\n" +
5466	"----------\n" +
5467	"3. ERROR in Foo.java (at line 5)\n" +
5468	" this(get().val);\n" +
5469	" ^^^\n" +
5470	"Cannot refer to the static enum field Foo.val within an initializer\n" +
5471	"----------\n" +
5472	"4. WARNING in Foo.java (at line 6)\n" +
5473	" System.out.println(get().val);\n" +
5474	" ^^^\n" +
5475	"The static field Foo.val should be accessed in a static way\n" +
5476	"----------\n" +
5477	"5. ERROR in Foo.java (at line 6)\n" +
5478	" System.out.println(get().val);\n" +
5479	" ^^^\n" +
5480	"Cannot refer to the static enum field Foo.val within an initializer\n" +
5481	"----------\n" +
5482	"6. WARNING in Foo.java (at line 10)\n" +
5483	" System.out.println(get().val);\n" +
5484	" ^^^\n" +
5485	"The static field Foo.val should be accessed in a static way\n" +
5486	"----------\n" +
5487	"7. ERROR in Foo.java (at line 10)\n" +
5488	" System.out.println(get().val);\n" +
5489	" ^^^\n" +
5490	"Cannot refer to the static enum field Foo.val within an initializer\n" +
5491	"----------\n" +
5492	"8. WARNING in Foo.java (at line 12)\n" +
5493	" int field = get().val;\n" +
5494	" ^^^\n" +
5495	"The static field Foo.val should be accessed in a static way\n" +
5496	"----------\n" +
5497	"9. ERROR in Foo.java (at line 12)\n" +
5498	" int field = get().val;\n" +
5499	" ^^^\n" +
5500	"Cannot refer to the static enum field Foo.val within an initializer\n" +
5501	"----------\n");
5502	}
5503	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=228109 - variation
5504	public void test160() {
5505	this.runNegativeTest(
5506	new String[] {
5507	"Foo.java",
5508	"enum Foo {\n" +
5509	" ONE, TWO, THREE;\n" +
5510	" static int val = 10;\n" +
5511	" Foo () {\n" +
5512	" this(get().val = 1);\n" +
5513	" System.out.println(get().val = 2);\n" +
5514	" }\n" +
5515	" Foo(int i){}\n" +
5516	" {\n" +
5517	" System.out.println(get().val = 3);\n" +
5518	" }\n" +
5519	" int field = get().val = 4;\n" +
5520	" Foo get() { return ONE; }\n" +
5521	"}\n"
5522	},
5523	"----------\n" +
5524	"1. ERROR in Foo.java (at line 5)\n" +
5525	" this(get().val = 1);\n" +
5526	" ^^^\n" +
5527	"Cannot refer to an instance method while explicitly invoking a constructor\n" +
5528	"----------\n" +
5529	"2. WARNING in Foo.java (at line 5)\n" +
5530	" this(get().val = 1);\n" +
5531	" ^^^\n" +
5532	"The static field Foo.val should be accessed in a static way\n" +
5533	"----------\n" +
5534	"3. ERROR in Foo.java (at line 5)\n" +
5535	" this(get().val = 1);\n" +
5536	" ^^^\n" +
5537	"Cannot refer to the static enum field Foo.val within an initializer\n" +
5538	"----------\n" +
5539	"4. WARNING in Foo.java (at line 6)\n" +
5540	" System.out.println(get().val = 2);\n" +
5541	" ^^^\n" +
5542	"The static field Foo.val should be accessed in a static way\n" +
5543	"----------\n" +
5544	"5. ERROR in Foo.java (at line 6)\n" +
5545	" System.out.println(get().val = 2);\n" +
5546	" ^^^\n" +
5547	"Cannot refer to the static enum field Foo.val within an initializer\n" +
5548	"----------\n" +
5549	"6. WARNING in Foo.java (at line 10)\n" +
5550	" System.out.println(get().val = 3);\n" +
5551	" ^^^\n" +
5552	"The static field Foo.val should be accessed in a static way\n" +
5553	"----------\n" +
5554	"7. ERROR in Foo.java (at line 10)\n" +
5555	" System.out.println(get().val = 3);\n" +
5556	" ^^^\n" +
5557	"Cannot refer to the static enum field Foo.val within an initializer\n" +
5558	"----------\n" +
5559	"8. WARNING in Foo.java (at line 12)\n" +
5560	" int field = get().val = 4;\n" +
5561	" ^^^\n" +
5562	"The static field Foo.val should be accessed in a static way\n" +
5563	"----------\n" +
5564	"9. ERROR in Foo.java (at line 12)\n" +
5565	" int field = get().val = 4;\n" +
5566	" ^^^\n" +
5567	"Cannot refer to the static enum field Foo.val within an initializer\n" +
5568	"----------\n");
5569	}
5570	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=228109 - variation
5571	public void test161() {
5572	this.runConformTest(
5573	new String[] {
5574	"EnumTest1.java",
5575	"enum EnumTest1 {\n" +
5576	" ;\n" +
5577	" static int foo = EnumTest2.bar;\n" +
5578	"}\n" +
5579	"enum EnumTest2 {\n" +
5580	" ;\n" +
5581	" static int bar = EnumTest1.foo;\n" +
5582	"}\n"
5583	},
5584	"");
5585	}
5265	}	5586	}