Attachment #191941 for bug #322494




	public static final String VARIABLE_DECLARATION_USE_TYPE_ARGUMENTS_FOR_RAW_TYPE_REFERENCES= "cleanup.use_arguments_for_raw_type_references"; //$NON-NLS-1$

	/**
	* Correct modifiers order for variable declarations.<br>
	* <br>
	* Possible values: {TRUE, FALSE}<br>
	*
	* <br>
	*
	* @see CleanUpOptions#TRUE
	* @see CleanUpOptions#FALSE
	* @since 3.7
	*/
	public static final String VARIABLE_DECLARATIONS_SORT_MODIFIERS= "cleanup.correct_variable_modifiers_order"; //$NON-NLS-1$
	
	/**
	 * Removes unused imports. <br>
	 * <br>
	 * Possible values: {TRUE, FALSE}<br>

		options.setOption(VARIABLE_DECLARATIONS_USE_FINAL_LOCAL_VARIABLES, CleanUpOptions.TRUE);
		options.setOption(VARIABLE_DECLARATIONS_USE_FINAL_PARAMETERS, CleanUpOptions.FALSE);
		options.setOption(VARIABLE_DECLARATIONS_USE_FINAL_PRIVATE_FIELDS, CleanUpOptions.TRUE);
		options.setOption(VARIABLE_DECLARATIONS_SORT_MODIFIERS, CleanUpOptions.FALSE);

		//Unused Code
		options.setOption(REMOVE_UNUSED_CODE_IMPORTS, CleanUpOptions.TRUE);

Lines 116-121 Link Here

(-)core extension/org/eclipse/jdt/internal/corext/fix/FixMessages.java (+1 lines)
116		116
117	public static String VariableDeclarationFix_changeModifierOfUnknownToFinal_description;	117	public static String VariableDeclarationFix_changeModifierOfUnknownToFinal_description;
118	public static String VariableDeclarationFix_ChangeMidifiersToFinalWherPossible_description;	118	public static String VariableDeclarationFix_ChangeMidifiersToFinalWherPossible_description;
		119	public static String VariableDeclarationFix_sortModifiers_description;
119		120
120	static {	121	static {
121	// initialize resource bundle	122	// initialize resource bundle

Lines 82-87 Link Here

(-)core extension/org/eclipse/jdt/internal/corext/fix/FixMessages.properties (+1 lines)
82	VariableDeclarationFix_changeModifierOfUnknownToFinal_description=Change modifier to final	82	VariableDeclarationFix_changeModifierOfUnknownToFinal_description=Change modifier to final
83	VariableDeclarationFix_add_final_change_name=Add final	83	VariableDeclarationFix_add_final_change_name=Add final
84	VariableDeclarationFix_ChangeMidifiersToFinalWherPossible_description=Change modifiers to final where possible	84	VariableDeclarationFix_ChangeMidifiersToFinalWherPossible_description=Change modifiers to final where possible
		85	VariableDeclarationFix_sortModifiers_description=Correct modifiers order
85		86
86	PotentialProgrammingProblemsFix_calculatingUIDFailed_unknown=Could not calculate a serial version id for {0}. The type will be ignored.	87	PotentialProgrammingProblemsFix_calculatingUIDFailed_unknown=Could not calculate a serial version id for {0}. The type will be ignored.
87	PotentialProgrammingProblemsFix_add_id_change_name=Add Serial Version ID	88	PotentialProgrammingProblemsFix_add_id_change_name=Add Serial Version ID




/*******************************************************************************
 * Copyright (c) 2000, 2011 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Chris West (Faux) <eclipse@goeswhere.com> - [clean up] "Use modifier 'final' where possible" can introduce compile errors - https://bugs.eclipse.org/bugs/show_bug.cgi?id=272532
 *******************************************************************************/
package org.eclipse.jdt.internal.corext.fix;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.text.edits.TextEditGroup;

import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.BodyDeclaration;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.IExtendedModifier;
import org.eclipse.jdt.core.dom.Modifier;
import org.eclipse.jdt.core.dom.Modifier.ModifierKeyword;
import org.eclipse.jdt.core.dom.SimpleName;
import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
import org.eclipse.jdt.core.dom.rewrite.ListRewrite;

import org.eclipse.jdt.internal.corext.dom.ASTNodeFactory;
import org.eclipse.jdt.internal.corext.dom.HierarchicalASTVisitor;
import org.eclipse.jdt.internal.corext.refactoring.structure.CompilationUnitRewrite;

import org.eclipse.jdt.ui.cleanup.ICleanUpFix;

public class SortModifiersFix extends CompilationUnitRewriteOperationsFix {

	private static class UnsortedModifiersNodeFinder extends HierarchicalASTVisitor {

		private final List<SortModifiersOperation> fOperations;

		public UnsortedModifiersNodeFinder(List<SortModifiersOperation> operations) {
			fOperations= operations;
		}

		/**
		 * {@inheritDoc}
		 */
		@Override
		public boolean visit(BodyDeclaration node) {
			int modifiers= node.getModifiers();
			if (modifiers != Modifier.NONE) {
				List<Modifier> newModifiers= ASTNodeFactory.newModifiers(node.getAST(), modifiers);
				List<Modifier> oldModifiers= node.modifiers();
				for (int o= 0, n= 0; o < oldModifiers.size(); o++) {
					IExtendedModifier modifier= oldModifiers.get(o);
					if (modifier.isAnnotation())
						continue;
					ModifierKeyword oldKeyword= ((Modifier) modifier).getKeyword();
					ModifierKeyword newKeyword= newModifiers.get(n++).getKeyword();
					if (oldKeyword != newKeyword) {
						fOperations.add(new SortModifiersOperation(node, newModifiers));
						break;
					}
				}
			}
			return super.visit(node);
		}
	}

	private static class SortModifiersOperation extends CompilationUnitRewriteOperation {

		private final BodyDeclaration fWithModifiersNode;
		private final List<Modifier> fNewModifiers;

		public SortModifiersOperation(BodyDeclaration withModifiersNode, List<Modifier> newModifiers) {
			fWithModifiersNode= withModifiersNode;
			fNewModifiers= newModifiers;
		}

		/**
		 * {@inheritDoc}
		 */
		@Override
		public void rewriteAST(CompilationUnitRewrite cuRewrite, LinkedProposalModel model) throws CoreException {
			ASTRewrite rewrite= cuRewrite.getASTRewrite();
			TextEditGroup group= createTextEditGroup(FixMessages.VariableDeclarationFix_sortModifiers_description, cuRewrite);
			
			List<IExtendedModifier> oldModifiers= fWithModifiersNode.modifiers();
			for (int i= 0; i < oldModifiers.size(); i++) {
				Object modifier= oldModifiers.get(i);
				if (modifier instanceof Modifier) {
					rewrite.remove((Modifier) modifier, group);
				}
			}
			
			ListRewrite listRewrite= rewrite.getListRewrite(fWithModifiersNode, fWithModifiersNode.getModifiersProperty());
			for (int i= 0; i < fNewModifiers.size(); i++) {
				Modifier curr= fNewModifiers.get(i);
				listRewrite.insertLast(curr, group);
			}
		}
	}

	public static SortModifiersFix createFix(final CompilationUnit compilationUnit, ASTNode[] selectedNodes) {
		List<SortModifiersOperation> operations= new ArrayList<SortModifiersOperation>();
		UnsortedModifiersNodeFinder visitor= new UnsortedModifiersNodeFinder(operations);
		compilationUnit.accept(visitor);
		if (selectedNodes.length == 1) {
			if (selectedNodes[0] instanceof SimpleName) {
				selectedNodes[0]= selectedNodes[0].getParent();
			}
			selectedNodes[0].accept(visitor);
		} else {
			for (int i= 0; i < selectedNodes.length; i++) {
				ASTNode selectedNode= selectedNodes[i];
				selectedNode.accept(visitor);
			}
		}
		if (operations.size() == 0)
			return null;

		CompilationUnitRewriteOperation[] fixRewriteOperations= operations.toArray(new CompilationUnitRewriteOperation[operations.size()]);

		return new SortModifiersFix(FixMessages.VariableDeclarationFix_sortModifiers_description, compilationUnit, fixRewriteOperations);
	}

	public static ICleanUpFix createCleanUp(CompilationUnit compilationUnit) {
		List<SortModifiersOperation> operations= new ArrayList<SortModifiersOperation>();
		UnsortedModifiersNodeFinder finder= new UnsortedModifiersNodeFinder(operations);
		compilationUnit.accept(finder);

		if (operations.isEmpty())
			return null;
		
		CompilationUnitRewriteOperation[] fixRewriteOperations= operations.toArray(new CompilationUnitRewriteOperation[operations.size()]);

		return new SortModifiersFix(FixMessages.VariableDeclarationFix_sortModifiers_description, compilationUnit, fixRewriteOperations);
	}

	protected SortModifiersFix(String name, CompilationUnit compilationUnit, CompilationUnitRewriteOperation[] fixRewriteOperations) {
		super(name, compilationUnit, fixRewriteOperations);
	}

}

Lines 6616-6621 Link Here

(-)plugin.xml (+5 lines)
6616	runAfter="org.eclipse.jdt.ui.cleanup.loop">	6616	runAfter="org.eclipse.jdt.ui.cleanup.loop">
6617	</cleanUp>	6617	</cleanUp>
6618	<cleanUp	6618	<cleanUp
		6619	class="org.eclipse.jdt.internal.ui.fix.SortModifiersCleanUp"
		6620	id="org.eclipse.jdt.ui.cleanup.correct_modifiers_order"
		6621	runAfter="org.eclipse.jdt.ui.cleanup.variables">
		6622	</cleanUp>
		6623	<cleanUp
6619	class="org.eclipse.jdt.internal.ui.fix.ExpressionsCleanUp"	6624	class="org.eclipse.jdt.internal.ui.fix.ExpressionsCleanUp"
6620	id="org.eclipse.jdt.ui.cleanup.expressions"	6625	id="org.eclipse.jdt.ui.cleanup.expressions"
6621	runAfter="org.eclipse.jdt.ui.cleanup.variables">	6626	runAfter="org.eclipse.jdt.ui.cleanup.variables">




/*******************************************************************************
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.internal.ui.fix;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.jdt.core.dom.CompilationUnit;

import org.eclipse.jdt.internal.corext.fix.CleanUpConstants;
import org.eclipse.jdt.internal.corext.fix.SortModifiersFix;

import org.eclipse.jdt.ui.cleanup.CleanUpContext;
import org.eclipse.jdt.ui.cleanup.CleanUpRequirements;
import org.eclipse.jdt.ui.cleanup.ICleanUpFix;

public class SortModifiersCleanUp extends AbstractCleanUp {

	public SortModifiersCleanUp(Map options) {
		super(options);
	}

	public SortModifiersCleanUp() {
		super();
	}

	/**
	 * {@inheritDoc}
	 */
	public CleanUpRequirements getRequirements() {
		return new CleanUpRequirements(requireAST(), false, false, null);
	}

	private boolean requireAST() {
		return isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_SORT_MODIFIERS);
	}

	/**
	 * {@inheritDoc}
	 */
	public ICleanUpFix createFix(CleanUpContext context) throws CoreException {
		CompilationUnit compilationUnit= context.getAST();
		if (compilationUnit == null)
			return null;

		boolean addFinal= isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_SORT_MODIFIERS);
		if (!addFinal)
			return null;

		return SortModifiersFix.createCleanUp(compilationUnit);
	}

	/**
	 * {@inheritDoc}
	 */
	public String[] getStepDescriptions() {
		List result= new ArrayList();
		return (String[])result.toArray(new String[result.size()]);
	}

	/**
	 * {@inheritDoc}
	 */
	public String getPreview() {
		StringBuffer buf= new StringBuffer();

		if (isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_SORT_MODIFIERS)) {
			buf.append("abstract public class A {\n"); //$NON-NLS-1$
			buf.append("    static public final int FIELD= 0;\n"); //$NON-NLS-1$
			buf.append("    final synchronized protected void foo() {}\n"); //$NON-NLS-1$
		} else {
			buf.append("public abstract class A {\n"); //$NON-NLS-1$
			buf.append("    public static final int FIELD= 0;\n"); //$NON-NLS-1$
			buf.append("    synchronized protected final void foo() {}\n"); //$NON-NLS-1$
		}
		buf.append("}\n"); //$NON-NLS-1$

		return buf.toString();
	}

}

Lines 53-58 Link Here

(-)ui/org/eclipse/jdt/internal/ui/preferences/cleanup/CleanUpMessages.java (+1 lines)
53	public static String CodeStyleTabPage_CheckboxName_UseFinalForFields;	53	public static String CodeStyleTabPage_CheckboxName_UseFinalForFields;
54	public static String CodeStyleTabPage_CheckboxName_UseFinalForLocals;	54	public static String CodeStyleTabPage_CheckboxName_UseFinalForLocals;
55	public static String CodeStyleTabPage_CheckboxName_UseFinalForParameters;	55	public static String CodeStyleTabPage_CheckboxName_UseFinalForParameters;
		56	public static String CodeStyleTabPage_CheckboxName_SortModifiers;
56	public static String CodeStyleTabPage_CheckboxName_UseParentheses;	57	public static String CodeStyleTabPage_CheckboxName_UseParentheses;
57	public static String CodeStyleTabPage_GroupName_ControlStatments;	58	public static String CodeStyleTabPage_GroupName_ControlStatments;
58	public static String CodeStyleTabPage_GroupName_Expressions;	59	public static String CodeStyleTabPage_GroupName_Expressions;

Lines 43-48 Link Here

(-)ui/org/eclipse/jdt/internal/ui/preferences/cleanup/CleanUpMessages.properties (+1 lines)
43	CodeStyleTabPage_GroupName_VariableDeclarations=Variable declarations	43	CodeStyleTabPage_GroupName_VariableDeclarations=Variable declarations
44	CodeStyleTabPage_CheckboxName_UseFinalForFields=Private &fields	44	CodeStyleTabPage_CheckboxName_UseFinalForFields=Private &fields
45	CodeStyleTabPage_CheckboxName_UseFinalForLocals=&Local variables	45	CodeStyleTabPage_CheckboxName_UseFinalForLocals=&Local variables
		46	CodeStyleTabPage_CheckboxName_SortModifiers=Sort modifiers
46	CodeStyleTabPage_CheckboxName_ConvertForLoopToEnhanced=Conver&t for loops to enhanced	47	CodeStyleTabPage_CheckboxName_ConvertForLoopToEnhanced=Conver&t for loops to enhanced
47	CodeStyleTabPage_GroupName_ControlStatments=Control statements	48	CodeStyleTabPage_GroupName_ControlStatments=Control statements
48	CodeStyleTabPage_RadioName_UseBlocksSpecial=Always &except for single 'return' or 'throw' statements	49	CodeStyleTabPage_RadioName_UseBlocksSpecial=Always &except for single 'return' or 'throw' statements




import org.eclipse.jdt.internal.corext.fix.CleanUpConstants;
import org.eclipse.jdt.internal.corext.fix.ControlStatementsFix;
import org.eclipse.jdt.internal.corext.fix.ConvertLoopFix;
import org.eclipse.jdt.internal.corext.fix.SortModifiersFix;
import org.eclipse.jdt.internal.corext.fix.IProposableFix;
import org.eclipse.jdt.internal.corext.fix.LinkedProposalModel;
import org.eclipse.jdt.internal.corext.fix.VariableDeclarationFix;

import org.eclipse.jdt.internal.ui.JavaPluginImages;
import org.eclipse.jdt.internal.ui.fix.ControlStatementsCleanUp;
import org.eclipse.jdt.internal.ui.fix.ConvertLoopCleanUp;
import org.eclipse.jdt.internal.ui.fix.SortModifiersCleanUp;
import org.eclipse.jdt.internal.ui.fix.VariableDeclarationCleanUp;
import org.eclipse.jdt.internal.ui.javaeditor.JavaEditor;
import org.eclipse.jdt.internal.ui.text.correction.proposals.ASTRewriteCorrectionProposal;

				|| getConvertIterableLoopProposal(context, coveringNode, null)
				|| getRemoveBlockProposals(context, coveringNode, null)
				|| getMakeVariableDeclarationFinalProposals(context, null)
				|| getSortModifiersProposals(context, null)
				|| getMissingCaseStatementProposals(context, coveringNode, null)
				|| getConvertStringConcatenationProposals(context, null);
		}

					getConvertIterableLoopProposal(context, coveringNode, resultingCollections);
				getRemoveBlockProposals(context, coveringNode, resultingCollections);
				getMakeVariableDeclarationFinalProposals(context, resultingCollections);
				getSortModifiersProposals(context, resultingCollections);
				getConvertStringConcatenationProposals(context, resultingCollections);
				getMissingCaseStatementProposals(context, coveringNode, resultingCollections);
			}

		resultingCollections.add(proposal);
		return true;
	}
	
	private static boolean getSortModifiersProposals(IInvocationContext context, Collection<ICommandAccess> resultingCollections) {
		SelectionAnalyzer analyzer= new SelectionAnalyzer(Selection.createFromStartLength(context.getSelectionOffset(), context.getSelectionLength()), false);
		context.getASTRoot().accept(analyzer);
		ASTNode[] selectedNodes= analyzer.getSelectedNodes();
		if (selectedNodes.length == 0)
			return false;

		IProposableFix fix= SortModifiersFix.createFix(context.getASTRoot(), selectedNodes);
		if (fix == null)
			return false;

		if (resultingCollections == null)
			return true;

		Image image= JavaPluginImages.get(JavaPluginImages.IMG_CORRECTION_CHANGE);
		Map<String, String> options= new Hashtable<String, String>();
		options.put(CleanUpConstants.VARIABLE_DECLARATIONS_SORT_MODIFIERS, CleanUpOptions.TRUE);
		SortModifiersCleanUp cleanUp= new SortModifiersCleanUp(options);
		FixCorrectionProposal proposal= new FixCorrectionProposal(fix, cleanUp, 5, image, context);
		resultingCollections.add(proposal);
		return true;
	}

	private static boolean getInlineLocalProposal(IInvocationContext context, final ASTNode node, Collection<ICommandAccess> proposals) throws CoreException {
		if (!(node instanceof SimpleName))




import org.eclipse.jdt.internal.ui.fix.ImportsCleanUp;
import org.eclipse.jdt.internal.ui.fix.Java50CleanUp;
import org.eclipse.jdt.internal.ui.fix.SortMembersCleanUp;
import org.eclipse.jdt.internal.ui.fix.SortModifiersCleanUp;
import org.eclipse.jdt.internal.ui.fix.StringCleanUp;
import org.eclipse.jdt.internal.ui.fix.UnnecessaryCodeCleanUp;
import org.eclipse.jdt.internal.ui.fix.UnusedCodeCleanUp;

		doCleanUp(cleanUpRefactoring);
	}

	public void testSortModifiersCleanUp() throws Exception {
		CleanUpRefactoring cleanUpRefactoring= new CleanUpRefactoring();
		addAllCUs(cleanUpRefactoring, MyTestSetup.fJProject1.getChildren());

		Map node= getNullSettings();

		node.put(CleanUpConstants.VARIABLE_DECLARATIONS_SORT_MODIFIERS, CleanUpOptions.TRUE);

		storeSettings(node);

		cleanUpRefactoring.addCleanUp(new SortModifiersCleanUp());

		doCleanUp(cleanUpRefactoring);
	}	

	public void testUnnecessaryCodeCleanUp() throws Exception {
		CleanUpRefactoring cleanUpRefactoring= new CleanUpRefactoring();
		addAllCUs(cleanUpRefactoring, MyTestSetup.fJProject1.getChildren());

Return to bug 322494

Lines 663-668 Link Here

(-)core extension/org/eclipse/jdt/internal/corext/fix/CleanUpConstants.java (+14 lines)
663	public static final String VARIABLE_DECLARATION_USE_TYPE_ARGUMENTS_FOR_RAW_TYPE_REFERENCES= "cleanup.use_arguments_for_raw_type_references"; //$NON-NLS-1$	663	public static final String VARIABLE_DECLARATION_USE_TYPE_ARGUMENTS_FOR_RAW_TYPE_REFERENCES= "cleanup.use_arguments_for_raw_type_references"; //$NON-NLS-1$
664		664
665	/**	665	/**
		666	* Correct modifiers order for variable declarations.<br>
		667	* <br>
		668	* Possible values: {TRUE, FALSE}<br>
		669	*
		670	* <br>
		671	*
		672	* @see CleanUpOptions#TRUE
		673	* @see CleanUpOptions#FALSE
		674	* @since 3.7
		675	*/
		676	public static final String VARIABLE_DECLARATIONS_SORT_MODIFIERS= "cleanup.correct_variable_modifiers_order"; //$NON-NLS-1$
		677
		678	/**
666	* Removes unused imports. <br>	679	* Removes unused imports. <br>
667	* <br>	680	* <br>
668	* Possible values: {TRUE, FALSE}<br>	681	* Possible values: {TRUE, FALSE}<br>
Lines 1135-1140 Link Here
1135	options.setOption(VARIABLE_DECLARATIONS_USE_FINAL_LOCAL_VARIABLES, CleanUpOptions.TRUE);	1148	options.setOption(VARIABLE_DECLARATIONS_USE_FINAL_LOCAL_VARIABLES, CleanUpOptions.TRUE);
1136	options.setOption(VARIABLE_DECLARATIONS_USE_FINAL_PARAMETERS, CleanUpOptions.FALSE);	1149	options.setOption(VARIABLE_DECLARATIONS_USE_FINAL_PARAMETERS, CleanUpOptions.FALSE);
1137	options.setOption(VARIABLE_DECLARATIONS_USE_FINAL_PRIVATE_FIELDS, CleanUpOptions.TRUE);	1150	options.setOption(VARIABLE_DECLARATIONS_USE_FINAL_PRIVATE_FIELDS, CleanUpOptions.TRUE);
		1151	options.setOption(VARIABLE_DECLARATIONS_SORT_MODIFIERS, CleanUpOptions.FALSE);
1138		1152
1139	//Unused Code	1153	//Unused Code
1140	options.setOption(REMOVE_UNUSED_CODE_IMPORTS, CleanUpOptions.TRUE);	1154	options.setOption(REMOVE_UNUSED_CODE_IMPORTS, CleanUpOptions.TRUE);

Lines 63-68 Link Here

(-)performance/org/eclipse/jdt/ui/tests/performance/views/CleanUpPerfTest.java (+16 lines)
63	import org.eclipse.jdt.internal.ui.fix.ImportsCleanUp;	63	import org.eclipse.jdt.internal.ui.fix.ImportsCleanUp;
64	import org.eclipse.jdt.internal.ui.fix.Java50CleanUp;	64	import org.eclipse.jdt.internal.ui.fix.Java50CleanUp;
65	import org.eclipse.jdt.internal.ui.fix.SortMembersCleanUp;	65	import org.eclipse.jdt.internal.ui.fix.SortMembersCleanUp;
		66	import org.eclipse.jdt.internal.ui.fix.SortModifiersCleanUp;
66	import org.eclipse.jdt.internal.ui.fix.StringCleanUp;	67	import org.eclipse.jdt.internal.ui.fix.StringCleanUp;
67	import org.eclipse.jdt.internal.ui.fix.UnnecessaryCodeCleanUp;	68	import org.eclipse.jdt.internal.ui.fix.UnnecessaryCodeCleanUp;
68	import org.eclipse.jdt.internal.ui.fix.UnusedCodeCleanUp;	69	import org.eclipse.jdt.internal.ui.fix.UnusedCodeCleanUp;
Lines 342-347 Link Here
342	doCleanUp(cleanUpRefactoring);	343	doCleanUp(cleanUpRefactoring);
343	}	344	}
344		345
		346	public void testSortModifiersCleanUp() throws Exception {
		347	CleanUpRefactoring cleanUpRefactoring= new CleanUpRefactoring();
		348	addAllCUs(cleanUpRefactoring, MyTestSetup.fJProject1.getChildren());
		349
		350	Map node= getNullSettings();
		351
		352	node.put(CleanUpConstants.VARIABLE_DECLARATIONS_SORT_MODIFIERS, CleanUpOptions.TRUE);
		353
		354	storeSettings(node);
		355
		356	cleanUpRefactoring.addCleanUp(new SortModifiersCleanUp());
		357
		358	doCleanUp(cleanUpRefactoring);
		359	}
		360
345	public void testUnnecessaryCodeCleanUp() throws Exception {	361	public void testUnnecessaryCodeCleanUp() throws Exception {
346	CleanUpRefactoring cleanUpRefactoring= new CleanUpRefactoring();	362	CleanUpRefactoring cleanUpRefactoring= new CleanUpRefactoring();
347	addAllCUs(cleanUpRefactoring, MyTestSetup.fJProject1.getChildren());	363	addAllCUs(cleanUpRefactoring, MyTestSetup.fJProject1.getChildren());

Added Link Here

(-)core (+146 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	* Chris West (Faux) <eclipse@goeswhere.com> - [clean up] "Use modifier 'final' where possible" can introduce compile errors - https://bugs.eclipse.org/bugs/show_bug.cgi?id=272532
11	*******************************************************************************/
12	package org.eclipse.jdt.internal.corext.fix;
13
14	import java.util.ArrayList;
15	import java.util.List;
16
17	import org.eclipse.core.runtime.CoreException;
18
19	import org.eclipse.text.edits.TextEditGroup;
20
21	import org.eclipse.jdt.core.dom.ASTNode;
22	import org.eclipse.jdt.core.dom.BodyDeclaration;
23	import org.eclipse.jdt.core.dom.CompilationUnit;
24	import org.eclipse.jdt.core.dom.IExtendedModifier;
25	import org.eclipse.jdt.core.dom.Modifier;
26	import org.eclipse.jdt.core.dom.Modifier.ModifierKeyword;
27	import org.eclipse.jdt.core.dom.SimpleName;
28	import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
29	import org.eclipse.jdt.core.dom.rewrite.ListRewrite;
30
31	import org.eclipse.jdt.internal.corext.dom.ASTNodeFactory;
32	import org.eclipse.jdt.internal.corext.dom.HierarchicalASTVisitor;
33	import org.eclipse.jdt.internal.corext.refactoring.structure.CompilationUnitRewrite;
34
35	import org.eclipse.jdt.ui.cleanup.ICleanUpFix;
36
37	public class SortModifiersFix extends CompilationUnitRewriteOperationsFix {
38
39	private static class UnsortedModifiersNodeFinder extends HierarchicalASTVisitor {
40
41	private final List<SortModifiersOperation> fOperations;
42
43	public UnsortedModifiersNodeFinder(List<SortModifiersOperation> operations) {
44	fOperations= operations;
45	}
46
47	/**
48	* {@inheritDoc}
49	*/
50	@Override
51	public boolean visit(BodyDeclaration node) {
52	int modifiers= node.getModifiers();
53	if (modifiers != Modifier.NONE) {
54	List<Modifier> newModifiers= ASTNodeFactory.newModifiers(node.getAST(), modifiers);
55	List<Modifier> oldModifiers= node.modifiers();
56	for (int o= 0, n= 0; o < oldModifiers.size(); o++) {
57	IExtendedModifier modifier= oldModifiers.get(o);
58	if (modifier.isAnnotation())
59	continue;
60	ModifierKeyword oldKeyword= ((Modifier) modifier).getKeyword();
61	ModifierKeyword newKeyword= newModifiers.get(n++).getKeyword();
62	if (oldKeyword != newKeyword) {
63	fOperations.add(new SortModifiersOperation(node, newModifiers));
64	break;
65	}
66	}
67	}
68	return super.visit(node);
69	}
70	}
71
72	private static class SortModifiersOperation extends CompilationUnitRewriteOperation {
73
74	private final BodyDeclaration fWithModifiersNode;
75	private final List<Modifier> fNewModifiers;
76
77	public SortModifiersOperation(BodyDeclaration withModifiersNode, List<Modifier> newModifiers) {
78	fWithModifiersNode= withModifiersNode;
79	fNewModifiers= newModifiers;
80	}
81
82	/**
83	* {@inheritDoc}
84	*/
85	@Override
86	public void rewriteAST(CompilationUnitRewrite cuRewrite, LinkedProposalModel model) throws CoreException {
87	ASTRewrite rewrite= cuRewrite.getASTRewrite();
88	TextEditGroup group= createTextEditGroup(FixMessages.VariableDeclarationFix_sortModifiers_description, cuRewrite);
89
90	List<IExtendedModifier> oldModifiers= fWithModifiersNode.modifiers();
91	for (int i= 0; i < oldModifiers.size(); i++) {
92	Object modifier= oldModifiers.get(i);
93	if (modifier instanceof Modifier) {
94	rewrite.remove((Modifier) modifier, group);
95	}
96	}
97
98	ListRewrite listRewrite= rewrite.getListRewrite(fWithModifiersNode, fWithModifiersNode.getModifiersProperty());
99	for (int i= 0; i < fNewModifiers.size(); i++) {
100	Modifier curr= fNewModifiers.get(i);
101	listRewrite.insertLast(curr, group);
102	}
103	}
104	}
105
106	public static SortModifiersFix createFix(final CompilationUnit compilationUnit, ASTNode[] selectedNodes) {
107	List<SortModifiersOperation> operations= new ArrayList<SortModifiersOperation>();
108	UnsortedModifiersNodeFinder visitor= new UnsortedModifiersNodeFinder(operations);
109	compilationUnit.accept(visitor);
110	if (selectedNodes.length == 1) {
111	if (selectedNodes[0] instanceof SimpleName) {
112	selectedNodes[0]= selectedNodes[0].getParent();
113	}
114	selectedNodes[0].accept(visitor);
115	} else {
116	for (int i= 0; i < selectedNodes.length; i++) {
117	ASTNode selectedNode= selectedNodes[i];
118	selectedNode.accept(visitor);
119	}
120	}
121	if (operations.size() == 0)
122	return null;
123
124	CompilationUnitRewriteOperation[] fixRewriteOperations= operations.toArray(new CompilationUnitRewriteOperation[operations.size()]);
125
126	return new SortModifiersFix(FixMessages.VariableDeclarationFix_sortModifiers_description, compilationUnit, fixRewriteOperations);
127	}
128
129	public static ICleanUpFix createCleanUp(CompilationUnit compilationUnit) {
130	List<SortModifiersOperation> operations= new ArrayList<SortModifiersOperation>();
131	UnsortedModifiersNodeFinder finder= new UnsortedModifiersNodeFinder(operations);
132	compilationUnit.accept(finder);
133
134	if (operations.isEmpty())
135	return null;
136
137	CompilationUnitRewriteOperation[] fixRewriteOperations= operations.toArray(new CompilationUnitRewriteOperation[operations.size()]);
138
139	return new SortModifiersFix(FixMessages.VariableDeclarationFix_sortModifiers_description, compilationUnit, fixRewriteOperations);
140	}
141
142	protected SortModifiersFix(String name, CompilationUnit compilationUnit, CompilationUnitRewriteOperation[] fixRewriteOperations) {
143	super(name, compilationUnit, fixRewriteOperations);
144	}
145
146	}

Added Link Here

(-)ui/org/eclipse/jdt/internal/ui/fix/SortModifiersCleanUp.java (+92 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.jdt.internal.ui.fix;
12
13	import java.util.ArrayList;
14	import java.util.List;
15	import java.util.Map;
16
17	import org.eclipse.core.runtime.CoreException;
18
19	import org.eclipse.jdt.core.dom.CompilationUnit;
20
21	import org.eclipse.jdt.internal.corext.fix.CleanUpConstants;
22	import org.eclipse.jdt.internal.corext.fix.SortModifiersFix;
23
24	import org.eclipse.jdt.ui.cleanup.CleanUpContext;
25	import org.eclipse.jdt.ui.cleanup.CleanUpRequirements;
26	import org.eclipse.jdt.ui.cleanup.ICleanUpFix;
27
28	public class SortModifiersCleanUp extends AbstractCleanUp {
29
30	public SortModifiersCleanUp(Map options) {
31	super(options);
32	}
33
34	public SortModifiersCleanUp() {
35	super();
36	}
37
38	/**
39	* {@inheritDoc}
40	*/
41	public CleanUpRequirements getRequirements() {
42	return new CleanUpRequirements(requireAST(), false, false, null);
43	}
44
45	private boolean requireAST() {
46	return isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_SORT_MODIFIERS);
47	}
48
49	/**
50	* {@inheritDoc}
51	*/
52	public ICleanUpFix createFix(CleanUpContext context) throws CoreException {
53	CompilationUnit compilationUnit= context.getAST();
54	if (compilationUnit == null)
55	return null;
56
57	boolean addFinal= isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_SORT_MODIFIERS);
58	if (!addFinal)
59	return null;
60
61	return SortModifiersFix.createCleanUp(compilationUnit);
62	}
63
64	/**
65	* {@inheritDoc}
66	*/
67	public String[] getStepDescriptions() {
68	List result= new ArrayList();
69	return (String[])result.toArray(new String[result.size()]);
70	}
71
72	/**
73	* {@inheritDoc}
74	*/
75	public String getPreview() {
76	StringBuffer buf= new StringBuffer();
77
78	if (isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_SORT_MODIFIERS)) {
79	buf.append("abstract public class A {\n"); //$NON-NLS-1$
80	buf.append(" static public final int FIELD= 0;\n"); //$NON-NLS-1$
81	buf.append(" final synchronized protected void foo() {}\n"); //$NON-NLS-1$
82	} else {
83	buf.append("public abstract class A {\n"); //$NON-NLS-1$
84	buf.append(" public static final int FIELD= 0;\n"); //$NON-NLS-1$
85	buf.append(" synchronized protected final void foo() {}\n"); //$NON-NLS-1$
86	}
87	buf.append("}\n"); //$NON-NLS-1$
88
89	return buf.toString();
90	}
91
92	}

Lines 21-26 Link Here

(-)ui/org/eclipse/jdt/internal/ui/preferences/cleanup/CodeStyleTabPage.java (-1 / +6 lines)
21	import org.eclipse.jdt.internal.ui.fix.ControlStatementsCleanUp;	21	import org.eclipse.jdt.internal.ui.fix.ControlStatementsCleanUp;
22	import org.eclipse.jdt.internal.ui.fix.ConvertLoopCleanUp;	22	import org.eclipse.jdt.internal.ui.fix.ConvertLoopCleanUp;
23	import org.eclipse.jdt.internal.ui.fix.ExpressionsCleanUp;	23	import org.eclipse.jdt.internal.ui.fix.ExpressionsCleanUp;
		24	import org.eclipse.jdt.internal.ui.fix.SortModifiersCleanUp;
24	import org.eclipse.jdt.internal.ui.fix.VariableDeclarationCleanUp;	25	import org.eclipse.jdt.internal.ui.fix.VariableDeclarationCleanUp;
25		26
26	public final class CodeStyleTabPage extends AbstractCleanUpTabPage {	27	public final class CodeStyleTabPage extends AbstractCleanUpTabPage {
Lines 37-43 Link Here
37	new ControlStatementsCleanUp(values),	38	new ControlStatementsCleanUp(values),
38	new ConvertLoopCleanUp(values),	39	new ConvertLoopCleanUp(values),
39	new ExpressionsCleanUp(values),	40	new ExpressionsCleanUp(values),
40	new VariableDeclarationCleanUp(values)	41	new VariableDeclarationCleanUp(values),
		42	new SortModifiersCleanUp(values),
41	};	43	};
42	}	44	}
43		45
Lines 74-78 Link Here
74	final CheckboxPreference useFinalParametersPref= createCheckboxPref(variableGroup, 1, CleanUpMessages.CodeStyleTabPage_CheckboxName_UseFinalForParameters, CleanUpConstants.VARIABLE_DECLARATIONS_USE_FINAL_PARAMETERS, CleanUpModifyDialog.FALSE_TRUE);	76	final CheckboxPreference useFinalParametersPref= createCheckboxPref(variableGroup, 1, CleanUpMessages.CodeStyleTabPage_CheckboxName_UseFinalForParameters, CleanUpConstants.VARIABLE_DECLARATIONS_USE_FINAL_PARAMETERS, CleanUpModifyDialog.FALSE_TRUE);
75	final CheckboxPreference useFinalVariablesPref= createCheckboxPref(variableGroup, 1, CleanUpMessages.CodeStyleTabPage_CheckboxName_UseFinalForLocals, CleanUpConstants.VARIABLE_DECLARATIONS_USE_FINAL_LOCAL_VARIABLES, CleanUpModifyDialog.FALSE_TRUE);	77	final CheckboxPreference useFinalVariablesPref= createCheckboxPref(variableGroup, 1, CleanUpMessages.CodeStyleTabPage_CheckboxName_UseFinalForLocals, CleanUpConstants.VARIABLE_DECLARATIONS_USE_FINAL_LOCAL_VARIABLES, CleanUpModifyDialog.FALSE_TRUE);
76	registerSlavePreference(useFinalPref, new CheckboxPreference[] {useFinalFieldsPref, useFinalParametersPref, useFinalVariablesPref});	78	registerSlavePreference(useFinalPref, new CheckboxPreference[] {useFinalFieldsPref, useFinalParametersPref, useFinalVariablesPref});
		79
		80	final CheckboxPreference sortModifiersPref= createCheckboxPref(variableGroup, numColumns, CleanUpMessages.CodeStyleTabPage_CheckboxName_SortModifiers, CleanUpConstants.VARIABLE_DECLARATIONS_SORT_MODIFIERS, CleanUpModifyDialog.FALSE_TRUE);
		81	registerPreference(sortModifiersPref);
77	}	82	}
78	}	83	}

Lines 116-121 Link Here

(-)ui/org/eclipse/jdt/internal/ui/text/correction/QuickAssistProcessor.java (+27 lines)
116	import org.eclipse.jdt.internal.corext.fix.CleanUpConstants;	116	import org.eclipse.jdt.internal.corext.fix.CleanUpConstants;
117	import org.eclipse.jdt.internal.corext.fix.ControlStatementsFix;	117	import org.eclipse.jdt.internal.corext.fix.ControlStatementsFix;
118	import org.eclipse.jdt.internal.corext.fix.ConvertLoopFix;	118	import org.eclipse.jdt.internal.corext.fix.ConvertLoopFix;
		119	import org.eclipse.jdt.internal.corext.fix.SortModifiersFix;
119	import org.eclipse.jdt.internal.corext.fix.IProposableFix;	120	import org.eclipse.jdt.internal.corext.fix.IProposableFix;
120	import org.eclipse.jdt.internal.corext.fix.LinkedProposalModel;	121	import org.eclipse.jdt.internal.corext.fix.LinkedProposalModel;
121	import org.eclipse.jdt.internal.corext.fix.VariableDeclarationFix;	122	import org.eclipse.jdt.internal.corext.fix.VariableDeclarationFix;
Lines 141-146 Link Here
141	import org.eclipse.jdt.internal.ui.JavaPluginImages;	142	import org.eclipse.jdt.internal.ui.JavaPluginImages;
142	import org.eclipse.jdt.internal.ui.fix.ControlStatementsCleanUp;	143	import org.eclipse.jdt.internal.ui.fix.ControlStatementsCleanUp;
143	import org.eclipse.jdt.internal.ui.fix.ConvertLoopCleanUp;	144	import org.eclipse.jdt.internal.ui.fix.ConvertLoopCleanUp;
		145	import org.eclipse.jdt.internal.ui.fix.SortModifiersCleanUp;
144	import org.eclipse.jdt.internal.ui.fix.VariableDeclarationCleanUp;	146	import org.eclipse.jdt.internal.ui.fix.VariableDeclarationCleanUp;
145	import org.eclipse.jdt.internal.ui.javaeditor.JavaEditor;	147	import org.eclipse.jdt.internal.ui.javaeditor.JavaEditor;
146	import org.eclipse.jdt.internal.ui.text.correction.proposals.ASTRewriteCorrectionProposal;	148	import org.eclipse.jdt.internal.ui.text.correction.proposals.ASTRewriteCorrectionProposal;
Lines 204-209 Link Here
204	\|\| getConvertIterableLoopProposal(context, coveringNode, null)	206	\|\| getConvertIterableLoopProposal(context, coveringNode, null)
205	\|\| getRemoveBlockProposals(context, coveringNode, null)	207	\|\| getRemoveBlockProposals(context, coveringNode, null)
206	\|\| getMakeVariableDeclarationFinalProposals(context, null)	208	\|\| getMakeVariableDeclarationFinalProposals(context, null)
		209	\|\| getSortModifiersProposals(context, null)
207	\|\| getMissingCaseStatementProposals(context, coveringNode, null)	210	\|\| getMissingCaseStatementProposals(context, coveringNode, null)
208	\|\| getConvertStringConcatenationProposals(context, null);	211	\|\| getConvertStringConcatenationProposals(context, null);
209	}	212	}
Lines 243-248 Link Here
243	getConvertIterableLoopProposal(context, coveringNode, resultingCollections);	246	getConvertIterableLoopProposal(context, coveringNode, resultingCollections);
244	getRemoveBlockProposals(context, coveringNode, resultingCollections);	247	getRemoveBlockProposals(context, coveringNode, resultingCollections);
245	getMakeVariableDeclarationFinalProposals(context, resultingCollections);	248	getMakeVariableDeclarationFinalProposals(context, resultingCollections);
		249	getSortModifiersProposals(context, resultingCollections);
246	getConvertStringConcatenationProposals(context, resultingCollections);	250	getConvertStringConcatenationProposals(context, resultingCollections);
247	getMissingCaseStatementProposals(context, coveringNode, resultingCollections);	251	getMissingCaseStatementProposals(context, coveringNode, resultingCollections);
248	}	252	}
Lines 1925-1930 Link Here
1925	resultingCollections.add(proposal);	1929	resultingCollections.add(proposal);
1926	return true;	1930	return true;
1927	}	1931	}
		1932
		1933	private static boolean getSortModifiersProposals(IInvocationContext context, Collection<ICommandAccess> resultingCollections) {
		1934	SelectionAnalyzer analyzer= new SelectionAnalyzer(Selection.createFromStartLength(context.getSelectionOffset(), context.getSelectionLength()), false);
		1935	context.getASTRoot().accept(analyzer);
		1936	ASTNode[] selectedNodes= analyzer.getSelectedNodes();
		1937	if (selectedNodes.length == 0)
		1938	return false;
		1939
		1940	IProposableFix fix= SortModifiersFix.createFix(context.getASTRoot(), selectedNodes);
		1941	if (fix == null)
		1942	return false;
		1943
		1944	if (resultingCollections == null)
		1945	return true;
		1946
		1947	Image image= JavaPluginImages.get(JavaPluginImages.IMG_CORRECTION_CHANGE);
		1948	Map<String, String> options= new Hashtable<String, String>();
		1949	options.put(CleanUpConstants.VARIABLE_DECLARATIONS_SORT_MODIFIERS, CleanUpOptions.TRUE);
		1950	SortModifiersCleanUp cleanUp= new SortModifiersCleanUp(options);
		1951	FixCorrectionProposal proposal= new FixCorrectionProposal(fix, cleanUp, 5, image, context);
		1952	resultingCollections.add(proposal);
		1953	return true;
		1954	}
1928		1955
1929	private static boolean getInlineLocalProposal(IInvocationContext context, final ASTNode node, Collection<ICommandAccess> proposals) throws CoreException {	1956	private static boolean getInlineLocalProposal(IInvocationContext context, final ASTNode node, Collection<ICommandAccess> proposals) throws CoreException {
1930	if (!(node instanceof SimpleName))	1957	if (!(node instanceof SimpleName))