Attachment #184249 for bug #318682

Lines 3228-3233 Link Here

(-)batch/org/eclipse/jdt/internal/compiler/batch/Main.java (+7 lines)
3228	CompilerOptions.OPTION_ReportMissingOverrideAnnotationForInterfaceMethodImplementation,	3228	CompilerOptions.OPTION_ReportMissingOverrideAnnotationForInterfaceMethodImplementation,
3229	isEnabling ? CompilerOptions.ENABLED : CompilerOptions.DISABLED);	3229	isEnabling ? CompilerOptions.ENABLED : CompilerOptions.DISABLED);
3230	return;	3230	return;
		3231	} else if (token.equals("all-static-method")) { //$NON-NLS-1$
		3232	setSeverity(CompilerOptions.OPTION_ReportMethodCanBeStatic, severity, isEnabling);
		3233	setSeverity(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, severity, isEnabling);
		3234	return;
3231	}	3235	}
3232	break;	3236	break;
3233	case 'b' :	3237	case 'b' :
Lines 3459-3464 Link Here
3459	} else if (token.equals("super")) { //$NON-NLS-1$	3463	} else if (token.equals("super")) { //$NON-NLS-1$
3460	setSeverity(CompilerOptions.OPTION_ReportOverridingMethodWithoutSuperInvocation, severity, isEnabling);	3464	setSeverity(CompilerOptions.OPTION_ReportOverridingMethodWithoutSuperInvocation, severity, isEnabling);
3461	return;	3465	return;
		3466	} else if (token.equals("static-method")) { //$NON-NLS-1$
		3467	setSeverity(CompilerOptions.OPTION_ReportMethodCanBeStatic, severity, isEnabling);
		3468	return;
3462	}	3469	}
3463	break;	3470	break;
3464	case 't' :	3471	case 't' :

Lines 401-406 Link Here

(-)compiler/org/eclipse/jdt/core/compiler/IProblem.java (+4 lines)
401	int IndirectAccessToStaticMethod = Internal + MethodRelated + 119;	401	int IndirectAccessToStaticMethod = Internal + MethodRelated + 119;
402	/** @since 3.4 */	402	/** @since 3.4 */
403	int MissingTypeInMethod = MethodRelated + 120;	403	int MissingTypeInMethod = MethodRelated + 120;
		404	/** @since 3.7 */
		405	int MethodCanBeStatic = Internal + MethodRelated + 121;
		406	/** @since 3.7 */
		407	int MethodCanBePotentiallyStatic = Internal + MethodRelated + 122;
404		408
405	// constructors	409	// constructors
406	/** @since 3.4 */	410	/** @since 3.4 */

Lines 169-174 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java (+1 lines)
169	// for block and method declaration	169	// for block and method declaration
170	public static final int UndocumentedEmptyBlock = Bit4;	170	public static final int UndocumentedEmptyBlock = Bit4;
171	public static final int OverridingMethodWithSupercall = Bit5;	171	public static final int OverridingMethodWithSupercall = Bit5;
		172	public static final int CanBeStatic = Bit6; // used to flag a method that can be declared static
172		173
173	// for initializer and method declaration	174	// for initializer and method declaration
174	public static final int ErrorInSignature = Bit6;	175	public static final int ErrorInSignature = Bit6;




	if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) == 0) {
		this.bits |= ASTNode.IsLocalDeclarationReachable; // only set if actually reached
	}
	if (this.binding != null && this.type.resolvedType instanceof TypeVariableBinding) {
		MethodScope methodScope= this.binding.declaringScope.methodScope();
		AbstractMethodDeclaration methodDeclaration = methodScope.referenceMethod();
		if (methodDeclaration != null && methodDeclaration.binding != null) {
			TypeVariableBinding[] typeVariables = methodDeclaration.binding.typeVariables();
			if (typeVariables == Binding.NO_TYPE_VARIABLES) {
				// Method declares no type variables.
				currentScope.resetEnclosingMethodStaticFlag();
			} else {
				for (int i = 0; i < typeVariables.length ; i ++) {
					if (typeVariables[i] != this.type.resolvedType){
						// uses a type variable not declared by enclosing method
						currentScope.resetEnclosingMethodStaticFlag();
						break;
					}
				}
			}
		}
	}
//	if (this.type.resolvedType instanceof TypeVariableBinding) {
//		Binding declaringElement = ((TypeVariableBinding)this.type.resolvedType).declaringElement;
//		if (this.binding != null &&  this.binding.declaringScope != null) {
//			ClassScope enclosingClassScope = this.binding.declaringScope.enclosingClassScope();
//			if (enclosingClassScope != null && enclosingClassScope.referenceContext != null && enclosingClassScope.referenceContext.binding == declaringElement)
//				currentScope.resetEnclosingMethodStaticFlag();
//		}
//	}
	if (this.initialization == null) {
		return flowInfo;
	}




	flowInfo = this.receiver.analyseCode(currentScope, flowContext, flowInfo, nonStatic).unconditionalInits();
	if (nonStatic) {
		this.receiver.checkNPE(currentScope, flowContext, flowInfo);
		// https://bugs.eclipse.org/bugs/show_bug.cgi?id=318682
		if (this.receiver.isThis()) {
			// accessing non-static method without an object
			currentScope.resetEnclosingMethodStaticFlag();
		}
	} else if (this.receiver.isThis()) {
		if ((this.receiver.bits & ASTNode.IsImplicitThis) == 0) {
			// explicit this receiver, not allowed in static context
			currentScope.resetEnclosingMethodStaticFlag();
		}
	}

	if (this.arguments != null) {

Lines 81-86 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedNameReference.java (-1 / +7 lines)
81	currentScope.problemReporter().uninitializedBlankFinalField(lastFieldBinding, this);	81	currentScope.problemReporter().uninitializedBlankFinalField(lastFieldBinding, this);
82	}	82	}
83	}	83	}
		84	if (!lastFieldBinding.isStatic()) {
		85	currentScope.resetEnclosingMethodStaticFlag();
		86	}
84	break;	87	break;
85	case Binding.LOCAL :	88	case Binding.LOCAL :
86	// first binding is a local variable	89	// first binding is a local variable
Lines 176-183 Link Here
176	if (needValue \|\| complyTo14) {	179	if (needValue \|\| complyTo14) {
177	manageSyntheticAccessIfNecessary(currentScope, (FieldBinding) this.binding, 0, flowInfo);	180	manageSyntheticAccessIfNecessary(currentScope, (FieldBinding) this.binding, 0, flowInfo);
178	}	181	}
		182	FieldBinding fieldBinding = (FieldBinding) this.binding;
179	if (this.indexOfFirstFieldBinding == 1) { // was an implicit reference to the first field binding	183	if (this.indexOfFirstFieldBinding == 1) { // was an implicit reference to the first field binding
180	FieldBinding fieldBinding = (FieldBinding) this.binding;
181	// check if reading a final blank field	184	// check if reading a final blank field
182	if (fieldBinding.isBlankFinal()	185	if (fieldBinding.isBlankFinal()
183	&& currentScope.needBlankFinalFieldInitializationCheck(fieldBinding)) {	186	&& currentScope.needBlankFinalFieldInitializationCheck(fieldBinding)) {
Lines 187-192 Link Here
187	}	190	}
188	}	191	}
189	}	192	}
		193	if (!fieldBinding.isStatic()) {
		194	currentScope.resetEnclosingMethodStaticFlag();
		195	}
190	break;	196	break;
191	case Binding.LOCAL : // reading a local variable	197	case Binding.LOCAL : // reading a local variable
192	LocalVariableBinding localBinding;	198	LocalVariableBinding localBinding;

Lines 1-5 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/SuperReference.java (-1 / +8 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2009 IBM Corporation and others.	2	* Copyright (c) 2000, 2010 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 11-16 Link Here
11	package org.eclipse.jdt.internal.compiler.ast;	11	package org.eclipse.jdt.internal.compiler.ast;
12		12
13	import org.eclipse.jdt.internal.compiler.ASTVisitor;	13	import org.eclipse.jdt.internal.compiler.ASTVisitor;
		14	import org.eclipse.jdt.internal.compiler.flow.FlowContext;
		15	import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
14	import org.eclipse.jdt.internal.compiler.impl.Constant;	16	import org.eclipse.jdt.internal.compiler.impl.Constant;
15	import org.eclipse.jdt.internal.compiler.lookup.BlockScope;	17	import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
16	import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;	18	import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
Lines 66-69 Link Here
66	visitor.visit(this, blockScope);	68	visitor.visit(this, blockScope);
67	visitor.endVisit(this, blockScope);	69	visitor.endVisit(this, blockScope);
68	}	70	}
		71
		72	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
		73	currentScope.resetEnclosingMethodStaticFlag();
		74	return analyseCode(currentScope, flowContext, flowInfo);
		75	}
69	}	76	}

Lines 133-138 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/impl/CompilerOptions.java (+22 lines)
133	public static final String OPTION_ReportTasks = "org.eclipse.jdt.core.compiler.problem.tasks"; //$NON-NLS-1$	133	public static final String OPTION_ReportTasks = "org.eclipse.jdt.core.compiler.problem.tasks"; //$NON-NLS-1$
134	public static final String OPTION_ReportUnusedObjectAllocation = "org.eclipse.jdt.core.compiler.problem.unusedObjectAllocation"; //$NON-NLS-1$	134	public static final String OPTION_ReportUnusedObjectAllocation = "org.eclipse.jdt.core.compiler.problem.unusedObjectAllocation"; //$NON-NLS-1$
135	public static final String OPTION_IncludeNullInfoFromAsserts = "org.eclipse.jdt.core.compiler.problem.includeNullInfoFromAsserts"; //$NON-NLS-1$	135	public static final String OPTION_IncludeNullInfoFromAsserts = "org.eclipse.jdt.core.compiler.problem.includeNullInfoFromAsserts"; //$NON-NLS-1$
		136	public static final String OPTION_ReportMethodCanBeStatic = "org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic"; //$NON-NLS-1$
		137	public static final String OPTION_ReportMethodCanBePotentiallyStatic = "org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic"; //$NON-NLS-1$
136	// Backward compatibility	138	// Backward compatibility
137	public static final String OPTION_ReportInvalidAnnotation = "org.eclipse.jdt.core.compiler.problem.invalidAnnotation"; //$NON-NLS-1$	139	public static final String OPTION_ReportInvalidAnnotation = "org.eclipse.jdt.core.compiler.problem.invalidAnnotation"; //$NON-NLS-1$
138	public static final String OPTION_ReportMissingAnnotation = "org.eclipse.jdt.core.compiler.problem.missingAnnotation"; //$NON-NLS-1$	140	public static final String OPTION_ReportMissingAnnotation = "org.eclipse.jdt.core.compiler.problem.missingAnnotation"; //$NON-NLS-1$
Lines 238-243 Link Here
238	public static final int DeadCode = IrritantSet.GROUP2 \| ASTNode.Bit2;	240	public static final int DeadCode = IrritantSet.GROUP2 \| ASTNode.Bit2;
239	public static final int Tasks = IrritantSet.GROUP2 \| ASTNode.Bit3;	241	public static final int Tasks = IrritantSet.GROUP2 \| ASTNode.Bit3;
240	public static final int UnusedObjectAllocation = IrritantSet.GROUP2 \| ASTNode.Bit4;	242	public static final int UnusedObjectAllocation = IrritantSet.GROUP2 \| ASTNode.Bit4;
		243	public static final int MethodCanBeStatic = IrritantSet.GROUP2 \| ASTNode.Bit5;
		244	public static final int MethodCanBePotentiallyStatic = IrritantSet.GROUP2 \| ASTNode.Bit6;
241		245
242	// Severity level for handlers	246	// Severity level for handlers
243	/**	247	/**
Lines 375-380 Link Here
375	"rawtypes", //$NON-NLS-1$	379	"rawtypes", //$NON-NLS-1$
376	"serial", //$NON-NLS-1$	380	"serial", //$NON-NLS-1$
377	"static-access", //$NON-NLS-1$	381	"static-access", //$NON-NLS-1$
		382	"static-method", //$NON-NLS-1$
378	"super", //$NON-NLS-1$	383	"super", //$NON-NLS-1$
379	"synthetic-access", //$NON-NLS-1$	384	"synthetic-access", //$NON-NLS-1$
380	"unchecked", //$NON-NLS-1$	385	"unchecked", //$NON-NLS-1$
Lines 539-544 Link Here
539	return OPTION_ReportDeadCode;	544	return OPTION_ReportDeadCode;
540	case UnusedObjectAllocation:	545	case UnusedObjectAllocation:
541	return OPTION_ReportUnusedObjectAllocation;	546	return OPTION_ReportUnusedObjectAllocation;
		547	case MethodCanBeStatic :
		548	return OPTION_ReportMethodCanBeStatic;
		549	case MethodCanBePotentiallyStatic :
		550	return OPTION_ReportMethodCanBePotentiallyStatic;
542	}	551	}
543	return null;	552	return null;
544	}	553	}
Lines 638-643 Link Here
638	OPTION_ReportInvalidJavadoc,	647	OPTION_ReportInvalidJavadoc,
639	OPTION_ReportLocalVariableHiding,	648	OPTION_ReportLocalVariableHiding,
640	OPTION_ReportMethodWithConstructorName,	649	OPTION_ReportMethodWithConstructorName,
		650	OPTION_ReportMethodCanBeStatic,
		651	OPTION_ReportMethodCanBePotentiallyStatic,
641	OPTION_ReportMissingDeprecatedAnnotation,	652	OPTION_ReportMissingDeprecatedAnnotation,
642	OPTION_ReportMissingJavadocComments,	653	OPTION_ReportMissingJavadocComments,
643	OPTION_ReportMissingJavadocTagDescription,	654	OPTION_ReportMissingJavadocTagDescription,
Lines 739-744 Link Here
739	return "fallthrough"; //$NON-NLS-1$	750	return "fallthrough"; //$NON-NLS-1$
740	case OverridingMethodWithoutSuperInvocation :	751	case OverridingMethodWithoutSuperInvocation :
741	return "super"; //$NON-NLS-1$	752	return "super"; //$NON-NLS-1$
		753	case MethodCanBeStatic :
		754	case MethodCanBePotentiallyStatic :
		755	return "static-method"; //$NON-NLS-1$
742	}	756	}
743	return null;	757	return null;
744	}	758	}
Lines 796-801 Link Here
796	return IrritantSet.SERIAL;	810	return IrritantSet.SERIAL;
797	if ("static-access".equals(warningToken)) //$NON-NLS-1$	811	if ("static-access".equals(warningToken)) //$NON-NLS-1$
798	return IrritantSet.STATIC_ACCESS;	812	return IrritantSet.STATIC_ACCESS;
		813	if ("static-method".equals(warningToken)) //$NON-NLS-1$
		814	return IrritantSet.STATIC_METHOD;
799	if ("synthetic-access".equals(warningToken)) //$NON-NLS-1$	815	if ("synthetic-access".equals(warningToken)) //$NON-NLS-1$
800	return IrritantSet.SYNTHETIC_ACCESS;	816	return IrritantSet.SYNTHETIC_ACCESS;
801	if ("super".equals(warningToken)) { //$NON-NLS-1$	817	if ("super".equals(warningToken)) { //$NON-NLS-1$
Lines 921-926 Link Here
921	optionsMap.put(OPTION_ReportTasks, getSeverityString(Tasks));	937	optionsMap.put(OPTION_ReportTasks, getSeverityString(Tasks));
922	optionsMap.put(OPTION_ReportUnusedObjectAllocation, getSeverityString(UnusedObjectAllocation));	938	optionsMap.put(OPTION_ReportUnusedObjectAllocation, getSeverityString(UnusedObjectAllocation));
923	optionsMap.put(OPTION_IncludeNullInfoFromAsserts, this.includeNullInfoFromAsserts ? ENABLED : DISABLED);	939	optionsMap.put(OPTION_IncludeNullInfoFromAsserts, this.includeNullInfoFromAsserts ? ENABLED : DISABLED);
		940	optionsMap.put(OPTION_ReportMethodCanBeStatic, getSeverityString(MethodCanBeStatic));
		941	optionsMap.put(OPTION_ReportMethodCanBePotentiallyStatic, getSeverityString(MethodCanBePotentiallyStatic));
924	return optionsMap;	942	return optionsMap;
925	}	943	}
926		944
Lines 1339-1344 Link Here
1339	if ((optionValue = optionsMap.get(OPTION_ReportDeadCode)) != null) updateSeverity(DeadCode, optionValue);	1357	if ((optionValue = optionsMap.get(OPTION_ReportDeadCode)) != null) updateSeverity(DeadCode, optionValue);
1340	if ((optionValue = optionsMap.get(OPTION_ReportTasks)) != null) updateSeverity(Tasks, optionValue);	1358	if ((optionValue = optionsMap.get(OPTION_ReportTasks)) != null) updateSeverity(Tasks, optionValue);
1341	if ((optionValue = optionsMap.get(OPTION_ReportUnusedObjectAllocation)) != null) updateSeverity(UnusedObjectAllocation, optionValue);	1359	if ((optionValue = optionsMap.get(OPTION_ReportUnusedObjectAllocation)) != null) updateSeverity(UnusedObjectAllocation, optionValue);
		1360	if ((optionValue = optionsMap.get(OPTION_ReportMethodCanBeStatic)) != null) updateSeverity(MethodCanBeStatic, optionValue);
		1361	if ((optionValue = optionsMap.get(OPTION_ReportMethodCanBePotentiallyStatic)) != null) updateSeverity(MethodCanBePotentiallyStatic, optionValue);
1342		1362
1343	// Javadoc options	1363	// Javadoc options
1344	if ((optionValue = optionsMap.get(OPTION_DocCommentSupport)) != null) {	1364	if ((optionValue = optionsMap.get(OPTION_DocCommentSupport)) != null) {
Lines 1551-1556 Link Here
1551	buf.append("\n\t- dead code in trivial if statement: ").append(this.reportDeadCodeInTrivialIfStatement ? ENABLED : DISABLED); //$NON-NLS-1$	1571	buf.append("\n\t- dead code in trivial if statement: ").append(this.reportDeadCodeInTrivialIfStatement ? ENABLED : DISABLED); //$NON-NLS-1$
1552	buf.append("\n\t- tasks severity: ").append(getSeverityString(Tasks)); //$NON-NLS-1$	1572	buf.append("\n\t- tasks severity: ").append(getSeverityString(Tasks)); //$NON-NLS-1$
1553	buf.append("\n\t- unused object allocation: ").append(getSeverityString(UnusedObjectAllocation)); //$NON-NLS-1$	1573	buf.append("\n\t- unused object allocation: ").append(getSeverityString(UnusedObjectAllocation)); //$NON-NLS-1$
		1574	buf.append("\n\t- method can be static: ").append(getSeverityString(MethodCanBeStatic)); //$NON-NLS-1$
		1575	buf.append("\n\t- method can be potentially static: ").append(getSeverityString(MethodCanBePotentiallyStatic)); //$NON-NLS-1$
1554	return buf.toString();	1576	return buf.toString();
1555	}	1577	}
1556		1578




			s += ((BlockScope) this.subscopes[i]).toString(tab + 1) + "\n"; //$NON-NLS-1$
	return s;
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=318682
public void resetEnclosingMethodStaticFlag() {
	MethodScope methodScope = methodScope();
	while (methodScope != null && methodScope.referenceContext instanceof MethodDeclaration) {
		MethodDeclaration methodDeclaration= (MethodDeclaration) methodScope.referenceContext;
		methodDeclaration.bits &= ~ASTNode.CanBeStatic;
		ClassScope enclosingClassScope = methodScope.enclosingClassScope();
		if (enclosingClassScope != null) {
			methodScope = enclosingClassScope.methodScope();
		} else {
			break;
		}
	}
}
}

Lines 103-108 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties (+2 lines)
103	118 = The method {1}({2}) from the type {0} is never used locally	103	118 = The method {1}({2}) from the type {0} is never used locally
104	119 = The static method {1}({2}) from the type {0} should be accessed directly	104	119 = The static method {1}({2}) from the type {0} should be accessed directly
105	120 = The method {1}({2}) from the type {0} refers to the missing type {3}	105	120 = The method {1}({2}) from the type {0} refers to the missing type {3}
		106	121 = The method {1}({2}) from the type {0} can be declared as static
		107	122 = The method {1}({2}) from the type {0} can potentially be declared as static
106		108
107	129 = The constructor {0}({1}) refers to the missing type {2}	109	129 = The constructor {0}({1}) refers to the missing type {2}
108	130 = The constructor {0}({1}) is undefined	110	130 = The constructor {0}({1}) is undefined




// Static initializer to specify tests subset using TESTS_* static variables
// All specified tests which does not belong to the class are skipped...
static {
//		TESTS_NAMES = new String[] { "test120" };
//		TESTS_NUMBERS = new int[] { 113 };
//		TESTS_RANGE = new int[] { 108, -1 };
}

		false,
		null);
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=318682
// QualifiedNameReference, SingleNameReference and MessageSend
// Can be static warning shown
public void test114() {
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBeStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, CompilerOptions.ERROR);
	this.runNegativeTest(
		new String[] {
			"X.java", 
			"public class X {\n" +
			"	public static int field1;\n" +
			"	public static int field2;\n" + 
			"	public void bar(int i) {\n" + 
			"		System.out.println(foo());\n" +
			"		foo();" +
			"		System.out.println(X.field1);\n" +
			"		System.out.println(field2);\n" +
			"		field2 = 1;\n" +
			"	}\n" + 
			"	public final void bar2(int i) {\n" + 
			"		System.out.println(foo());\n" +
			"		foo();" +
			"		System.out.println(X.field1);\n" +
			"		System.out.println(field2);\n" +
			"		field2 = 1;\n" +
			"	}\n" +
			"	private void bar3(int i) {\n" + 
			"		System.out.println(foo());\n" +
			"		foo();" +
			"		System.out.println(X.field1);\n" +
			"		System.out.println(field2);\n" +
			"		field2 = 1;\n" +
			"	}\n" +
			"	private static String foo() {\n" + 
			"		return null;\n" + 
			"	}\n" + 
			"}"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	public void bar(int i) {\n" + 
		"	            ^^^^^^^^^^\n" + 
		"The method bar(int) from the type X can potentially be declared as static\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 10)\n" + 
		"	public final void bar2(int i) {\n" + 
		"	                  ^^^^^^^^^^^\n" + 
		"The method bar2(int) from the type X can be declared as static\n" + 
		"----------\n" + 
		"3. WARNING in X.java (at line 16)\n" + 
		"	private void bar3(int i) {\n" + 
		"	             ^^^^^^^^^^^\n" + 
		"The method bar3(int) from the type X is never used locally\n" + 
		"----------\n" + 
		"4. ERROR in X.java (at line 16)\n" + 
		"	private void bar3(int i) {\n" + 
		"	             ^^^^^^^^^^^\n" + 
		"The method bar3(int) from the type X can 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=318682
// FieldReference and MessageSend
// Can be static warning shown
public void test115() {
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBeStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, CompilerOptions.ERROR);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X extends B{\n" +
			"	public static int field1;\n" +
			"	public static int field2;\n" +
			"	public void bar(int i) {\n" + 
			"		System.out.println(foo());\n" +
			"		X.field2 = 2;\n" +
			"		System.out.println(field1);\n" +
			"		A a = new A();\n" +
			"		a.a1();\n" +
			"	}\n" + 
			"	private static String foo() {\n" + 
			"		return null;\n" + 
			"	}\n" + 
			"}\n" +
			"class A{\n" +
			"	public void a1() {\n" +
			"	}\n" +
			"}\n" +
			"class B{\n" +
			"	public void b1(){\n" +
			"	}\n" +
			"}"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	public void bar(int i) {\n" + 
		"	            ^^^^^^^^^^\n" + 
		"The method bar(int) 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=318682
// MessageSend in different ways
public void test116a() {
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBeStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportNonStaticAccessToStatic, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X extends B{\n" +
			"	public static int field1;\n" +
			"	public X xfield;\n" +
			"	public void bar1(int i) {\n" + 
			"		baz();\n" +
			"	}\n" +
			"	public void bar2(int i) {\n" + 
			"		this.baz();\n" +
			"	}\n" +
			"	public void bar3(int i) {\n" + 
			"		this.xfield.baz();\n" +
			"	}\n" +
			"	public void bar4(int i) {\n" + 
			"		xfield.baz();\n" +
			"	}\n" +
			"	public void bar5(int i) {\n" + 
			"		X x = new X();\n" +
			"		x.baz();\n" +
			"	}\n" +
			"	public void bar6(int i) {\n" + 
			"		A.xA.baz();\n" +
			"	}\n" +
			"	public void bar7(int i) {\n" + 
			"		b1();\n" +
			"	}\n" +
			"	public void bar8(int i) {\n" + 
			"		this.b1();\n" +
			"	}\n" +
			"	public void bar9(int i) {\n" + 
			"		new X().b1();\n" +
			"	}\n" +
			"	public void baz() {\n" +
			"	}\n" + 
			"}\n" +
			"class A{\n" +
			"	public static X xA;\n" +
			"}\n" +
			"class B{\n" +
			"	public void b1(){\n" +
			"	}\n" +
			"}",
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 16)\n" + 
		"	public void bar5(int i) {\n" + 
		"	            ^^^^^^^^^^^\n" + 
		"The method bar5(int) from the type X can potentially be declared as static\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 20)\n" + 
		"	public void bar6(int i) {\n" + 
		"	            ^^^^^^^^^^^\n" + 
		"The method bar6(int) from the type X can potentially be declared as static\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 29)\n" + 
		"	public void bar9(int i) {\n" + 
		"	            ^^^^^^^^^^^\n" + 
		"The method bar9(int) 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=318682
// MessageSend in different ways, referencing a static method.
public void test116b() {
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBeStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportNonStaticAccessToStatic, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X extends B{\n" +
			"	public static int field1;\n" +
			"	public static X xfield;\n" +
			"	public void bar1(int i) {\n" + 
			"		baz();\n" +
			"	}\n" +
			"	public void bar2(int i) {\n" + 
			"		this.baz();\n" +
			"	}\n" +
			"	public void bar3(int i) {\n" + 
			"		this.xfield.baz();\n" +
			"	}\n" +
			"	public void bar4(int i) {\n" + 
			"		xfield.baz();\n" +
			"	}\n" +
			"	public void bar5(int i) {\n" + 
			"		X x = new X();\n" +
			"		x.baz();\n" +
			"	}\n" +
			"	public void bar6(int i) {\n" + 
			"		A.xA.baz();\n" +
			"	}\n" +
			"	public void bar7(int i) {\n" + 
			"		b1();\n" +
			"	}\n" +
			"	public void bar8(int i) {\n" + 
			"		this.b1();\n" +
			"	}\n" +
			"	public void bar9(int i) {\n" + 
			"		new X().b1();\n" +
			"	}\n" +
			"	public static void baz() {\n" +
			"	}\n" + 
			"}\n" +
			"class A{\n" +
			"	public static X xA;\n" +
			"}\n" +
			"class B{\n" +
			"	public static void b1(){\n" +
			"	}\n" +
			"}",
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	public void bar1(int i) {\n" + 
		"	            ^^^^^^^^^^^\n" + 
		"The method bar1(int) from the type X can potentially be declared as static\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 13)\n" + 
		"	public void bar4(int i) {\n" + 
		"	            ^^^^^^^^^^^\n" + 
		"The method bar4(int) from the type X can potentially be declared as static\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 16)\n" + 
		"	public void bar5(int i) {\n" + 
		"	            ^^^^^^^^^^^\n" + 
		"The method bar5(int) from the type X can potentially be declared as static\n" + 
		"----------\n" + 
		"4. ERROR in X.java (at line 20)\n" + 
		"	public void bar6(int i) {\n" + 
		"	            ^^^^^^^^^^^\n" + 
		"The method bar6(int) from the type X can potentially be declared as static\n" + 
		"----------\n" + 
		"5. ERROR in X.java (at line 23)\n" + 
		"	public void bar7(int i) {\n" + 
		"	            ^^^^^^^^^^^\n" + 
		"The method bar7(int) from the type X can potentially be declared as static\n" + 
		"----------\n" + 
		"6. ERROR in X.java (at line 29)\n" + 
		"	public void bar9(int i) {\n" + 
		"	            ^^^^^^^^^^^\n" + 
		"The method bar9(int) 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=318682
// Referring a field in different ways, accessing non-static field.
public void test117a() {
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBeStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportNonStaticAccessToStatic, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X extends B{\n" +
			"	public int field1;\n" +
			"	public X xfield;\n" +
			"	public void bar1(int i) {\n" + 
			"		field1 = 1;\n" +
			"	}\n" +
			"	public void bar2(int i) {\n" + 
			"		this.field1 = 1;\n" +
			"	}\n" +
			"	public void bar3(int i) {\n" + 
			"		System.out.println(field1);\n" +
			"	}\n" +
			"	public void bar4(int i) {\n" + 
			"		System.out.println(this.field1);\n" +
			"	}\n" +
			"	public void bar5(int i) {\n" + 
			"		X x = new X();\n" +
			"		x.field1 = 1;\n" +
			"	}\n" +
			"	public void bar6(int i) {\n" + 
			"		A.xA.field1 = 1;\n" +
			"	}\n" +
			"	public void bar7(int i) {\n" + 
			"		b1 = 1;\n" +
			"	}\n" +
			"	public void bar8(int i) {\n" + 
			"		this.b1 = 1;\n" +
			"	}\n" +
			"	public void bar9(int i) {\n" + 
			"		new X().b1 = 1;\n" +
			"	}\n" +
			"	public void bar10(int i) {\n" + 
			"		this.xfield.field1 = 1;\n" +
			"	}\n" +
			"	public void bar11(int i) {\n" + 
			"		System.out.println(this.xfield.field1);\n" +
			"	}\n" +
			"	public void bar12(int i) {\n" + 
			"		System.out.println(new X().b1);\n" +
			"	}\n" +
			"	public void bar13(int i) {\n" + 
			"		System.out.println(b1);\n" +
			"	}\n" +
			"	public void bar14(int i) {\n" + 
			"		System.out.println(this.b1);\n" +
			"	}\n" +
			"	public void bar15(int i) {\n" + 
			"		xfield.field1 = 1;\n" +
			"	}\n" +
			"	public void bar16(int i) {\n" + 
			"		System.out.println(xfield.field1);\n" +
			"	}\n" +
			"	public void baz() {\n" +
			"	}\n" + 
			"}\n" +
			"class A{\n" +
			"	public static X xA;\n" +
			"}\n" +
			"class B{\n" +
			"	public int b1;\n" +
			"}",
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 16)\n" + 
		"	public void bar5(int i) {\n" + 
		"	            ^^^^^^^^^^^\n" + 
		"The method bar5(int) from the type X can potentially be declared as static\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 20)\n" + 
		"	public void bar6(int i) {\n" + 
		"	            ^^^^^^^^^^^\n" + 
		"The method bar6(int) from the type X can potentially be declared as static\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 29)\n" + 
		"	public void bar9(int i) {\n" + 
		"	            ^^^^^^^^^^^\n" + 
		"The method bar9(int) from the type X can potentially be declared as static\n" + 
		"----------\n" + 
		"4. ERROR in X.java (at line 38)\n" + 
		"	public void bar12(int i) {\n" + 
		"	            ^^^^^^^^^^^^\n" + 
		"The method bar12(int) 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=318682
// Referring a field in different ways, accessing non-static field.
public void test117b() {
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBeStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportNonStaticAccessToStatic, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X extends B{\n" +
			"	public static int field1;\n" +
			"	public static X xfield;\n" +
			"	public void bar1(int i) {\n" + 
			"		field1 = 1;\n" +
			"	}\n" +
			"	public void bar2(int i) {\n" + 
			"		this.field1 = 1;\n" +
			"	}\n" +
			"	public void bar3(int i) {\n" + 
			"		System.out.println(field1);\n" +
			"	}\n" +
			"	public void bar4(int i) {\n" + 
			"		System.out.println(this.field1);\n" +
			"	}\n" +
			"	public void bar5(int i) {\n" + 
			"		X x = new X();\n" +
			"		x.field1 = 1;\n" +
			"	}\n" +
			"	public void bar6(int i) {\n" + 
			"		A.xA.field1 = 1;\n" +
			"	}\n" +
			"	public void bar7(int i) {\n" + 
			"		b1 = 1;\n" +
			"	}\n" +
			"	public void bar8(int i) {\n" + 
			"		this.b1 = 1;\n" +
			"	}\n" +
			"	public void bar9(int i) {\n" + 
			"		new X().b1 = 1;\n" +
			"	}\n" +
			"	public void bar10(int i) {\n" + 
			"		this.xfield.field1 = 1;\n" +
			"	}\n" +
			"	public void bar11(int i) {\n" + 
			"		System.out.println(this.xfield.field1);\n" +
			"	}\n" +
			"	public void bar12(int i) {\n" + 
			"		System.out.println(new X().b1);\n" +
			"	}\n" +
			"	public void bar13(int i) {\n" + 
			"		System.out.println(b1);\n" +
			"	}\n" +
			"	public void bar14(int i) {\n" + 
			"		System.out.println(this.b1);\n" +
			"	}\n" +
			"	public void bar15(int i) {\n" + 
			"		xfield.field1 = 1;\n" +
			"	}\n" +
			"	public void bar16(int i) {\n" + 
			"		System.out.println(xfield.field1);\n" +
			"	}\n" +
			"	public void baz() {\n" +
			"	}\n" + 
			"}\n" +
			"class A{\n" +
			"	public static X xA;\n" +
			"}\n" +
			"class B{\n" +
			"	public static int b1;\n" +
			"}",
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	public void bar1(int i) {\n" + 
		"	            ^^^^^^^^^^^\n" + 
		"The method bar1(int) from the type X can potentially be declared as static\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 10)\n" + 
		"	public void bar3(int i) {\n" + 
		"	            ^^^^^^^^^^^\n" + 
		"The method bar3(int) from the type X can potentially be declared as static\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 16)\n" + 
		"	public void bar5(int i) {\n" + 
		"	            ^^^^^^^^^^^\n" + 
		"The method bar5(int) from the type X can potentially be declared as static\n" + 
		"----------\n" + 
		"4. ERROR in X.java (at line 20)\n" + 
		"	public void bar6(int i) {\n" + 
		"	            ^^^^^^^^^^^\n" + 
		"The method bar6(int) from the type X can potentially be declared as static\n" + 
		"----------\n" + 
		"5. ERROR in X.java (at line 23)\n" + 
		"	public void bar7(int i) {\n" + 
		"	            ^^^^^^^^^^^\n" + 
		"The method bar7(int) from the type X can potentially be declared as static\n" + 
		"----------\n" + 
		"6. ERROR in X.java (at line 29)\n" + 
		"	public void bar9(int i) {\n" + 
		"	            ^^^^^^^^^^^\n" + 
		"The method bar9(int) from the type X can potentially be declared as static\n" + 
		"----------\n" + 
		"7. ERROR in X.java (at line 38)\n" + 
		"	public void bar12(int i) {\n" + 
		"	            ^^^^^^^^^^^^\n" + 
		"The method bar12(int) from the type X can potentially be declared as static\n" + 
		"----------\n" + 
		"8. ERROR in X.java (at line 41)\n" + 
		"	public void bar13(int i) {\n" + 
		"	            ^^^^^^^^^^^^\n" + 
		"The method bar13(int) from the type X can potentially be declared as static\n" + 
		"----------\n" + 
		"9. ERROR in X.java (at line 47)\n" + 
		"	public void bar15(int i) {\n" + 
		"	            ^^^^^^^^^^^^\n" + 
		"The method bar15(int) from the type X can potentially be declared as static\n" + 
		"----------\n" + 
		"10. ERROR in X.java (at line 50)\n" + 
		"	public void bar16(int i) {\n" + 
		"	            ^^^^^^^^^^^^\n" + 
		"The method bar16(int) 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=318682
// Final class -> can be static (and not potentially be static) warning shown
public void test118() {
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBeStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, CompilerOptions.ERROR);
	this.runNegativeTest(
		new String[] {
				"X.java", 
				"final public class X {\n" +
				"	public static int field1;\n" +
				"	public static int field2;\n" + 
				"	public void bar(int i) {\n" + 
				"		System.out.println(foo());\n" +
				"		foo();" +
				"		System.out.println(X.field1);\n" +
				"		System.out.println(field2);\n" +
				"		field2 = 1;\n" +
				"	}\n" +
				"	public static int foo(){ return 1;}\n" + 
				"}"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	public void bar(int i) {\n" + 
		"	            ^^^^^^^^^^\n" + 
		"The method bar(int) from the type X can 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=318682
// Method of a local class -> can't be static, so no warning
// Also method with such a local class accessing a member of the outer class can't be static
public void test119() {
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBeStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, CompilerOptions.ERROR);
	this.runNegativeTest(
		new String[] {
				"X.java", 
				"public class X {\n" +
					"	public static int field1;\n" +
					"	public int field2;\n" + 
					"	public void bar(int i) {\n" + 	// don't warn
					"		(new Object() {\n" +
					"			public boolean foo1() {\n" +	// don't warn for foo1
					"				return X.this.field2 == 1;\n" +
					"			}\n" +
					"		}).foo1();\n" +
					"	System.out.println(X.field1);\n" +
					"	}\n" + 
					"	public void bar2(int i) {\n" + 	// warn
					"		(new Object() {\n" +
					"			public boolean foo1() {\n" +	// don't warn for foo1
					"				System.out.println(X.field1);\n" +
					"				return true;" +
					"			}\n" +
					"		}).foo1();\n" +
					"	System.out.println(X.field1);\n" +
					"	}\n" + 
					"}"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 12)\n" + 
		"	public void bar2(int i) {\n" + 
		"	            ^^^^^^^^^^^\n" + 
		"The method bar2(int) 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=318682
// Method using type parameters declared by enclosing class can't be static, so don't warn
public void test120() {
	if (this.complianceLevel < ClassFileConstants.JDK1_5)
		return;
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBeStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, CompilerOptions.ERROR);
	this.runNegativeTest(
		new String[] {
				"X.java", 
				"public class X<T> {\n" +
				"	public static int field1;\n" +
				"	public int field2;\n" + 
				"	public void bar(T t) {\n" + 	// don't warn
				"		X.field1 = 1;\n" +
				"		System.out.println(t);\n" +
				"	}\n" + 
				"	public <E> void bar2(E e) {\n" + 	// warn
				"		X.field1 = 1;\n" +
				"		System.out.println(e);\n" +
				"	}\n" +
				"	public <E> void bar3() {\n" + 	// don't warn
				"		T a;\n" +
				"		System.out.println();\n" +
				"	}\n" + 
				"}"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 8)\n" + 
		"	public <E> void bar2(E e) {\n" + 
		"	                ^^^^^^^^^\n" + 
		"The method bar2(E) 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=318682
// Access to super in a method disqualifies it from being static
public void test121() {
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBeStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportNonStaticAccessToStatic, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
				"X.java", 
				"public class X extends A{\n" +
				"	public static int field1;\n" +
				"	public int field2;\n" + 
				"	public void methodA() {\n" + 	// don't warn
				"		super.methodA();\n" +
				"	}\n" + 
				"	public void bar() {\n" + 	// don't warn
				"		super.fieldA = 1;\n" +
				"	}\n" +
				"	public void bar2() {\n" + 	// don't warn
				"		System.out.println(super.fieldA);\n" +
				"	}\n" +
				"	public void bar3() {\n" + 	// warn
				"		System.out.println(X.fieldA);\n" +
				"	}\n" +
				"}\n" +
				"class A{\n" +
				"	public static int fieldA;\n" +
				"   public void methodA(){\n" +
				"   }\n" +
				"}"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 13)\n" + 
		"	public void bar3() {\n" + 
		"	            ^^^^^^\n" + 
		"The method bar3() 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=318682
// Methods of non-static member types can't be static
public void test122() {
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBeStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, CompilerOptions.ERROR);
	compilerOptions.put(CompilerOptions.OPTION_ReportNonStaticAccessToStatic, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
				"X.java", 
				"public class X {\n" +
				"	class A{\n" +
				"   	void methodA() {\n" +	// don't warn
				"			System.out.println();\n" +
				"		}\n" +
				"   }\n" +
				"	static class B{\n" +
				"   	void methodB() {\n" +	// warn
				"			System.out.println();\n" +
				"		}\n" +
				"   }\n" +
				"}"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 8)\n" + 
		"	void methodB() {\n" + 
		"	     ^^^^^^^^^\n" + 
		"The method methodB() from the type X.B can potentially be declared as static\n" + 
		"----------\n",
		null /* no extra class libraries */,
		true /* flush output directory */,
		compilerOptions /* custom options */
	);
}
}

Return to bug 318682

Lines 267-272 Link Here

(-)batch/org/eclipse/jdt/internal/compiler/batch/messages.properties (+2 lines)
267	\ allDeprecation deprecation including inside deprecated code\n\	267	\ allDeprecation deprecation including inside deprecated code\n\
268	\ allJavadoc invalid or missing javadoc\n\	268	\ allJavadoc invalid or missing javadoc\n\
269	\ allOver-ann all missing @Override annotations\n\	269	\ allOver-ann all missing @Override annotations\n\
		270	\ all-static-method all method can be declared as static warnings\n\
270	\ assertIdentifier + ''assert'' used as identifier\n\	271	\ assertIdentifier + ''assert'' used as identifier\n\
271	\ boxing autoboxing conversion\n\	272	\ boxing autoboxing conversion\n\
272	\ charConcat + char[] in String concat\n\	273	\ charConcat + char[] in String concat\n\
Lines 309-314 Link Here
309	\ semicolon unnecessary semicolon, empty statement\n\	310	\ semicolon unnecessary semicolon, empty statement\n\
310	\ serial + missing serialVersionUID\n\	311	\ serial + missing serialVersionUID\n\
311	\ specialParamHiding constructor or setter parameter hiding a field\n\	312	\ specialParamHiding constructor or setter parameter hiding a field\n\
		313	\ static-method method can be declared as static\n\
312	\ static-access macro for indirectStatic and staticReceiver\n\	314	\ static-access macro for indirectStatic and staticReceiver\n\
313	\ staticReceiver + non-static reference to static member\n\	315	\ staticReceiver + non-static reference to static member\n\
314	\ super overriding a method without making a super invocation\n\	316	\ super overriding a method without making a super invocation\n\

Lines 39-44 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/LocalDeclaration.java (+27 lines)
39	if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) == 0) {	39	if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) == 0) {
40	this.bits \|= ASTNode.IsLocalDeclarationReachable; // only set if actually reached	40	this.bits \|= ASTNode.IsLocalDeclarationReachable; // only set if actually reached
41	}	41	}
		42	if (this.binding != null && this.type.resolvedType instanceof TypeVariableBinding) {
		43	MethodScope methodScope= this.binding.declaringScope.methodScope();
		44	AbstractMethodDeclaration methodDeclaration = methodScope.referenceMethod();
		45	if (methodDeclaration != null && methodDeclaration.binding != null) {
		46	TypeVariableBinding[] typeVariables = methodDeclaration.binding.typeVariables();
		47	if (typeVariables == Binding.NO_TYPE_VARIABLES) {
		48	// Method declares no type variables.
		49	currentScope.resetEnclosingMethodStaticFlag();
		50	} else {
		51	for (int i = 0; i < typeVariables.length ; i ++) {
		52	if (typeVariables[i] != this.type.resolvedType){
		53	// uses a type variable not declared by enclosing method
		54	currentScope.resetEnclosingMethodStaticFlag();
		55	break;
		56	}
		57	}
		58	}
		59	}
		60	}
		61	// if (this.type.resolvedType instanceof TypeVariableBinding) {
		62	// Binding declaringElement = ((TypeVariableBinding)this.type.resolvedType).declaringElement;
		63	// if (this.binding != null && this.binding.declaringScope != null) {
		64	// ClassScope enclosingClassScope = this.binding.declaringScope.enclosingClassScope();
		65	// if (enclosingClassScope != null && enclosingClassScope.referenceContext != null && enclosingClassScope.referenceContext.binding == declaringElement)
		66	// currentScope.resetEnclosingMethodStaticFlag();
		67	// }
		68	// }
42	if (this.initialization == null) {	69	if (this.initialization == null) {
43	return flowInfo;	70	return flowInfo;
44	}	71	}

Lines 61-66 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/MessageSend.java (+10 lines)
61	flowInfo = this.receiver.analyseCode(currentScope, flowContext, flowInfo, nonStatic).unconditionalInits();	61	flowInfo = this.receiver.analyseCode(currentScope, flowContext, flowInfo, nonStatic).unconditionalInits();
62	if (nonStatic) {	62	if (nonStatic) {
63	this.receiver.checkNPE(currentScope, flowContext, flowInfo);	63	this.receiver.checkNPE(currentScope, flowContext, flowInfo);
		64	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=318682
		65	if (this.receiver.isThis()) {
		66	// accessing non-static method without an object
		67	currentScope.resetEnclosingMethodStaticFlag();
		68	}
		69	} else if (this.receiver.isThis()) {
		70	if ((this.receiver.bits & ASTNode.IsImplicitThis) == 0) {
		71	// explicit this receiver, not allowed in static context
		72	currentScope.resetEnclosingMethodStaticFlag();
		73	}
64	}	74	}
65		75
66	if (this.arguments != null) {	76	if (this.arguments != null) {

Lines 51-56 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/impl/IrritantSet.java (+3 lines)
51	public static final IrritantSet RESTRICTION = new IrritantSet(CompilerOptions.ForbiddenReference);	51	public static final IrritantSet RESTRICTION = new IrritantSet(CompilerOptions.ForbiddenReference);
52	public static final IrritantSet SERIAL = new IrritantSet(CompilerOptions.MissingSerialVersion);	52	public static final IrritantSet SERIAL = new IrritantSet(CompilerOptions.MissingSerialVersion);
53	public static final IrritantSet STATIC_ACCESS = new IrritantSet(CompilerOptions.IndirectStaticAccess);	53	public static final IrritantSet STATIC_ACCESS = new IrritantSet(CompilerOptions.IndirectStaticAccess);
		54	public static final IrritantSet STATIC_METHOD = new IrritantSet(CompilerOptions.MethodCanBeStatic);
54	public static final IrritantSet SYNTHETIC_ACCESS = new IrritantSet(CompilerOptions.AccessEmulation);	55	public static final IrritantSet SYNTHETIC_ACCESS = new IrritantSet(CompilerOptions.AccessEmulation);
55	public static final IrritantSet SUPER = new IrritantSet(CompilerOptions.OverridingMethodWithoutSuperInvocation);	56	public static final IrritantSet SUPER = new IrritantSet(CompilerOptions.OverridingMethodWithoutSuperInvocation);
56	public static final IrritantSet UNUSED = new IrritantSet(CompilerOptions.UnusedLocalVariable);	57	public static final IrritantSet UNUSED = new IrritantSet(CompilerOptions.UnusedLocalVariable);
Lines 119-124 Link Here
119	.set(CompilerOptions.RedundantSuperinterface)	120	.set(CompilerOptions.RedundantSuperinterface)
120	.set(CompilerOptions.DeadCode)	121	.set(CompilerOptions.DeadCode)
121	.set(CompilerOptions.UnusedObjectAllocation);	122	.set(CompilerOptions.UnusedObjectAllocation);
		123	STATIC_METHOD
		124	.set(CompilerOptions.MethodCanBePotentiallyStatic);
122	String suppressRawWhenUnchecked = System.getProperty("suppressRawWhenUnchecked"); //$NON-NLS-1$	125	String suppressRawWhenUnchecked = System.getProperty("suppressRawWhenUnchecked"); //$NON-NLS-1$
123	if (suppressRawWhenUnchecked != null && "true".equalsIgnoreCase(suppressRawWhenUnchecked)) { //$NON-NLS-1$	126	if (suppressRawWhenUnchecked != null && "true".equalsIgnoreCase(suppressRawWhenUnchecked)) { //$NON-NLS-1$
124	UNCHECKED.set(CompilerOptions.RawTypeReference);	127	UNCHECKED.set(CompilerOptions.RawTypeReference);

Lines 941-944 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/BlockScope.java (+14 lines)
941	s += ((BlockScope) this.subscopes[i]).toString(tab + 1) + "\n"; //$NON-NLS-1$	941	s += ((BlockScope) this.subscopes[i]).toString(tab + 1) + "\n"; //$NON-NLS-1$
942	return s;	942	return s;
943	}	943	}
		944	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=318682
		945	public void resetEnclosingMethodStaticFlag() {
		946	MethodScope methodScope = methodScope();
		947	while (methodScope != null && methodScope.referenceContext instanceof MethodDeclaration) {
		948	MethodDeclaration methodDeclaration= (MethodDeclaration) methodScope.referenceContext;
		949	methodDeclaration.bits &= ~ASTNode.CanBeStatic;
		950	ClassScope enclosingClassScope = methodScope.enclosingClassScope();
		951	if (enclosingClassScope != null) {
		952	methodScope = enclosingClassScope.methodScope();
		953	} else {
		954	break;
		955	}
		956	}
		957	}
944	}	958	}