Attachment #187990 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, 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
 *     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.LinkedList;
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.SimpleName;
import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;

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

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

public class SortModifiersFix extends CompilationUnitRewriteOperationsFix {

	private static class WithModifiersNodeFinder extends HierarchicalASTVisitor {

		private final List fWithModifiersNodes;
		private final List fOperations;

		public WithModifiersNodeFinder(List withModifiersNodes, List operations) {
			fWithModifiersNodes= withModifiersNodes;
			fOperations= operations;
		}

		/**
		 * {@inheritDoc}
		 */
		public boolean visit(BodyDeclaration node) {
			if (node.modifiers().size() > 1) {
				fWithModifiersNodes.add(node);
				fOperations.add(createSortModifiersOperation(node));
			}
			return super.visit(node);
		}

	}

	private static class SortModifiersOperation extends CompilationUnitRewriteOperation {

		private final BodyDeclaration fWithModifiersNode;

		public SortModifiersOperation(BodyDeclaration withModifiersNode) {
			fWithModifiersNode= withModifiersNode;
		}

		/**
		 * {@inheritDoc}
		 */
		public void rewriteAST(CompilationUnitRewrite cuRewrite, LinkedProposalModel model) throws CoreException {
			ASTRewrite rewrite= cuRewrite.getASTRewrite();
			TextEditGroup group= createTextEditGroup(FixMessages.VariableDeclarationFix_sortModifiers_description, cuRewrite);
			int modifiers= fWithModifiersNode.getModifiers();
			ModifierRewrite listRewrite= ModifierRewrite.create(rewrite, fWithModifiersNode);
			listRewrite.setModifiers(modifiers, group);
		}
	}

	private static SortModifiersOperation createSortModifiersOperation(BodyDeclaration withModifiersNode) {
		return new SortModifiersOperation(withModifiersNode);
	}

	public static SortModifiersFix createFix(final CompilationUnit compilationUnit, ASTNode[] selectedNodes) {
		List withModifiersNode= new LinkedList();
		List operations= new ArrayList();
		WithModifiersNodeFinder visitor= new WithModifiersNodeFinder(withModifiersNode, 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= (CompilationUnitRewriteOperation[])operations.toArray(new CompilationUnitRewriteOperation[operations.size()]);

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

	public static ICleanUpFix createCleanUp(CompilationUnit compilationUnit) {
		List withModifiersNodes= new LinkedList();
		List operations= new ArrayList();
		WithModifiersNodeFinder finder= new WithModifiersNodeFinder(withModifiersNodes, operations);
		compilationUnit.accept(finder);

		CompilationUnitRewriteOperation[] fixRewriteOperations= (CompilationUnitRewriteOperation[])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);
			}

		return true;
	}

	private static boolean getSortModifiersProposals(IInvocationContext context, Collection 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 options= new Hashtable();
		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 proposals) throws CoreException {
		if (!(node instanceof SimpleName))
			return false;

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);

Added Link Here

(-)core (+122 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	* 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.LinkedList;
16	import java.util.List;
17
18	import org.eclipse.core.runtime.CoreException;
19
20	import org.eclipse.text.edits.TextEditGroup;
21
22	import org.eclipse.jdt.core.dom.ASTNode;
23	import org.eclipse.jdt.core.dom.BodyDeclaration;
24	import org.eclipse.jdt.core.dom.CompilationUnit;
25	import org.eclipse.jdt.core.dom.SimpleName;
26	import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
27
28	import org.eclipse.jdt.internal.corext.dom.HierarchicalASTVisitor;
29	import org.eclipse.jdt.internal.corext.dom.ModifierRewrite;
30	import org.eclipse.jdt.internal.corext.refactoring.structure.CompilationUnitRewrite;
31
32	import org.eclipse.jdt.ui.cleanup.ICleanUpFix;
33
34	public class SortModifiersFix extends CompilationUnitRewriteOperationsFix {
35
36	private static class WithModifiersNodeFinder extends HierarchicalASTVisitor {
37
38	private final List fWithModifiersNodes;
39	private final List fOperations;
40
41	public WithModifiersNodeFinder(List withModifiersNodes, List operations) {
42	fWithModifiersNodes= withModifiersNodes;
43	fOperations= operations;
44	}
45
46	/**
47	* {@inheritDoc}
48	*/
49	public boolean visit(BodyDeclaration node) {
50	if (node.modifiers().size() > 1) {
51	fWithModifiersNodes.add(node);
52	fOperations.add(createSortModifiersOperation(node));
53	}
54	return super.visit(node);
55	}
56
57	}
58
59	private static class SortModifiersOperation extends CompilationUnitRewriteOperation {
60
61	private final BodyDeclaration fWithModifiersNode;
62
63	public SortModifiersOperation(BodyDeclaration withModifiersNode) {
64	fWithModifiersNode= withModifiersNode;
65	}
66
67	/**
68	* {@inheritDoc}
69	*/
70	public void rewriteAST(CompilationUnitRewrite cuRewrite, LinkedProposalModel model) throws CoreException {
71	ASTRewrite rewrite= cuRewrite.getASTRewrite();
72	TextEditGroup group= createTextEditGroup(FixMessages.VariableDeclarationFix_sortModifiers_description, cuRewrite);
73	int modifiers= fWithModifiersNode.getModifiers();
74	ModifierRewrite listRewrite= ModifierRewrite.create(rewrite, fWithModifiersNode);
75	listRewrite.setModifiers(modifiers, group);
76	}
77	}
78
79	private static SortModifiersOperation createSortModifiersOperation(BodyDeclaration withModifiersNode) {
80	return new SortModifiersOperation(withModifiersNode);
81	}
82
83	public static SortModifiersFix createFix(final CompilationUnit compilationUnit, ASTNode[] selectedNodes) {
84	List withModifiersNode= new LinkedList();
85	List operations= new ArrayList();
86	WithModifiersNodeFinder visitor= new WithModifiersNodeFinder(withModifiersNode, operations);
87	compilationUnit.accept(visitor);
88	if (selectedNodes.length == 1) {
89	if (selectedNodes[0] instanceof SimpleName) {
90	selectedNodes[0]= selectedNodes[0].getParent();
91	}
92	selectedNodes[0].accept(visitor);
93	} else {
94	for (int i= 0; i < selectedNodes.length; i++) {
95	ASTNode selectedNode= selectedNodes[i];
96	selectedNode.accept(visitor);
97	}
98	}
99	if (operations.size() == 0)
100	return null;
101
102	CompilationUnitRewriteOperation[] fixRewriteOperations= (CompilationUnitRewriteOperation[])operations.toArray(new CompilationUnitRewriteOperation[operations.size()]);
103
104	return new SortModifiersFix(FixMessages.VariableDeclarationFix_sortModifiers_description, compilationUnit, fixRewriteOperations);
105	}
106
107	public static ICleanUpFix createCleanUp(CompilationUnit compilationUnit) {
108	List withModifiersNodes= new LinkedList();
109	List operations= new ArrayList();
110	WithModifiersNodeFinder finder= new WithModifiersNodeFinder(withModifiersNodes, operations);
111	compilationUnit.accept(finder);
112
113	CompilationUnitRewriteOperation[] fixRewriteOperations= (CompilationUnitRewriteOperation[])operations.toArray(new CompilationUnitRewriteOperation[operations.size()]);
114
115	return new SortModifiersFix(FixMessages.VariableDeclarationFix_sortModifiers_description, compilationUnit, fixRewriteOperations);
116	}
117
118	protected SortModifiersFix(String name, CompilationUnit compilationUnit, CompilationUnitRewriteOperation[] fixRewriteOperations) {
119	super(name, compilationUnit, fixRewriteOperations);
120	}
121
122	}

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 36-42 Link Here
36	new ControlStatementsCleanUp(values),	37	new ControlStatementsCleanUp(values),
37	new ConvertLoopCleanUp(values),	38	new ConvertLoopCleanUp(values),
38	new ExpressionsCleanUp(values),	39	new ExpressionsCleanUp(values),
39	new VariableDeclarationCleanUp(values)	40	new VariableDeclarationCleanUp(values),
		41	new SortModifiersCleanUp(values),
40	};	42	};
41	}	43	}
42		44
Lines 72-76 Link Here
72	final CheckboxPreference useFinalParametersPref= createCheckboxPref(variableGroup, 1, CleanUpMessages.CodeStyleTabPage_CheckboxName_UseFinalForParameters, CleanUpConstants.VARIABLE_DECLARATIONS_USE_FINAL_PARAMETERS, CleanUpModifyDialog.FALSE_TRUE);	74	final CheckboxPreference useFinalParametersPref= createCheckboxPref(variableGroup, 1, CleanUpMessages.CodeStyleTabPage_CheckboxName_UseFinalForParameters, CleanUpConstants.VARIABLE_DECLARATIONS_USE_FINAL_PARAMETERS, CleanUpModifyDialog.FALSE_TRUE);
73	final CheckboxPreference useFinalVariablesPref= createCheckboxPref(variableGroup, 1, CleanUpMessages.CodeStyleTabPage_CheckboxName_UseFinalForLocals, CleanUpConstants.VARIABLE_DECLARATIONS_USE_FINAL_LOCAL_VARIABLES, CleanUpModifyDialog.FALSE_TRUE);	75	final CheckboxPreference useFinalVariablesPref= createCheckboxPref(variableGroup, 1, CleanUpMessages.CodeStyleTabPage_CheckboxName_UseFinalForLocals, CleanUpConstants.VARIABLE_DECLARATIONS_USE_FINAL_LOCAL_VARIABLES, CleanUpModifyDialog.FALSE_TRUE);
74	registerSlavePreference(useFinalPref, new CheckboxPreference[] {useFinalFieldsPref, useFinalParametersPref, useFinalVariablesPref});	76	registerSlavePreference(useFinalPref, new CheckboxPreference[] {useFinalFieldsPref, useFinalParametersPref, useFinalVariablesPref});
		77
		78	final CheckboxPreference sortModifiersPref= createCheckboxPref(variableGroup, numColumns, CleanUpMessages.CodeStyleTabPage_CheckboxName_SortModifiers, CleanUpConstants.VARIABLE_DECLARATIONS_SORT_MODIFIERS, CleanUpModifyDialog.FALSE_TRUE);
		79	registerPreference(sortModifiersPref);
75	}	80	}
76	}	81	}

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 242-247 Link Here
242	getConvertIterableLoopProposal(context, coveringNode, resultingCollections);	245	getConvertIterableLoopProposal(context, coveringNode, resultingCollections);
243	getRemoveBlockProposals(context, coveringNode, resultingCollections);	246	getRemoveBlockProposals(context, coveringNode, resultingCollections);
244	getMakeVariableDeclarationFinalProposals(context, resultingCollections);	247	getMakeVariableDeclarationFinalProposals(context, resultingCollections);
		248	getSortModifiersProposals(context, resultingCollections);
245	getConvertStringConcatenationProposals(context, resultingCollections);	249	getConvertStringConcatenationProposals(context, resultingCollections);
246	getMissingCaseStatementProposals(context, coveringNode, resultingCollections);	250	getMissingCaseStatementProposals(context, coveringNode, resultingCollections);
247	}	251	}
Lines 1913-1918 Link Here
1913	return true;	1917	return true;
1914	}	1918	}
1915		1919
		1920	private static boolean getSortModifiersProposals(IInvocationContext context, Collection resultingCollections) {
		1921	SelectionAnalyzer analyzer= new SelectionAnalyzer(Selection.createFromStartLength(context.getSelectionOffset(), context.getSelectionLength()), false);
		1922	context.getASTRoot().accept(analyzer);
		1923	ASTNode[] selectedNodes= analyzer.getSelectedNodes();
		1924	if (selectedNodes.length == 0)
		1925	return false;
		1926
		1927	IProposableFix fix= SortModifiersFix.createFix(context.getASTRoot(), selectedNodes);
		1928	if (fix == null)
		1929	return false;
		1930
		1931	if (resultingCollections == null)
		1932	return true;
		1933
		1934	Image image= JavaPluginImages.get(JavaPluginImages.IMG_CORRECTION_CHANGE);
		1935	Map options= new Hashtable();
		1936	options.put(CleanUpConstants.VARIABLE_DECLARATIONS_SORT_MODIFIERS, CleanUpOptions.TRUE);
		1937	SortModifiersCleanUp cleanUp= new SortModifiersCleanUp(options);
		1938	FixCorrectionProposal proposal= new FixCorrectionProposal(fix, cleanUp, 5, image, context);
		1939	resultingCollections.add(proposal);
		1940	return true;
		1941	}
		1942
1916	private static boolean getInlineLocalProposal(IInvocationContext context, final ASTNode node, Collection proposals) throws CoreException {	1943	private static boolean getInlineLocalProposal(IInvocationContext context, final ASTNode node, Collection proposals) throws CoreException {
1917	if (!(node instanceof SimpleName))	1944	if (!(node instanceof SimpleName))
1918	return false;	1945	return false;