### Eclipse Workspace Patch 1.0 #P org.eclipse.jdt.core Index: batch/org/eclipse/jdt/internal/compiler/batch/Main.java =================================================================== RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/Main.java,v retrieving revision 1.356 diff -u -r1.356 Main.java --- batch/org/eclipse/jdt/internal/compiler/batch/Main.java 26 Oct 2010 17:24:15 -0000 1.356 +++ batch/org/eclipse/jdt/internal/compiler/batch/Main.java 1 Dec 2010 12:38:31 -0000 @@ -3228,6 +3228,10 @@ CompilerOptions.OPTION_ReportMissingOverrideAnnotationForInterfaceMethodImplementation, isEnabling ? CompilerOptions.ENABLED : CompilerOptions.DISABLED); return; + } else if (token.equals("all-static-method")) { //$NON-NLS-1$ + setSeverity(CompilerOptions.OPTION_ReportMethodCanBeStatic, severity, isEnabling); + setSeverity(CompilerOptions.OPTION_ReportMethodCanBePotentiallyStatic, severity, isEnabling); + return; } break; case 'b' : @@ -3459,6 +3463,9 @@ } else if (token.equals("super")) { //$NON-NLS-1$ setSeverity(CompilerOptions.OPTION_ReportOverridingMethodWithoutSuperInvocation, severity, isEnabling); return; + } else if (token.equals("static-method")) { //$NON-NLS-1$ + setSeverity(CompilerOptions.OPTION_ReportMethodCanBeStatic, severity, isEnabling); + return; } break; case 't' : Index: batch/org/eclipse/jdt/internal/compiler/batch/messages.properties =================================================================== RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/messages.properties,v retrieving revision 1.943 diff -u -r1.943 messages.properties --- batch/org/eclipse/jdt/internal/compiler/batch/messages.properties 30 Nov 2010 15:06:55 -0000 1.943 +++ batch/org/eclipse/jdt/internal/compiler/batch/messages.properties 1 Dec 2010 12:38:32 -0000 @@ -267,6 +267,7 @@ \ allDeprecation deprecation including inside deprecated code\n\ \ allJavadoc invalid or missing javadoc\n\ \ allOver-ann all missing @Override annotations\n\ +\ all-static-method all method can be declared as static warnings\n\ \ assertIdentifier + ''assert'' used as identifier\n\ \ boxing autoboxing conversion\n\ \ charConcat + char[] in String concat\n\ @@ -309,6 +310,7 @@ \ semicolon unnecessary semicolon, empty statement\n\ \ serial + missing serialVersionUID\n\ \ specialParamHiding constructor or setter parameter hiding a field\n\ +\ static-method method can be declared as static\n\ \ static-access macro for indirectStatic and staticReceiver\n\ \ staticReceiver + non-static reference to static member\n\ \ super overriding a method without making a super invocation\n\ Index: compiler/org/eclipse/jdt/core/compiler/IProblem.java =================================================================== RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/core/compiler/IProblem.java,v retrieving revision 1.222 diff -u -r1.222 IProblem.java --- compiler/org/eclipse/jdt/core/compiler/IProblem.java 7 Sep 2010 13:39:18 -0000 1.222 +++ compiler/org/eclipse/jdt/core/compiler/IProblem.java 1 Dec 2010 12:38:32 -0000 @@ -401,6 +401,10 @@ int IndirectAccessToStaticMethod = Internal + MethodRelated + 119; /** @since 3.4 */ int MissingTypeInMethod = MethodRelated + 120; + /** @since 3.7 */ + int MethodCanBeStatic = Internal + MethodRelated + 121; + /** @since 3.7 */ + int MethodCanBePotentiallyStatic = Internal + MethodRelated + 122; // constructors /** @since 3.4 */ Index: compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java =================================================================== RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java,v retrieving revision 1.104 diff -u -r1.104 ASTNode.java --- compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java 22 Oct 2010 22:42:55 -0000 1.104 +++ compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java 1 Dec 2010 12:38:32 -0000 @@ -169,6 +169,7 @@ // for block and method declaration public static final int UndocumentedEmptyBlock = Bit4; public static final int OverridingMethodWithSupercall = Bit5; + public static final int CanBeStatic = Bit6; // used to flag a method that can be declared static // for initializer and method declaration public static final int ErrorInSignature = Bit6; Index: compiler/org/eclipse/jdt/internal/compiler/ast/LocalDeclaration.java =================================================================== RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/LocalDeclaration.java,v retrieving revision 1.74 diff -u -r1.74 LocalDeclaration.java --- compiler/org/eclipse/jdt/internal/compiler/ast/LocalDeclaration.java 9 Sep 2010 17:36:21 -0000 1.74 +++ compiler/org/eclipse/jdt/internal/compiler/ast/LocalDeclaration.java 1 Dec 2010 12:38:32 -0000 @@ -39,6 +39,33 @@ 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; } Index: compiler/org/eclipse/jdt/internal/compiler/ast/MessageSend.java =================================================================== RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/MessageSend.java,v retrieving revision 1.148 diff -u -r1.148 MessageSend.java --- compiler/org/eclipse/jdt/internal/compiler/ast/MessageSend.java 12 Aug 2010 16:58:28 -0000 1.148 +++ compiler/org/eclipse/jdt/internal/compiler/ast/MessageSend.java 1 Dec 2010 12:38:32 -0000 @@ -61,6 +61,16 @@ 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) { Index: compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedNameReference.java =================================================================== RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedNameReference.java,v retrieving revision 1.148 diff -u -r1.148 QualifiedNameReference.java --- compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedNameReference.java 22 Oct 2010 22:42:55 -0000 1.148 +++ compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedNameReference.java 1 Dec 2010 12:38:32 -0000 @@ -81,6 +81,9 @@ currentScope.problemReporter().uninitializedBlankFinalField(lastFieldBinding, this); } } + if (!lastFieldBinding.isStatic()) { + currentScope.resetEnclosingMethodStaticFlag(); + } break; case Binding.LOCAL : // first binding is a local variable @@ -176,8 +179,8 @@ if (needValue || complyTo14) { manageSyntheticAccessIfNecessary(currentScope, (FieldBinding) this.binding, 0, flowInfo); } + FieldBinding fieldBinding = (FieldBinding) this.binding; if (this.indexOfFirstFieldBinding == 1) { // was an implicit reference to the first field binding - FieldBinding fieldBinding = (FieldBinding) this.binding; // check if reading a final blank field if (fieldBinding.isBlankFinal() && currentScope.needBlankFinalFieldInitializationCheck(fieldBinding)) { @@ -187,6 +190,9 @@ } } } + if (!fieldBinding.isStatic()) { + currentScope.resetEnclosingMethodStaticFlag(); + } break; case Binding.LOCAL : // reading a local variable LocalVariableBinding localBinding; Index: compiler/org/eclipse/jdt/internal/compiler/ast/SuperReference.java =================================================================== RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/SuperReference.java,v retrieving revision 1.31 diff -u -r1.31 SuperReference.java --- compiler/org/eclipse/jdt/internal/compiler/ast/SuperReference.java 7 Mar 2009 01:08:07 -0000 1.31 +++ compiler/org/eclipse/jdt/internal/compiler/ast/SuperReference.java 1 Dec 2010 12:38:32 -0000 @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright (c) 2000, 2009 IBM Corporation and others. + * Copyright (c) 2000, 2010 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 @@ -11,6 +11,8 @@ package org.eclipse.jdt.internal.compiler.ast; import org.eclipse.jdt.internal.compiler.ASTVisitor; +import org.eclipse.jdt.internal.compiler.flow.FlowContext; +import org.eclipse.jdt.internal.compiler.flow.FlowInfo; import org.eclipse.jdt.internal.compiler.impl.Constant; import org.eclipse.jdt.internal.compiler.lookup.BlockScope; import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding; @@ -66,4 +68,9 @@ visitor.visit(this, blockScope); visitor.endVisit(this, blockScope); } + + public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) { + currentScope.resetEnclosingMethodStaticFlag(); + return analyseCode(currentScope, flowContext, flowInfo); + } } Index: compiler/org/eclipse/jdt/internal/compiler/impl/CompilerOptions.java =================================================================== RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/impl/CompilerOptions.java,v retrieving revision 1.235 diff -u -r1.235 CompilerOptions.java --- compiler/org/eclipse/jdt/internal/compiler/impl/CompilerOptions.java 21 Oct 2010 19:59:58 -0000 1.235 +++ compiler/org/eclipse/jdt/internal/compiler/impl/CompilerOptions.java 1 Dec 2010 12:38:32 -0000 @@ -133,6 +133,8 @@ public static final String OPTION_ReportTasks = "org.eclipse.jdt.core.compiler.problem.tasks"; //$NON-NLS-1$ public static final String OPTION_ReportUnusedObjectAllocation = "org.eclipse.jdt.core.compiler.problem.unusedObjectAllocation"; //$NON-NLS-1$ public static final String OPTION_IncludeNullInfoFromAsserts = "org.eclipse.jdt.core.compiler.problem.includeNullInfoFromAsserts"; //$NON-NLS-1$ + public static final String OPTION_ReportMethodCanBeStatic = "org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic"; //$NON-NLS-1$ + public static final String OPTION_ReportMethodCanBePotentiallyStatic = "org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic"; //$NON-NLS-1$ // Backward compatibility public static final String OPTION_ReportInvalidAnnotation = "org.eclipse.jdt.core.compiler.problem.invalidAnnotation"; //$NON-NLS-1$ public static final String OPTION_ReportMissingAnnotation = "org.eclipse.jdt.core.compiler.problem.missingAnnotation"; //$NON-NLS-1$ @@ -238,6 +240,8 @@ public static final int DeadCode = IrritantSet.GROUP2 | ASTNode.Bit2; public static final int Tasks = IrritantSet.GROUP2 | ASTNode.Bit3; public static final int UnusedObjectAllocation = IrritantSet.GROUP2 | ASTNode.Bit4; + public static final int MethodCanBeStatic = IrritantSet.GROUP2 | ASTNode.Bit5; + public static final int MethodCanBePotentiallyStatic = IrritantSet.GROUP2 | ASTNode.Bit6; // Severity level for handlers /** @@ -375,6 +379,7 @@ "rawtypes", //$NON-NLS-1$ "serial", //$NON-NLS-1$ "static-access", //$NON-NLS-1$ + "static-method", //$NON-NLS-1$ "super", //$NON-NLS-1$ "synthetic-access", //$NON-NLS-1$ "unchecked", //$NON-NLS-1$ @@ -539,6 +544,10 @@ return OPTION_ReportDeadCode; case UnusedObjectAllocation: return OPTION_ReportUnusedObjectAllocation; + case MethodCanBeStatic : + return OPTION_ReportMethodCanBeStatic; + case MethodCanBePotentiallyStatic : + return OPTION_ReportMethodCanBePotentiallyStatic; } return null; } @@ -638,6 +647,8 @@ OPTION_ReportInvalidJavadoc, OPTION_ReportLocalVariableHiding, OPTION_ReportMethodWithConstructorName, + OPTION_ReportMethodCanBeStatic, + OPTION_ReportMethodCanBePotentiallyStatic, OPTION_ReportMissingDeprecatedAnnotation, OPTION_ReportMissingJavadocComments, OPTION_ReportMissingJavadocTagDescription, @@ -739,6 +750,9 @@ return "fallthrough"; //$NON-NLS-1$ case OverridingMethodWithoutSuperInvocation : return "super"; //$NON-NLS-1$ + case MethodCanBeStatic : + case MethodCanBePotentiallyStatic : + return "static-method"; //$NON-NLS-1$ } return null; } @@ -796,6 +810,8 @@ return IrritantSet.SERIAL; if ("static-access".equals(warningToken)) //$NON-NLS-1$ return IrritantSet.STATIC_ACCESS; + if ("static-method".equals(warningToken)) //$NON-NLS-1$ + return IrritantSet.STATIC_METHOD; if ("synthetic-access".equals(warningToken)) //$NON-NLS-1$ return IrritantSet.SYNTHETIC_ACCESS; if ("super".equals(warningToken)) { //$NON-NLS-1$ @@ -921,6 +937,8 @@ optionsMap.put(OPTION_ReportTasks, getSeverityString(Tasks)); optionsMap.put(OPTION_ReportUnusedObjectAllocation, getSeverityString(UnusedObjectAllocation)); optionsMap.put(OPTION_IncludeNullInfoFromAsserts, this.includeNullInfoFromAsserts ? ENABLED : DISABLED); + optionsMap.put(OPTION_ReportMethodCanBeStatic, getSeverityString(MethodCanBeStatic)); + optionsMap.put(OPTION_ReportMethodCanBePotentiallyStatic, getSeverityString(MethodCanBePotentiallyStatic)); return optionsMap; } @@ -1339,6 +1357,8 @@ if ((optionValue = optionsMap.get(OPTION_ReportDeadCode)) != null) updateSeverity(DeadCode, optionValue); if ((optionValue = optionsMap.get(OPTION_ReportTasks)) != null) updateSeverity(Tasks, optionValue); if ((optionValue = optionsMap.get(OPTION_ReportUnusedObjectAllocation)) != null) updateSeverity(UnusedObjectAllocation, optionValue); + if ((optionValue = optionsMap.get(OPTION_ReportMethodCanBeStatic)) != null) updateSeverity(MethodCanBeStatic, optionValue); + if ((optionValue = optionsMap.get(OPTION_ReportMethodCanBePotentiallyStatic)) != null) updateSeverity(MethodCanBePotentiallyStatic, optionValue); // Javadoc options if ((optionValue = optionsMap.get(OPTION_DocCommentSupport)) != null) { @@ -1551,6 +1571,8 @@ buf.append("\n\t- dead code in trivial if statement: ").append(this.reportDeadCodeInTrivialIfStatement ? ENABLED : DISABLED); //$NON-NLS-1$ buf.append("\n\t- tasks severity: ").append(getSeverityString(Tasks)); //$NON-NLS-1$ buf.append("\n\t- unused object allocation: ").append(getSeverityString(UnusedObjectAllocation)); //$NON-NLS-1$ + buf.append("\n\t- method can be static: ").append(getSeverityString(MethodCanBeStatic)); //$NON-NLS-1$ + buf.append("\n\t- method can be potentially static: ").append(getSeverityString(MethodCanBePotentiallyStatic)); //$NON-NLS-1$ return buf.toString(); } Index: compiler/org/eclipse/jdt/internal/compiler/impl/IrritantSet.java =================================================================== RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/impl/IrritantSet.java,v retrieving revision 1.10 diff -u -r1.10 IrritantSet.java --- compiler/org/eclipse/jdt/internal/compiler/impl/IrritantSet.java 18 May 2010 18:12:12 -0000 1.10 +++ compiler/org/eclipse/jdt/internal/compiler/impl/IrritantSet.java 1 Dec 2010 12:38:32 -0000 @@ -51,6 +51,7 @@ public static final IrritantSet RESTRICTION = new IrritantSet(CompilerOptions.ForbiddenReference); public static final IrritantSet SERIAL = new IrritantSet(CompilerOptions.MissingSerialVersion); public static final IrritantSet STATIC_ACCESS = new IrritantSet(CompilerOptions.IndirectStaticAccess); + public static final IrritantSet STATIC_METHOD = new IrritantSet(CompilerOptions.MethodCanBeStatic); public static final IrritantSet SYNTHETIC_ACCESS = new IrritantSet(CompilerOptions.AccessEmulation); public static final IrritantSet SUPER = new IrritantSet(CompilerOptions.OverridingMethodWithoutSuperInvocation); public static final IrritantSet UNUSED = new IrritantSet(CompilerOptions.UnusedLocalVariable); @@ -119,6 +120,8 @@ .set(CompilerOptions.RedundantSuperinterface) .set(CompilerOptions.DeadCode) .set(CompilerOptions.UnusedObjectAllocation); + STATIC_METHOD + .set(CompilerOptions.MethodCanBePotentiallyStatic); String suppressRawWhenUnchecked = System.getProperty("suppressRawWhenUnchecked"); //$NON-NLS-1$ if (suppressRawWhenUnchecked != null && "true".equalsIgnoreCase(suppressRawWhenUnchecked)) { //$NON-NLS-1$ UNCHECKED.set(CompilerOptions.RawTypeReference); Index: compiler/org/eclipse/jdt/internal/compiler/lookup/BlockScope.java =================================================================== RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/BlockScope.java,v retrieving revision 1.122 diff -u -r1.122 BlockScope.java --- compiler/org/eclipse/jdt/internal/compiler/lookup/BlockScope.java 9 Nov 2010 19:59:19 -0000 1.122 +++ compiler/org/eclipse/jdt/internal/compiler/lookup/BlockScope.java 1 Dec 2010 12:38:34 -0000 @@ -941,4 +941,18 @@ 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; + } + } +} } Index: compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties =================================================================== RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties,v retrieving revision 1.259 diff -u -r1.259 messages.properties --- compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties 22 Oct 2010 22:42:56 -0000 1.259 +++ compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties 1 Dec 2010 12:38:34 -0000 @@ -103,6 +103,8 @@ 118 = The method {1}({2}) from the type {0} is never used locally 119 = The static method {1}({2}) from the type {0} should be accessed directly 120 = The method {1}({2}) from the type {0} refers to the missing type {3} +121 = The method {1}({2}) from the type {0} can be declared as static +122 = The method {1}({2}) from the type {0} can potentially be declared as static 129 = The constructor {0}({1}) refers to the missing type {2} 130 = The constructor {0}({1}) is undefined #P org.eclipse.jdt.core.tests.compiler Index: src/org/eclipse/jdt/core/tests/compiler/regression/ProblemTypeAndMethodTest.java =================================================================== RCS file: /cvsroot/eclipse/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/ProblemTypeAndMethodTest.java,v retrieving revision 1.38 diff -u -r1.38 ProblemTypeAndMethodTest.java --- src/org/eclipse/jdt/core/tests/compiler/regression/ProblemTypeAndMethodTest.java 1 Nov 2010 14:15:07 -0000 1.38 +++ src/org/eclipse/jdt/core/tests/compiler/regression/ProblemTypeAndMethodTest.java 1 Dec 2010 12:38:38 -0000 @@ -30,7 +30,7 @@ // 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[] { "test127" }; +// TESTS_NAMES = new String[] { "test120" }; // TESTS_NUMBERS = new int[] { 113 }; // TESTS_RANGE = new int[] { 108, -1 }; } @@ -5892,4 +5892,703 @@ 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 {\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 void bar2(E e) {\n" + // warn + " X.field1 = 1;\n" + + " System.out.println(e);\n" + + " }\n" + + " public 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 void bar2(E e) {\n" + + " ^^^^^^^^^\n" + + "The method bar2(E) 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 +// 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 */ + ); +} }