Attachment #215387 for bug #376550

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




/*******************************************************************************
 * Copyright (c) 2000, 2012 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

		// javac options
		JavacTestOptions.SKIP_UNTIL_FRAMEWORK_FIX /* javac test options */);
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=376550
// SingleNameReference, assignment of instance field inside a local class method
public void test376550_1a() {
	if (this.complianceLevel < ClassFileConstants.JDK1_5)
		return;
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBeStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportUnusedPrivateMember, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
				"X.java", 
				"public class X {\n" +
				"	int i = 1;\n" +
				"   public void upper1(){}\n" +
				"   public void foo(){\n" + // can't be static
				"   	class Local{\n" +
				"			int i2 = 1;\n" +
				"			void method1() {\n" + // can't be static
				"				i = 1;\n" +
				"			}\n" +
				"		}\n" +
				"	}\n" +
				"}"
		},
		"",
		null /* no extra class libraries */,
		true /* flush output directory */,
		compilerOptions /* custom options */
	);
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=376550
// SingleNameReference, assignment of instance field of local class inside a local class method
public void test376550_1b() {
	if (this.complianceLevel < ClassFileConstants.JDK1_5)
		return;
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBeStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportUnusedPrivateMember, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
				"X.java", 
				"public class X {\n" +
				"	int i = 1;\n" +
				"   public void upper1(){}\n" +
				"   public void foo(){\n" + // can be static
				"   	class Local{\n" +
				"			int i2 = 1;\n" +
				"			void method2() {\n" +  // can't be static
				"				i2 = 1;\n" +
				"			}\n" +
				"		}\n" +
				"	}\n" +
				"}"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	public void foo(){\n" + 
		"	            ^^^^^\n" + 
		"The method foo() from the type X can potentially be declared as static\n" + 
		"----------\n",
		null /* no extra class libraries */,
		true /* flush output directory */,
		compilerOptions /* custom options */
	);
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=376550
// LocalDeclaration with type as a type variable binding
public void test376550_2a() {
	if (this.complianceLevel < ClassFileConstants.JDK1_5)
		return;
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBeStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportUnusedPrivateMember, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
				"X.java", 
				"public class X<T> {\n" +
				"   public void upper1(){}\n" +
				"   public void foo(){\n" + // can be static
				"   	class Local<K>{\n" +
				"			void method2() {\n" +  // can't be static
				"				K k;\n" +
				"			}\n" +
				"		}\n" +
				"	}\n" +
				"}"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 3)\n" + 
		"	public void foo(){\n" + 
		"	            ^^^^^\n" + 
		"The method foo() from the type X<T> can potentially be declared as static\n" + 
		"----------\n",
		null /* no extra class libraries */,
		true /* flush output directory */,
		compilerOptions /* custom options */
	);
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=376550
// LocalDeclaration with type as a type variable binding
public void test376550_2b() {
	if (this.complianceLevel < ClassFileConstants.JDK1_5)
		return;
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBeStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportUnusedPrivateMember, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
				"X.java", 
				"public class X<T> {\n" +
				"   public void upper1(){}\n" +
				"   public void foo(){\n" + // can't be static
				"   	class Local<K>{\n" +
				"			void method2() {\n" +  // can't be static
				"				T t;\n" +
				"			}\n" +
				"		}\n" +
				"	}\n" +
				"}"
		},
		"",
		null /* no extra class libraries */,
		true /* flush output directory */,
		compilerOptions /* custom options */
	);
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=376550
// MessageSend, calling outer class method inside a local class method
public void test376550_3a() {
	if (this.complianceLevel < ClassFileConstants.JDK1_5)
		return;
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBeStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportUnusedPrivateMember, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
				"X.java", 
				"public class X<T> {\n" +
				"   public void upper1(){}\n" +
				"   public void foo(){\n" + // can't be static
				"   	class Local<K>{\n" +
				"			void lower() {}\n" +
				"			void method2() {\n" +  // can't be static
				"				upper1();\n" +
				"			}\n" +
				"		}\n" +
				"	}\n" +
				"}"
		},
		"",
		null /* no extra class libraries */,
		true /* flush output directory */,
		compilerOptions /* custom options */
	);
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=376550
// MessageSend, calling local class method inside a local class method
public void test376550_3b() {
	if (this.complianceLevel < ClassFileConstants.JDK1_5)
		return;
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBeStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportUnusedPrivateMember, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
				"X.java", 
				"public class X<T> {\n" +
				"   public void upper1(){}\n" +
				"   public void foo(){\n" + // can be static
				"   	class Local<K>{\n" +
				"			void lower() {}\n" +
				"			void method2() {\n" +  // can't be static
				"				lower();\n" +
				"			}\n" +
				"		}\n" +
				"	}\n" +
				"}"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 3)\n" + 
		"	public void foo(){\n" + 
		"	            ^^^^^\n" + 
		"The method foo() from the type X<T> can potentially be declared as static\n" + 
		"----------\n",
		null /* no extra class libraries */,
		true /* flush output directory */,
		compilerOptions /* custom options */
	);
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=376550
// Local class instance field is an argument in messageSend in local class method
public void test376550_4a() {
	if (this.complianceLevel < ClassFileConstants.JDK1_5)
		return;
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBeStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportUnusedPrivateMember, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
				"X.java", 
				"public class X<T> {\n" +
				"   int i1 = 1;\n" +
				"   public void foo(){\n" + // can be static
				"   	class Local<K>{\n" +
				"			int i2 = 1;\n" +
				"			void lower(int i) {}\n" +
				"			void method2() {\n" +  // can't be static
				"				lower(i2);\n" +
				"			}\n" +
				"		}\n" +
				"	}\n" +
				"}"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 3)\n" + 
		"	public void foo(){\n" + 
		"	            ^^^^^\n" + 
		"The method foo() from the type X<T> can potentially be declared as static\n" + 
		"----------\n",
		null /* no extra class libraries */,
		true /* flush output directory */,
		compilerOptions /* custom options */
	);
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=376550
// Outerclass instance field is an argument in messageSend in local class method
public void test376550_4b() {
	if (this.complianceLevel < ClassFileConstants.JDK1_5)
		return;
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBeStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportUnusedPrivateMember, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
				"X.java", 
				"public class X<T> {\n" +
				"   int i1 = 1;\n" +
				"   public void foo(){\n" + // can't be static
				"   	class Local<K>{\n" +
				"			int i2 = 1;\n" +
				"			void lower(int i) {}\n" +
				"			void method2() {\n" +  // can't be static
				"				lower(i1);\n" +
				"			}\n" +
				"		}\n" +
				"	}\n" +
				"}"
		},
		"",
		null /* no extra class libraries */,
		true /* flush output directory */,
		compilerOptions /* custom options */
	);
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=376550
// QualifiedNameReference, accessing local class instance field
public void test376550_5a() {
	if (this.complianceLevel < ClassFileConstants.JDK1_5)
		return;
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBeStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportUnusedPrivateMember, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
				"X.java", 
				"public class X {\n" +
				"   int i1 = 1;\n" +
				"   public void foo(){\n" + // can be static
				"   	class Local{\n" +
				"			int i2 = 1;\n" +
				"			void method2() {\n" +  // can't be static
				"				Local.this.i2 = 1;\n" +
				"			}\n" +
				"		}\n" +
				"	}\n" +
				"}"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 3)\n" + 
		"	public void foo(){\n" + 
		"	            ^^^^^\n" + 
		"The method foo() from the type X can potentially be declared as static\n" + 
		"----------\n",
		null /* no extra class libraries */,
		true /* flush output directory */,
		compilerOptions /* custom options */
	);
}

//https://bugs.eclipse.org/bugs/show_bug.cgi?id=376550
//QualifiedNameReference, accessing outer class instance field
public void test376550_5b() {
	if (this.complianceLevel < ClassFileConstants.JDK1_5)
		return;
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBeStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportUnusedPrivateMember, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
				"X.java", 
				"public class X {\n" +
				"   int i1 = 1;\n" +
				"   public void foo(){\n" + // can't be static
				"   	class Local{\n" +
				"			int i2 = 1;\n" +
				"			void method2() {\n" +  // can't be static
				"				X.this.i1 = 1;\n" +
				"			}\n" +
				"		}\n" +
				"	}\n" +
				"}"
		},
		"",
		null /* no extra class libraries */,
		true /* flush output directory */,
		compilerOptions /* custom options */
	);
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=376550
// QualifiedNameRef.analyseCode()
public void test376550_6a() {
	if (this.complianceLevel < ClassFileConstants.JDK1_5)
		return;
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBeStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportUnusedPrivateMember, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
				"X.java", 
				"public class X {\n" +
				"   int i1 = 1;\n" +
				"   public void foo(){\n" + // can be static
				"   	class Local{\n" +
				"			int i2 = 1;\n" +
				"			boolean method2() {\n" +  // can't be static
				"				return Local.this.i2 == 1;\n" +
				"			}\n" +
				"		}\n" +
				"	}\n" +
				"}"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 3)\n" + 
		"	public void foo(){\n" + 
		"	            ^^^^^\n" + 
		"The method foo() from the type X can potentially be declared as static\n" + 
		"----------\n",
		null /* no extra class libraries */,
		true /* flush output directory */,
		compilerOptions /* custom options */
	);
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=376550
// QualifiedNameRef.analyseCode()
public void test376550_6b() {
	if (this.complianceLevel < ClassFileConstants.JDK1_5)
		return;
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBeStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportUnusedPrivateMember, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
				"X.java", 
				"public class X {\n" +
				"   int i1 = 1;\n" +
				"   public void foo(){\n" + // can't be static
				"   	class Local{\n" +
				"			int i2 = 1;\n" +
				"			boolean method2() {\n" +  // can't be static
				"				return X.this.i1 == 1;\n" +
				"			}\n" +
				"		}\n" +
				"	}\n" +
				"}"
		},
		"",
		null /* no extra class libraries */,
		true /* flush output directory */,
		compilerOptions /* custom options */
	);
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=376550
// QualifiedAllocationExpression, allocating an anonymous type without an enclosing instance of parent type
// anon. type is declared in local class
public void test376550_7a() {
	if (this.complianceLevel < ClassFileConstants.JDK1_5)
		return;
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBeStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportUnusedPrivateMember, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
				"X.java", 
				"public class X {\n" +
				"   abstract class AbsUp{}\n" +
				"   public void foo(){\n" + // can be static
				"   	class Local{\n" +
				"			abstract class AbsLow{}\n" +
				"			void method2() {\n" +  // can't be static
				"				new AbsLow(){};\n" +
				"			}\n" +
				"		}\n" +
				"	}\n" +
				"}"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 3)\n" + 
		"	public void foo(){\n" + 
		"	            ^^^^^\n" + 
		"The method foo() from the type X can potentially be declared as static\n" + 
		"----------\n",
		null /* no extra class libraries */,
		true /* flush output directory */,
		compilerOptions /* custom options */
	);
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=376550
// QualifiedAllocationExpression, allocating an anonymous type without an enclosing instance of parent type
// anon. type is declared in outer class
public void test376550_7b() {
	if (this.complianceLevel < ClassFileConstants.JDK1_5)
		return;
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBeStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportUnusedPrivateMember, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
				"X.java", 
				"public class X {\n" +
				"   abstract class AbsUp{}\n" +
				"   public void foo(){\n" + // can't be static
				"   	class Local{\n" +
				"			abstract  class AbsLow{}\n" +
				"			void method2() {\n" +  // can't be static
				"				new AbsUp(){};\n" +
				"			}\n" +
				"		}\n" +
				"	}\n" +
				"}"
		},
		"",
		null /* no extra class libraries */,
		true /* flush output directory */,
		compilerOptions /* custom options */
	);
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=376550
// FieldRef, from object of a class in outer class
public void test376550_8a() {
	if (this.complianceLevel < ClassFileConstants.JDK1_5)
		return;
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBeStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportUnusedPrivateMember, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
				"X.java", 
				"public class X {\n" +
				"   class AbsUp{ int a;}\n" +
				"   public void foo(){\n" + // can be static
				"   	class Local{\n" +
				"			class AbsLow{  int a;}\n" +
				"			void method2() {\n" +  // can't be static
				"				int abc = new AbsLow().a;\n" +
				"			}\n" +
				"		}\n" +
				"	}\n" +
				"}"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 3)\n" + 
		"	public void foo(){\n" + 
		"	            ^^^^^\n" + 
		"The method foo() from the type X can potentially be declared as static\n" + 
		"----------\n",
		null /* no extra class libraries */,
		true /* flush output directory */,
		compilerOptions /* custom options */
	);
}

//https://bugs.eclipse.org/bugs/show_bug.cgi?id=376550
//FieldRef, from object of a class in local class
public void test376550_8b() {
	if (this.complianceLevel < ClassFileConstants.JDK1_5)
		return;
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBeStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportUnusedPrivateMember, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
				"X.java", 
				"public class X {\n" +
				"   class AbsUp{ int a;}\n" +
				"   public void foo(){\n" + // can't be static
				"   	class Local{\n" +
				"			class AbsLow{  int a;}\n" +
				"			void method2() {\n" +  // can't be static
				"				int abc = new AbsUp().a;\n" +
				"			}\n" +
				"		}\n" +
				"	}\n" +
				"}"
		},
		"",
		null /* no extra class libraries */,
		true /* flush output directory */,
		compilerOptions /* custom options */
	);
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=376550
// QualifiedNameRef, accessing a field from local class field
public void test376550_9a() {
	if (this.complianceLevel < ClassFileConstants.JDK1_5)
		return;
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBeStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportUnusedPrivateMember, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
				"X.java", 
				"public class X {\n" +
				"   X xup;\n" +
				"	int i = 1;\n" +
				"   public void foo(){\n" + // can be static
				"   	class Local{\n" +
				"			X xdown;\n" +
				"			class AbsLow{  int a;}\n" +
				"			void method2() {\n" +  // can't be static
				"				int abc = xdown.i;\n" +
				"			}\n" +
				"		}\n" +
				"	}\n" +
				"}"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	public void foo(){\n" + 
		"	            ^^^^^\n" + 
		"The method foo() from the type X can potentially be declared as static\n" + 
		"----------\n",
		null /* no extra class libraries */,
		true /* flush output directory */,
		compilerOptions /* custom options */
	);
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=376550
// QualifiedNameRef, accessing a field from local class field
public void test376550_9b() {
	if (this.complianceLevel < ClassFileConstants.JDK1_5)
		return;
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBeStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportUnusedPrivateMember, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
				"X.java", 
				"public class X {\n" +
				"   X xup;\n" +
				"	int i = 1;\n" +
				"   public void foo(){\n" + // can't be static
				"   	class Local{\n" +
				"			X xdown;\n" +
				"			class AbsLow{  int a;}\n" +
				"			void method2() {\n" +  // can't be static
				"				int abc = xup.i;\n" +
				"			}\n" +
				"		}\n" +
				"	}\n" +
				"}"
		},
		"",
		null /* no extra class libraries */,
		true /* flush output directory */,
		compilerOptions /* custom options */
	);
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=376550
// QualifiedNameRef, accessing a field from local class field
public void test376550_10a() {
	if (this.complianceLevel < ClassFileConstants.JDK1_5)
		return;
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBeStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportUnusedPrivateMember, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
				"X.java", 
				"public class X {\n" +
				"   X xup;\n" +
				"	int i = 1;\n" +
				"   public void foo(){\n" + // can be static
				"   	class Local{\n" +
				"			X xdown;\n" +
				"			void calc(int i1){}\n" +
				"			void method2() {\n" +  // can't be static
				"				calc(xdown.i);\n" +
				"			}\n" +
				"		}\n" +
				"	}\n" +
				"}"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	public void foo(){\n" + 
		"	            ^^^^^\n" + 
		"The method foo() from the type X can potentially be declared as static\n" + 
		"----------\n",
		null /* no extra class libraries */,
		true /* flush output directory */,
		compilerOptions /* custom options */
	);
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=376550
// QualifiedNameRef, accessing a field from local class field
public void test376550_10b() {
	if (this.complianceLevel < ClassFileConstants.JDK1_5)
		return;
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBeStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportUnusedPrivateMember, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
				"X.java", 
				"public class X {\n" +
				"   X xup;\n" +
				"	int i = 1;\n" +
				"   public void foo(){\n" + // can't be static
				"   	class Local{\n" +
				"			X xdown;\n" +
				"			void calc(int i1){}\n" +
				"			void method2() {\n" +  // can't be static
				"				calc(xup.i);\n" +
				"			}\n" +
				"		}\n" +
				"	}\n" +
				"}"
		},
		"",
		null /* no extra class libraries */,
		true /* flush output directory */,
		compilerOptions /* custom options */
	);
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=376550
// bug test case
public void test376550_11() {
	if (this.complianceLevel < ClassFileConstants.JDK1_5)
		return;
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBeStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportUnusedPrivateMember, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
				"X.java", 
				"import java.util.ArrayList;\n" +
				"import java.util.Collection;\n" +
				"public class X {\n" +
				"   private Object o = new Object();\n" +
				"   public final Collection<Object> go() {\n" + // can't be static
				"   	return new ArrayList<Object>() {\n" +
				"			{ add(o);}\n" +
				"		};\n" +
				"	}\n" +
				"}"
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 6)\n" + 
		"	return new ArrayList<Object>() {\n" + 
		"	           ^^^^^^^^^^^^^^^^^^^\n" + 
		"The serializable class  does not declare a static final serialVersionUID field of type long\n" + 
		"----------\n" + 
		"2. WARNING in X.java (at line 7)\n" + 
		"	{ add(o);}\n" + 
		"	      ^\n" + 
		"Read access to enclosing field X.o is emulated by a synthetic accessor method\n" + 
		"----------\n",
		null /* no extra class libraries */,
		true /* flush output directory */,
		compilerOptions /* custom options */
	);
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=376550
public void test376550_12() {
	if (this.complianceLevel < ClassFileConstants.JDK1_5)
		return;
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBeStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportUnusedPrivateMember, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
				"X.java", 
				"import java.util.ArrayList;\n" +
				"import java.util.Collection;\n" +
				"public class X<E> {\n" +
				"   private Object o = new Object();\n" +
				"   public final <E1> Collection<E1> go() {\n" + // CAN be static
				"   	return new ArrayList<E1>() {\n" +
				"			{ E1 e;}\n" +
				"		};\n" +
				"	}\n" +
				"}"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 5)\n" + 
		"	public final <E1> Collection<E1> go() {\n" + 
		"	                                 ^^^^\n" + 
		"The method go() from the type X<E> can be declared as static\n" + 
		"----------\n" + 
		"2. WARNING in X.java (at line 6)\n" + 
		"	return new ArrayList<E1>() {\n" + 
		"	           ^^^^^^^^^^^^^^^\n" + 
		"The serializable class  does not declare a static final serialVersionUID field of type long\n" + 
		"----------\n",
		null /* no extra class libraries */,
		true /* flush output directory */,
		compilerOptions /* custom options */
	);
}
}

Lines 90-96 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/AllocationExpression.java (-1 / +1 lines)
90	if (this.binding.declaringClass.isMemberType() && !this.binding.declaringClass.isStatic()) {	90	if (this.binding.declaringClass.isMemberType() && !this.binding.declaringClass.isStatic()) {
91	// allocating a non-static member type without an enclosing instance of parent type	91	// allocating a non-static member type without an enclosing instance of parent type
92	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=335845	92	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=335845
93	currentScope.resetEnclosingMethodStaticFlag();	93	currentScope.resetDeclaringClassMethodStaticFlag(this.binding.declaringClass.enclosingType());
94	}	94	}
95	manageEnclosingInstanceAccessIfNecessary(currentScope, flowInfo);	95	manageEnclosingInstanceAccessIfNecessary(currentScope, flowInfo);
96	manageSyntheticAccessIfNecessary(currentScope, flowInfo);	96	manageSyntheticAccessIfNecessary(currentScope, flowInfo);




/*******************************************************************************
 * Copyright (c) 2000, 2012 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=318682
	if (!this.binding.isStatic()) {
		if (this.receiver.isThis()) {
			currentScope.resetDeclaringClassMethodStaticFlag(this.binding.declaringClass);
		}
	} else if (this.receiver.isThis()) {
		if ((this.receiver.bits & ASTNode.IsImplicitThis) == 0) {
			// explicit this, not allowed in static context
			currentScope.resetDeclaringClassMethodStaticFlag(this.binding.declaringClass);
		}
	}
	return flowInfo;

		this.receiver.checkNPE(currentScope, flowContext, flowInfo);
		// https://bugs.eclipse.org/bugs/show_bug.cgi?id=318682
		if (this.receiver.isThis()) {
			currentScope.resetDeclaringClassMethodStaticFlag(this.binding.declaringClass);
		}
	} else if (this.receiver.isThis()) {
		if ((this.receiver.bits & ASTNode.IsImplicitThis) == 0) {

Lines 47-59 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/LocalDeclaration.java (-3 / +14 lines)
47	this.bits \|= ASTNode.IsLocalDeclarationReachable; // only set if actually reached	47	this.bits \|= ASTNode.IsLocalDeclarationReachable; // only set if actually reached
48	}	48	}
49	if (this.binding != null && this.type.resolvedType instanceof TypeVariableBinding) {	49	if (this.binding != null && this.type.resolvedType instanceof TypeVariableBinding) {
		50	TypeVariableBinding typeVariableBinding = (TypeVariableBinding) this.type.resolvedType;
50	MethodScope methodScope= this.binding.declaringScope.methodScope();	51	MethodScope methodScope= this.binding.declaringScope.methodScope();
		52	if (methodScope != null && methodScope.referenceContext instanceof TypeDeclaration) {
		53	// initialization scope
		54	methodScope = methodScope.enclosingMethodScope();
		55	}
51	AbstractMethodDeclaration methodDeclaration = methodScope.referenceMethod();	56	AbstractMethodDeclaration methodDeclaration = methodScope.referenceMethod();
52	if (methodDeclaration != null && ((methodDeclaration.bits & ASTNode.CanBeStatic) != 0) && methodDeclaration.binding != null) {	57	if (methodDeclaration != null && methodDeclaration.binding != null) {
53	TypeVariableBinding[] typeVariables = methodDeclaration.binding.typeVariables();	58	TypeVariableBinding[] typeVariables = methodDeclaration.binding.typeVariables();
54	if (typeVariables == Binding.NO_TYPE_VARIABLES) {	59	if (typeVariables == Binding.NO_TYPE_VARIABLES) {
55	// Method declares no type variables.	60	// Method declares no type variables.
56	currentScope.resetEnclosingMethodStaticFlag();	61	if (typeVariableBinding.declaringElement instanceof TypeBinding)
		62	currentScope.resetDeclaringClassMethodStaticFlag((TypeBinding) typeVariableBinding.declaringElement);
		63	else
		64	currentScope.resetEnclosingMethodStaticFlag();
57	} else {	65	} else {
58	// to check whether the resolved type for this is declared by enclosing method as a type variable	66	// to check whether the resolved type for this is declared by enclosing method as a type variable
59	boolean usesEnclosingTypeVar = false;	67	boolean usesEnclosingTypeVar = false;
Lines 65-71 Link Here
65	}	73	}
66	if (!usesEnclosingTypeVar) {	74	if (!usesEnclosingTypeVar) {
67	// uses a type variable not declared by enclosing method	75	// uses a type variable not declared by enclosing method
68	currentScope.resetEnclosingMethodStaticFlag();	76	if (typeVariableBinding.declaringElement instanceof TypeBinding)
		77	currentScope.resetDeclaringClassMethodStaticFlag((TypeBinding) typeVariableBinding.declaringElement);
		78	else
		79	currentScope.resetEnclosingMethodStaticFlag();
69	}	80	}
70	}	81	}
71	}	82	}

Lines 86-92 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/MessageSend.java (-1 / +1 lines)
86	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=318682	86	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=318682
87	if (this.receiver.isThis()) {	87	if (this.receiver.isThis()) {
88	// accessing non-static method without an object	88	// accessing non-static method without an object
89	currentScope.resetEnclosingMethodStaticFlag();	89	currentScope.resetDeclaringClassMethodStaticFlag(this.binding.declaringClass);
90	}	90	}
91	} else if (this.receiver.isThis()) {	91	} else if (this.receiver.isThis()) {
92	if ((this.receiver.bits & ASTNode.IsImplicitThis) == 0) {	92	if ((this.receiver.bits & ASTNode.IsImplicitThis) == 0) {

Lines 67-73 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedAllocationExpression.java (-1 / +1 lines)
67	} else {	67	} else {
68	if (this.binding.declaringClass.superclass().isMemberType() && !this.binding.declaringClass.superclass().isStatic()) {	68	if (this.binding.declaringClass.superclass().isMemberType() && !this.binding.declaringClass.superclass().isStatic()) {
69	// creating an anonymous type of a non-static member type without an enclosing instance of parent type	69	// creating an anonymous type of a non-static member type without an enclosing instance of parent type
70	currentScope.resetEnclosingMethodStaticFlag();	70	currentScope.resetDeclaringClassMethodStaticFlag(this.binding.declaringClass.superclass().enclosingType());
71	}	71	}
72	}	72	}
73		73

Lines 86-92 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedNameReference.java (-2 / +2 lines)
86	}	86	}
87	}	87	}
88	if (!lastFieldBinding.isStatic()) {	88	if (!lastFieldBinding.isStatic()) {
89	currentScope.resetEnclosingMethodStaticFlag();	89	currentScope.resetDeclaringClassMethodStaticFlag(lastFieldBinding.declaringClass);
90	}	90	}
91	break;	91	break;
92	case Binding.LOCAL :	92	case Binding.LOCAL :
Lines 195-201 Link Here
195	}	195	}
196	}	196	}
197	if (!fieldBinding.isStatic()) {	197	if (!fieldBinding.isStatic()) {
198	currentScope.resetEnclosingMethodStaticFlag();	198	currentScope.resetDeclaringClassMethodStaticFlag(fieldBinding.declaringClass);
199	}	199	}
200	break;	200	break;
201	case Binding.LOCAL : // reading a local variable	201	case Binding.LOCAL : // reading a local variable




/*******************************************************************************
 * Copyright (c) 2000, 2012 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

				}
				if (!fieldBinding.isStatic()) {
					// https://bugs.eclipse.org/bugs/show_bug.cgi?id=318682
					currentScope.resetDeclaringClassMethodStaticFlag(fieldBinding.declaringClass);
				}
				manageSyntheticAccessIfNecessary(currentScope, flowInfo, true /*read-access*/);
				break;

			}
			if (!fieldBinding.isStatic()) {
				// https://bugs.eclipse.org/bugs/show_bug.cgi?id=318682
				currentScope.resetDeclaringClassMethodStaticFlag(fieldBinding.declaringClass);
			}
			break;
		case Binding.LOCAL : // assigning to a local variable

			}
			if (!fieldBinding.isStatic()) {
				// https://bugs.eclipse.org/bugs/show_bug.cgi?id=318682
				currentScope.resetDeclaringClassMethodStaticFlag(fieldBinding.declaringClass);
			}
			break;
		case Binding.LOCAL : // reading a local variable




	return s;
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=318682
/**
 * This method is used to reset the CanBeStatic the enclosing method of the current block
 */
public void resetEnclosingMethodStaticFlag() {
	MethodScope methodScope = methodScope();
	if (methodScope != null) {
		if (methodScope.referenceContext instanceof MethodDeclaration) {
			MethodDeclaration methodDeclaration = (MethodDeclaration) methodScope.referenceContext;
			methodDeclaration.bits &= ~ASTNode.CanBeStatic;
		} else if (methodScope.referenceContext instanceof TypeDeclaration) {
			// anonymous type, find enclosing method
			methodScope = methodScope.enclosingMethodScope();
			if (methodScope != null && methodScope.referenceContext instanceof MethodDeclaration) {
				MethodDeclaration methodDeclaration = (MethodDeclaration) methodScope.referenceContext;
				methodDeclaration.bits &= ~ASTNode.CanBeStatic;
			}
		}
	}
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=376550
/**
 * This method is used to reset the CanBeStatic on all enclosing methods until the method 
 * belonging to the declaringClass
 * @param declaringClass
 */
public void resetDeclaringClassMethodStaticFlag(TypeBinding declaringClass) {
	MethodScope methodScope = methodScope();
	if (methodScope != null && methodScope.referenceContext instanceof TypeDeclaration) {
		// anonymous type, find enclosing method
		methodScope = methodScope.enclosingMethodScope();
	}
	while (methodScope != null && methodScope.referenceContext instanceof MethodDeclaration) {
		MethodDeclaration methodDeclaration = (MethodDeclaration) methodScope.referenceContext;
		methodDeclaration.bits &= ~ASTNode.CanBeStatic;
		ClassScope enclosingClassScope = methodScope.enclosingClassScope();
		if (enclosingClassScope != null) {
			TypeDeclaration type = enclosingClassScope.referenceContext;
			if (type.binding != null && declaringClass != null && type.binding != declaringClass.original()) {
				methodScope = enclosingClassScope.enclosingMethodScope();
			} else {
				break;
			}
		}
	}
}

Return to bug 376550

Lines 1-5 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/FieldReference.java (-4 / +4 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2011 IBM Corporation and others.	2	* Copyright (c) 2000, 2012 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 111-122 Link Here
111	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=318682	111	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=318682
112	if (!this.binding.isStatic()) {	112	if (!this.binding.isStatic()) {
113	if (this.receiver.isThis()) {	113	if (this.receiver.isThis()) {
114	currentScope.resetEnclosingMethodStaticFlag();	114	currentScope.resetDeclaringClassMethodStaticFlag(this.binding.declaringClass);
115	}	115	}
116	} else if (this.receiver.isThis()) {	116	} else if (this.receiver.isThis()) {
117	if ((this.receiver.bits & ASTNode.IsImplicitThis) == 0) {	117	if ((this.receiver.bits & ASTNode.IsImplicitThis) == 0) {
118	// explicit this, not allowed in static context	118	// explicit this, not allowed in static context
119	currentScope.resetEnclosingMethodStaticFlag();	119	currentScope.resetDeclaringClassMethodStaticFlag(this.binding.declaringClass);
120	}	120	}
121	}	121	}
122	return flowInfo;	122	return flowInfo;
Lines 133-139 Link Here
133	this.receiver.checkNPE(currentScope, flowContext, flowInfo);	133	this.receiver.checkNPE(currentScope, flowContext, flowInfo);
134	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=318682	134	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=318682
135	if (this.receiver.isThis()) {	135	if (this.receiver.isThis()) {
136	currentScope.resetEnclosingMethodStaticFlag();	136	currentScope.resetDeclaringClassMethodStaticFlag(this.binding.declaringClass);
137	}	137	}
138	} else if (this.receiver.isThis()) {	138	} else if (this.receiver.isThis()) {
139	if ((this.receiver.bits & ASTNode.IsImplicitThis) == 0) {	139	if ((this.receiver.bits & ASTNode.IsImplicitThis) == 0) {

Lines 957-972 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/BlockScope.java (-4 / +37 lines)
957	return s;	957	return s;
958	}	958	}
959	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=318682	959	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=318682
		960	/**
		961	* This method is used to reset the CanBeStatic the enclosing method of the current block
		962	*/
960	public void resetEnclosingMethodStaticFlag() {	963	public void resetEnclosingMethodStaticFlag() {
961	MethodScope methodScope = methodScope();	964	MethodScope methodScope = methodScope();
		965	if (methodScope != null) {
		966	if (methodScope.referenceContext instanceof MethodDeclaration) {
		967	MethodDeclaration methodDeclaration = (MethodDeclaration) methodScope.referenceContext;
		968	methodDeclaration.bits &= ~ASTNode.CanBeStatic;
		969	} else if (methodScope.referenceContext instanceof TypeDeclaration) {
		970	// anonymous type, find enclosing method
		971	methodScope = methodScope.enclosingMethodScope();
		972	if (methodScope != null && methodScope.referenceContext instanceof MethodDeclaration) {
		973	MethodDeclaration methodDeclaration = (MethodDeclaration) methodScope.referenceContext;
		974	methodDeclaration.bits &= ~ASTNode.CanBeStatic;
		975	}
		976	}
		977	}
		978	}
		979
		980	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=376550
		981	/**
		982	* This method is used to reset the CanBeStatic on all enclosing methods until the method
		983	* belonging to the declaringClass
		984	* @param declaringClass
		985	*/
		986	public void resetDeclaringClassMethodStaticFlag(TypeBinding declaringClass) {
		987	MethodScope methodScope = methodScope();
		988	if (methodScope != null && methodScope.referenceContext instanceof TypeDeclaration) {
		989	// anonymous type, find enclosing method
		990	methodScope = methodScope.enclosingMethodScope();
		991	}
962	while (methodScope != null && methodScope.referenceContext instanceof MethodDeclaration) {	992	while (methodScope != null && methodScope.referenceContext instanceof MethodDeclaration) {
963	MethodDeclaration methodDeclaration= (MethodDeclaration) methodScope.referenceContext;	993	MethodDeclaration methodDeclaration = (MethodDeclaration) methodScope.referenceContext;
964	methodDeclaration.bits &= ~ASTNode.CanBeStatic;	994	methodDeclaration.bits &= ~ASTNode.CanBeStatic;
965	ClassScope enclosingClassScope = methodScope.enclosingClassScope();	995	ClassScope enclosingClassScope = methodScope.enclosingClassScope();
966	if (enclosingClassScope != null) {	996	if (enclosingClassScope != null) {
967	methodScope = enclosingClassScope.methodScope();	997	TypeDeclaration type = enclosingClassScope.referenceContext;
968	} else {	998	if (type.binding != null && declaringClass != null && type.binding != declaringClass.original()) {
969	break;	999	methodScope = enclosingClassScope.enclosingMethodScope();
		1000	} else {
		1001	break;
		1002	}
970	}	1003	}
971	}	1004	}
972	}	1005	}