Attachment #177773 for bug #322494

Lines 663-668 Link Here

(-)core extension/org/eclipse/jdt/internal/corext/fix/CleanUpConstants.java (+19 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
		1152	//Modifiers Order
		1153	options.setOption(VARIABLE_DECLARATIONS_SORT_MODIFIERS, CleanUpOptions.FALSE);
1138		1154
1139	//Unused Code	1155	//Unused Code
1140	options.setOption(REMOVE_UNUSED_CODE_IMPORTS, CleanUpOptions.TRUE);	1156	options.setOption(REMOVE_UNUSED_CODE_IMPORTS, CleanUpOptions.TRUE);
Lines 1215-1220 Link Here
1215	options.setOption(VARIABLE_DECLARATIONS_USE_FINAL_LOCAL_VARIABLES, CleanUpOptions.FALSE);	1231	options.setOption(VARIABLE_DECLARATIONS_USE_FINAL_LOCAL_VARIABLES, CleanUpOptions.FALSE);
1216	options.setOption(VARIABLE_DECLARATIONS_USE_FINAL_PARAMETERS, CleanUpOptions.FALSE);	1232	options.setOption(VARIABLE_DECLARATIONS_USE_FINAL_PARAMETERS, CleanUpOptions.FALSE);
1217	options.setOption(VARIABLE_DECLARATIONS_USE_FINAL_PRIVATE_FIELDS, CleanUpOptions.TRUE);	1233	options.setOption(VARIABLE_DECLARATIONS_USE_FINAL_PRIVATE_FIELDS, CleanUpOptions.TRUE);
		1234
		1235	//Modifiers Order
		1236	options.setOption(VARIABLE_DECLARATIONS_SORT_MODIFIERS, CleanUpOptions.TRUE);
1218		1237
1219	//Unused Code	1238	//Unused Code
1220	options.setOption(REMOVE_UNUSED_CODE_IMPORTS, CleanUpOptions.FALSE);	1239	options.setOption(REMOVE_UNUSED_CODE_IMPORTS, CleanUpOptions.FALSE);

Lines 117-122 Link Here

(-)core extension/org/eclipse/jdt/internal/corext/fix/FixMessages.java (+2 lines)
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		119
		120	public static String VariableDeclarationFix_sortModifiers_description;
		121
120	static {	122	static {
121	// initialize resource bundle	123	// initialize resource bundle
122	NLS.initializeMessages(BUNDLE_NAME, FixMessages.class);	124	NLS.initializeMessages(BUNDLE_NAME, FixMessages.class);

Lines 83-88 Link Here

(-)core extension/org/eclipse/jdt/internal/corext/fix/FixMessages.properties (+2 lines)
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		85
		86	VariableDeclarationFix_sortModifiers_description=Correct modifiers order
		87
86	PotentialProgrammingProblemsFix_calculatingUIDFailed_unknown=Could not calculate a serial version id for {0}. The type will be ignored.	88	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	89	PotentialProgrammingProblemsFix_add_id_change_name=Add Serial Version ID
88	PotentialProgrammingProblemsFix_calculatingUIDFailed_exception=Could not calculate serial version ids for serializable types in project {0}. The types will be ignored. Reason: {1}.	90	PotentialProgrammingProblemsFix_calculatingUIDFailed_exception=Could not calculate serial version ids for serializable types in project {0}. The types will be ignored. Reason: {1}.




/*******************************************************************************
 * 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 modifierRewrite= ModifierRewrite.create(rewrite, fWithModifiersNode);
			modifierRewrite.setModifiers(0, group);
			modifierRewrite.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 6597-6602 Link Here

(-)plugin.xml (+5 lines)
6597	runAfter="org.eclipse.jdt.ui.cleanup.loop">	6597	runAfter="org.eclipse.jdt.ui.cleanup.loop">
6598	</cleanUp>	6598	</cleanUp>
6599	<cleanUp	6599	<cleanUp
		6600	class="org.eclipse.jdt.internal.ui.fix.SortModifiersCleanUp"
		6601	id="org.eclipse.jdt.ui.cleanup.correct_modifiers_order"
		6602	runAfter="org.eclipse.jdt.ui.cleanup.variables">
		6603	</cleanUp>
		6604	<cleanUp
6600	class="org.eclipse.jdt.internal.ui.fix.ExpressionsCleanUp"	6605	class="org.eclipse.jdt.internal.ui.fix.ExpressionsCleanUp"
6601	id="org.eclipse.jdt.ui.cleanup.expressions"	6606	id="org.eclipse.jdt.ui.cleanup.expressions"
6602	runAfter="org.eclipse.jdt.ui.cleanup.variables">	6607	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 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 to bug 322494

Added Link Here

(-)core (+125 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
73	TextEditGroup group= createTextEditGroup(FixMessages.VariableDeclarationFix_sortModifiers_description, cuRewrite);
74
75	int modifiers= fWithModifiersNode.getModifiers();
76	ModifierRewrite modifierRewrite= ModifierRewrite.create(rewrite, fWithModifiersNode);
77	modifierRewrite.setModifiers(0, group);
78	modifierRewrite.setModifiers(modifiers, group);
79	}
80	}
81
82	private static SortModifiersOperation createSortModifiersOperation(BodyDeclaration withModifiersNode) {
83	return new SortModifiersOperation(withModifiersNode);
84	}
85
86	public static SortModifiersFix createFix(final CompilationUnit compilationUnit, ASTNode[] selectedNodes) {
87	List withModifiersNode= new LinkedList();
88	List operations= new ArrayList();
89	WithModifiersNodeFinder visitor= new WithModifiersNodeFinder(withModifiersNode, operations);
90	compilationUnit.accept(visitor);
91	if (selectedNodes.length == 1) {
92	if (selectedNodes[0] instanceof SimpleName) {
93	selectedNodes[0]= selectedNodes[0].getParent();
94	}
95	selectedNodes[0].accept(visitor);
96	} else {
97	for (int i= 0; i < selectedNodes.length; i++) {
98	ASTNode selectedNode= selectedNodes[i];
99	selectedNode.accept(visitor);
100	}
101	}
102	if (operations.size() == 0)
103	return null;
104
105	CompilationUnitRewriteOperation[] fixRewriteOperations= (CompilationUnitRewriteOperation[])operations.toArray(new CompilationUnitRewriteOperation[operations.size()]);
106
107	return new SortModifiersFix(FixMessages.VariableDeclarationFix_sortModifiers_description, compilationUnit, fixRewriteOperations);
108	}
109
110	public static ICleanUpFix createCleanUp(CompilationUnit compilationUnit) {
111	List withModifiersNodes= new LinkedList();
112	List operations= new ArrayList();
113	WithModifiersNodeFinder finder= new WithModifiersNodeFinder(withModifiersNodes, operations);
114	compilationUnit.accept(finder);
115
116	CompilationUnitRewriteOperation[] fixRewriteOperations= (CompilationUnitRewriteOperation[])operations.toArray(new CompilationUnitRewriteOperation[operations.size()]);
117
118	return new SortModifiersFix(FixMessages.VariableDeclarationFix_sortModifiers_description, compilationUnit, fixRewriteOperations);
119	}
120
121	protected SortModifiersFix(String name, CompilationUnit compilationUnit, CompilationUnitRewriteOperation[] fixRewriteOperations) {
122	super(name, compilationUnit, fixRewriteOperations);
123	}
124
125	}

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 115-120 Link Here

(-)ui/org/eclipse/jdt/internal/ui/text/correction/QuickAssistProcessor.java (+27 lines)
115	import org.eclipse.jdt.internal.corext.fix.CleanUpConstants;	115	import org.eclipse.jdt.internal.corext.fix.CleanUpConstants;
116	import org.eclipse.jdt.internal.corext.fix.ControlStatementsFix;	116	import org.eclipse.jdt.internal.corext.fix.ControlStatementsFix;
117	import org.eclipse.jdt.internal.corext.fix.ConvertLoopFix;	117	import org.eclipse.jdt.internal.corext.fix.ConvertLoopFix;
		118	import org.eclipse.jdt.internal.corext.fix.SortModifiersFix;
118	import org.eclipse.jdt.internal.corext.fix.IProposableFix;	119	import org.eclipse.jdt.internal.corext.fix.IProposableFix;
119	import org.eclipse.jdt.internal.corext.fix.LinkedProposalModel;	120	import org.eclipse.jdt.internal.corext.fix.LinkedProposalModel;
120	import org.eclipse.jdt.internal.corext.fix.VariableDeclarationFix;	121	import org.eclipse.jdt.internal.corext.fix.VariableDeclarationFix;
Lines 139-144 Link Here
139	import org.eclipse.jdt.internal.ui.JavaPluginImages;	140	import org.eclipse.jdt.internal.ui.JavaPluginImages;
140	import org.eclipse.jdt.internal.ui.fix.ControlStatementsCleanUp;	141	import org.eclipse.jdt.internal.ui.fix.ControlStatementsCleanUp;
141	import org.eclipse.jdt.internal.ui.fix.ConvertLoopCleanUp;	142	import org.eclipse.jdt.internal.ui.fix.ConvertLoopCleanUp;
		143	import org.eclipse.jdt.internal.ui.fix.SortModifiersCleanUp;
142	import org.eclipse.jdt.internal.ui.fix.VariableDeclarationCleanUp;	144	import org.eclipse.jdt.internal.ui.fix.VariableDeclarationCleanUp;
143	import org.eclipse.jdt.internal.ui.javaeditor.JavaEditor;	145	import org.eclipse.jdt.internal.ui.javaeditor.JavaEditor;
144	import org.eclipse.jdt.internal.ui.text.correction.proposals.ASTRewriteCorrectionProposal;	146	import org.eclipse.jdt.internal.ui.text.correction.proposals.ASTRewriteCorrectionProposal;
Lines 201-206 Link Here
201	\|\| getConvertIterableLoopProposal(context, coveringNode, null)	203	\|\| getConvertIterableLoopProposal(context, coveringNode, null)
202	\|\| getRemoveBlockProposals(context, coveringNode, null)	204	\|\| getRemoveBlockProposals(context, coveringNode, null)
203	\|\| getMakeVariableDeclarationFinalProposals(context, null)	205	\|\| getMakeVariableDeclarationFinalProposals(context, null)
		206	\|\| getSortModifiersProposals(context, null)
204	\|\| getMissingCaseStatementProposals(context, coveringNode, null)	207	\|\| getMissingCaseStatementProposals(context, coveringNode, null)
205	\|\| getConvertStringConcatenationProposals(context, null);	208	\|\| getConvertStringConcatenationProposals(context, null);
206	}	209	}
Lines 239-244 Link Here
239	getConvertIterableLoopProposal(context, coveringNode, resultingCollections);	242	getConvertIterableLoopProposal(context, coveringNode, resultingCollections);
240	getRemoveBlockProposals(context, coveringNode, resultingCollections);	243	getRemoveBlockProposals(context, coveringNode, resultingCollections);
241	getMakeVariableDeclarationFinalProposals(context, resultingCollections);	244	getMakeVariableDeclarationFinalProposals(context, resultingCollections);
		245	getSortModifiersProposals(context, resultingCollections);
242	getConvertStringConcatenationProposals(context, resultingCollections);	246	getConvertStringConcatenationProposals(context, resultingCollections);
243	getMissingCaseStatementProposals(context, coveringNode, resultingCollections);	247	getMissingCaseStatementProposals(context, coveringNode, resultingCollections);
244	}	248	}
Lines 1872-1877 Link Here
1872	resultingCollections.add(proposal);	1876	resultingCollections.add(proposal);
1873	return true;	1877	return true;
1874	}	1878	}
		1879
		1880	private static boolean getSortModifiersProposals(IInvocationContext context, Collection resultingCollections) {
		1881	SelectionAnalyzer analyzer= new SelectionAnalyzer(Selection.createFromStartLength(context.getSelectionOffset(), context.getSelectionLength()), false);
		1882	context.getASTRoot().accept(analyzer);
		1883	ASTNode[] selectedNodes= analyzer.getSelectedNodes();
		1884	if (selectedNodes.length == 0)
		1885	return false;
		1886
		1887	IProposableFix fix= SortModifiersFix.createFix(context.getASTRoot(), selectedNodes);
		1888	if (fix == null)
		1889	return false;
		1890
		1891	if (resultingCollections == null)
		1892	return true;
		1893
		1894	Image image= JavaPluginImages.get(JavaPluginImages.IMG_CORRECTION_CHANGE);
		1895	Map options= new Hashtable();
		1896	options.put(CleanUpConstants.VARIABLE_DECLARATIONS_SORT_MODIFIERS, CleanUpOptions.TRUE);
		1897	SortModifiersCleanUp cleanUp= new SortModifiersCleanUp(options);
		1898	FixCorrectionProposal proposal= new FixCorrectionProposal(fix, cleanUp, 5, image, context);
		1899	resultingCollections.add(proposal);
		1900	return true;
		1901	}
1875		1902
1876	private static boolean getInlineLocalProposal(IInvocationContext context, final ASTNode node, Collection proposals) throws CoreException {	1903	private static boolean getInlineLocalProposal(IInvocationContext context, final ASTNode node, Collection proposals) throws CoreException {
1877	if (!(node instanceof SimpleName))	1904	if (!(node instanceof SimpleName))