Attachment #176664 for bug #322494




/*******************************************************************************
 * 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.corext.dom;

import org.eclipse.text.edits.TextEditGroup;

import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.BodyDeclaration;
import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;

public class CorrectModifiersOrderRewrite {

	public static void rewriteModifiers(final BodyDeclaration withModifiersNode, final ASTRewrite rewrite, final TextEditGroup group) {
		AST ast= withModifiersNode.getAST();

		BodyDeclaration withOrderedModifiersReplacementNode= (BodyDeclaration)ASTNode.copySubtree(ast, withModifiersNode);
		withOrderedModifiersReplacementNode.modifiers().clear();
		withOrderedModifiersReplacementNode.modifiers().addAll(ASTNodeFactory.newModifiers(ast, withModifiersNode.getModifiers()));

		rewrite.replace(withModifiersNode, withOrderedModifiersReplacementNode, group);
	}

}




	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. For detailed settings use:<br>
	 * {@link #VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_CLASSES}<br>
	 * {@link #VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_FIELDS}<br>
	 * {@link #VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_METHODS} <br>
	 * <br>
	 * Possible values: {TRUE, FALSE}<br>
	 * 
	 * <br>
	 * 
	 * @see CleanUpOptions#TRUE
	 * @see CleanUpOptions#FALSE
	 * @since 3.7
	 */
	public static final String VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER= "cleanup.correct_variable_modifiers_order"; //$NON-NLS-1$

	/**
	 * Correct modifiers order for classes i.e.:
	 * 
	 * <pre>
	 *                   abstract public class A {} -&gt; public abstract class A {}
	 * </pre>
	 * 
	 * Only has an effect if {@link #VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER} is TRUE <br>
	 * <br>
	 * Possible values: {TRUE, FALSE}<br>
	 * 
	 * <br>
	 * 
	 * @see CleanUpOptions#TRUE
	 * @see CleanUpOptions#FALSE
	 * @since 3.7
	 */
	public static final String VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_CLASSES= "cleanup.correct_class_modifiers_order"; //$NON-NLS-1$

	/**
	 * Correct modifiers order for fields i.e.:
	 * 
	 * <pre>
	 *                   static public final int FIELD= 0; -&gt; public static final int FIELD= 0;
	 * </pre>
	 * 
	 * Only has an effect if {@link #VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER} is TRUE <br>
	 * <br>
	 * Possible values: {TRUE, FALSE}<br>
	 * 
	 * <br>
	 * 
	 * @see CleanUpOptions#TRUE
	 * @see CleanUpOptions#FALSE
	 * @since 3.7
	 */
	public static final String VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_FIELDS= "cleanup.correct_field_modifiers_order"; //$NON-NLS-1$

	/**
	 * Correct modifiers order for methods i.e.:
	 * 
	 * <pre>
	 *                   final synchronized protected void foo() {} -&gt; synchronized protected final void foo() {}
	 * </pre>
	 * 
	 * Only has an effect if {@link #VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER} is TRUE <br>
	 * <br>
	 * Possible values: {TRUE, FALSE}<br>
	 * 
	 * <br>
	 * 
	 * @see CleanUpOptions#TRUE
	 * @see CleanUpOptions#FALSE
	 * @since 3.7
	 */
	public static final String VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_METHODS= "cleanup.correct_method_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);
		
		//Modifiers Order
		options.setOption(VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER, CleanUpOptions.FALSE);
		options.setOption(VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_CLASSES, CleanUpOptions.TRUE);
		options.setOption(VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_FIELDS, CleanUpOptions.TRUE);
		options.setOption(VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_METHODS, CleanUpOptions.TRUE);

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

		options.setOption(VARIABLE_DECLARATIONS_USE_FINAL_LOCAL_VARIABLES, CleanUpOptions.FALSE);
		options.setOption(VARIABLE_DECLARATIONS_USE_FINAL_PARAMETERS, CleanUpOptions.FALSE);
		options.setOption(VARIABLE_DECLARATIONS_USE_FINAL_PRIVATE_FIELDS, CleanUpOptions.TRUE);
		
		//Modifiers Order
		options.setOption(VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER, CleanUpOptions.TRUE);
		options.setOption(VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_CLASSES, CleanUpOptions.FALSE);
		options.setOption(VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_FIELDS, CleanUpOptions.FALSE);
		options.setOption(VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_METHODS, CleanUpOptions.TRUE);

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




/*******************************************************************************
 * 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.EnumConstantDeclaration;
import org.eclipse.jdt.core.dom.EnumDeclaration;
import org.eclipse.jdt.core.dom.FieldDeclaration;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.SimpleName;
import org.eclipse.jdt.core.dom.TypeDeclaration;
import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;

import org.eclipse.jdt.internal.corext.dom.CorrectModifiersOrderRewrite;
import org.eclipse.jdt.internal.corext.dom.GenericVisitor;
import org.eclipse.jdt.internal.corext.refactoring.structure.CompilationUnitRewrite;

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

public class CorrectModifiersOrderFix extends CompilationUnitRewriteOperationsFix {

	private static class WithModifiersNodeFinder extends GenericVisitor {

		private final boolean fCorrectModifiersOrderClasses;
		private final boolean fCorrectModifiersOrderFields;
		private final boolean fCorrectModifiersOrderMethods;
		private final List fWithModifiersNodes;
		private final List fOperations;

		public WithModifiersNodeFinder(boolean correctModifiersOrderClasses,
				boolean correctModifiersOrderFields,
				boolean correctModifiersOrderMethods,
				List withModifiersNodes,
				List operations) {
			fCorrectModifiersOrderClasses= correctModifiersOrderClasses;
			fCorrectModifiersOrderFields= correctModifiersOrderFields;
			fCorrectModifiersOrderMethods= correctModifiersOrderMethods;
			fWithModifiersNodes= withModifiersNodes;
			fOperations= operations;
		}

		/**
		 * {@inheritDoc}
		 */
		public void endVisit(TypeDeclaration node) {
			if (fCorrectModifiersOrderClasses && node.modifiers().size() > 1) {
				fWithModifiersNodes.add(node);
				fOperations.add(createCorrectModifiersOrderOperation(node));
			}
		}

		/**
		 * {@inheritDoc}
		 */
		public void endVisit(EnumDeclaration node) {
			if (fCorrectModifiersOrderClasses && node.modifiers().size() > 1) {
				fWithModifiersNodes.add(node);
				fOperations.add(createCorrectModifiersOrderOperation(node));
			}
		}

		/**
		 * {@inheritDoc}
		 */
		public void endVisit(EnumConstantDeclaration node) {
			if (fCorrectModifiersOrderClasses && node.modifiers().size() > 1) {
				fWithModifiersNodes.add(node);
				fOperations.add(createCorrectModifiersOrderOperation(node));
			}
		}

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

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

	}

	private static class CorrectModifiersOrderOperation extends CompilationUnitRewriteOperation {

		private final BodyDeclaration fWithModifiersNode;

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

		/**
		 * {@inheritDoc}
		 */
		public void rewriteAST(CompilationUnitRewrite cuRewrite, LinkedProposalModel model) throws CoreException {
			ASTRewrite rewrite= cuRewrite.getASTRewrite();

			TextEditGroup group= createTextEditGroup(FixMessages.VariableDeclarationFix_correctModifiersOrder_description, cuRewrite);

			CorrectModifiersOrderRewrite.rewriteModifiers(fWithModifiersNode, rewrite, group);
		}
	}

	private static CorrectModifiersOrderOperation createCorrectModifiersOrderOperation(BodyDeclaration withModifiersNode) {
		return new CorrectModifiersOrderOperation(withModifiersNode);
	}

	public static CorrectModifiersOrderFix createFix(final CompilationUnit compilationUnit, ASTNode[] selectedNodes) {
		List withModifiersNode= new LinkedList();
		List operations= new ArrayList();
		WithModifiersNodeFinder visitor= new WithModifiersNodeFinder(true, true, true, 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 CorrectModifiersOrderFix(FixMessages.VariableDeclarationFix_correctModifiersOrder_description, compilationUnit, fixRewriteOperations);
	}

	public static ICleanUpFix createCleanUp(CompilationUnit compilationUnit,
			boolean correctModifiersOrderClasses,
			boolean correctModifiersOrderFields,
			boolean correctModifiersOrderMethods) {
		if (!correctModifiersOrderClasses && !correctModifiersOrderFields && !correctModifiersOrderMethods)
			return null;

		List withModifiersNodes= new LinkedList();
		List operations= new ArrayList();
		WithModifiersNodeFinder finder= new WithModifiersNodeFinder(correctModifiersOrderClasses, correctModifiersOrderFields, correctModifiersOrderMethods, withModifiersNodes, operations);
		compilationUnit.accept(finder);

		CompilationUnitRewriteOperation[] fixRewriteOperations= (CompilationUnitRewriteOperation[])operations.toArray(new CompilationUnitRewriteOperation[operations.size()]);
		
		return new CorrectModifiersOrderFix(FixMessages.VariableDeclarationFix_add_final_change_name, compilationUnit, fixRewriteOperations);
	}

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

}

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_correctModifiersOrder_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_correctModifiersOrder_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}.

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.CorrectModifiersOrderCleanUp"
		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.CorrectModifiersOrderFix;

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

public class CorrectModifiersOrderCleanUp extends AbstractCleanUp {

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

	public CorrectModifiersOrderCleanUp() {
		super();
	}

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

	private boolean requireAST() {
		boolean addFinal= isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER);
		if (!addFinal)
			return false;

		return isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_CLASSES) ||
				isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_FIELDS) ||
				isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_METHODS);
	}

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

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

		return CorrectModifiersOrderFix.createCleanUp(compilationUnit,
				isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_CLASSES),
				isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_FIELDS),
				isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_METHODS));
	}

	/**
	 * {@inheritDoc}
	 */
	public String[] getStepDescriptions() {
		List result= new ArrayList();
		if (isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER) && isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_CLASSES))
			result.add(MultiFixMessages.VariableDeclarationCleanUp_AddFinalField_description);
		if (isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER) && isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_FIELDS))
			result.add(MultiFixMessages.VariableDeclarationCleanUp_AddFinalParameters_description);
		if (isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER) && isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_METHODS))
			result.add(MultiFixMessages.VariableDeclarationCleanUp_AddFinalLocals_description);

		return (String[])result.toArray(new String[result.size()]);
	}

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

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

		return buf.toString();
	}

}

Lines 91-96 Link Here

(-)ui/org/eclipse/jdt/internal/ui/fix/MultiFixMessages.java (+4 lines)
91	public static String VariableDeclarationCleanUp_AddFinalParameters_description;	91	public static String VariableDeclarationCleanUp_AddFinalParameters_description;
92	public static String VariableDeclarationCleanUp_AddFinalLocals_description;	92	public static String VariableDeclarationCleanUp_AddFinalLocals_description;
93		93
		94	public static String VariableDeclarationCleanUp_CorrectModifiersOrderClass_description;
		95	public static String VariableDeclarationCleanUp_CorrectModifiersOrderField_description;
		96	public static String VariableDeclarationCleanUp_CorrectModifiersOrderMethod_description;
		97
94	public static String CodeFormatCleanUp_description;	98	public static String CodeFormatCleanUp_description;
95	public static String CodeFormatFix_description;	99	public static String CodeFormatFix_description;
96		100

Lines 67-72 Link Here

(-)ui/org/eclipse/jdt/internal/ui/fix/MultiFixMessages.properties (+3 lines)
67	VariableDeclarationCleanUp_AddFinalField_description=Add final modifier to private fields	67	VariableDeclarationCleanUp_AddFinalField_description=Add final modifier to private fields
68	VariableDeclarationCleanUp_AddFinalParameters_description=Add final modifier to method parameters	68	VariableDeclarationCleanUp_AddFinalParameters_description=Add final modifier to method parameters
69	VariableDeclarationCleanUp_AddFinalLocals_description=Add final modifier to local variables	69	VariableDeclarationCleanUp_AddFinalLocals_description=Add final modifier to local variables
		70	VariableDeclarationCleanUp_CorrectModifiersOrderClass_description=Correct modifiers order to class declarations
		71	VariableDeclarationCleanUp_CorrectModifiersOrderField_description=Correct modifiers order to fields declarations
		72	VariableDeclarationCleanUp_CorrectModifiersOrderMethod_description=Correct modifiers order to methods declarations
70		73
71	CleanUpRefactoringWizard_CleanUpConfigurationPage_title=Clean Up Configuration	74	CleanUpRefactoringWizard_CleanUpConfigurationPage_title=Clean Up Configuration
72	CleanUpRefactoringWizard_UnmanagedProfileWithName_Name=Unmanaged profile ''{0}''	75	CleanUpRefactoringWizard_UnmanagedProfileWithName_Name=Unmanaged profile ''{0}''

Lines 53-58 Link Here

(-)ui/org/eclipse/jdt/internal/ui/preferences/cleanup/CleanUpMessages.java (+4 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_CorrectModifiersOrder;
		57	public static String CodeStyleTabPage_CheckboxName_CorrectModifiersOrderClasses;
		58	public static String CodeStyleTabPage_CheckboxName_CorrectModifiersOrderFields;
		59	public static String CodeStyleTabPage_CheckboxName_CorrectModifiersOrderMethods;
56	public static String CodeStyleTabPage_CheckboxName_UseParentheses;	60	public static String CodeStyleTabPage_CheckboxName_UseParentheses;
57	public static String CodeStyleTabPage_GroupName_ControlStatments;	61	public static String CodeStyleTabPage_GroupName_ControlStatments;
58	public static String CodeStyleTabPage_GroupName_Expressions;	62	public static String CodeStyleTabPage_GroupName_Expressions;

Lines 43-48 Link Here

(-)ui/org/eclipse/jdt/internal/ui/preferences/cleanup/CleanUpMessages.properties (+4 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_CorrectModifiersOrder=Correct modifiers order
		47	CodeStyleTabPage_CheckboxName_CorrectModifiersOrderClasses=Classes (and Enums)
		48	CodeStyleTabPage_CheckboxName_CorrectModifiersOrderFields=Fields
		49	CodeStyleTabPage_CheckboxName_CorrectModifiersOrderMethods=Methods
46	CodeStyleTabPage_CheckboxName_ConvertForLoopToEnhanced=Conver&t for loops to enhanced	50	CodeStyleTabPage_CheckboxName_ConvertForLoopToEnhanced=Conver&t for loops to enhanced
47	CodeStyleTabPage_GroupName_ControlStatments=Control statements	51	CodeStyleTabPage_GroupName_ControlStatments=Control statements
48	CodeStyleTabPage_RadioName_UseBlocksSpecial=Always &except for single 'return' or 'throw' statements	52	CodeStyleTabPage_RadioName_UseBlocksSpecial=Always &except for single 'return' or 'throw' statements

Lines 72-76 Link Here

(-)ui/org/eclipse/jdt/internal/ui/preferences/cleanup/CodeStyleTabPage.java (+7 lines)
72	final CheckboxPreference useFinalParametersPref= createCheckboxPref(variableGroup, 1, CleanUpMessages.CodeStyleTabPage_CheckboxName_UseFinalForParameters, CleanUpConstants.VARIABLE_DECLARATIONS_USE_FINAL_PARAMETERS, CleanUpModifyDialog.FALSE_TRUE);	72	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);	73	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});	74	registerSlavePreference(useFinalPref, new CheckboxPreference[] {useFinalFieldsPref, useFinalParametersPref, useFinalVariablesPref});
		75
		76	final CheckboxPreference correctModifiersOrderPref= createCheckboxPref(variableGroup, numColumns, CleanUpMessages.CodeStyleTabPage_CheckboxName_CorrectModifiersOrder, CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER, CleanUpModifyDialog.FALSE_TRUE);
		77	intent(variableGroup);
		78	final CheckboxPreference correctModifiersOrderClassesPref= createCheckboxPref(variableGroup, 1, CleanUpMessages.CodeStyleTabPage_CheckboxName_CorrectModifiersOrderClasses, CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_CLASSES, CleanUpModifyDialog.FALSE_TRUE);
		79	final CheckboxPreference correctModifiersOrderFieldsPref= createCheckboxPref(variableGroup, 1, CleanUpMessages.CodeStyleTabPage_CheckboxName_CorrectModifiersOrderFields, CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_FIELDS, CleanUpModifyDialog.FALSE_TRUE);
		80	final CheckboxPreference correctModifiersOrderMethodsPref= createCheckboxPref(variableGroup, 1, CleanUpMessages.CodeStyleTabPage_CheckboxName_CorrectModifiersOrderMethods, CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_METHODS, CleanUpModifyDialog.FALSE_TRUE);
		81	registerSlavePreference(correctModifiersOrderPref, new CheckboxPreference[] {correctModifiersOrderClassesPref, correctModifiersOrderFieldsPref, correctModifiersOrderMethodsPref});
75	}	82	}
76	}	83	}




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.CorrectModifiersOrderFix;
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.CorrectModifiersOrderCleanUp;
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)
				|| getCorrectModifiersOrderProposals(context, null)
				|| getMissingCaseStatementProposals(context, coveringNode, null)
				|| getConvertStringConcatenationProposals(context, null);
		}

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

		resultingCollections.add(proposal);
		return true;
	}
	
	private static boolean getCorrectModifiersOrderProposals(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= CorrectModifiersOrderFix.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_CORRECT_MODIFIERS_ORDER, CleanUpOptions.TRUE);
		options.put(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_CLASSES, CleanUpOptions.TRUE);
		options.put(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_FIELDS, CleanUpOptions.TRUE);
		options.put(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_METHODS, CleanUpOptions.TRUE);
		CorrectModifiersOrderCleanUp cleanUp= new CorrectModifiersOrderCleanUp(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

Lines 663-668 Link Here

(-)core extension/org/eclipse/jdt/internal/corext/fix/CleanUpConstants.java (+85 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. For detailed settings use:<br>
		667	* {@link #VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_CLASSES}<br>
		668	* {@link #VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_FIELDS}<br>
		669	* {@link #VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_METHODS} <br>
		670	* <br>
		671	* Possible values: {TRUE, FALSE}<br>
		672	*
		673	* <br>
		674	*
		675	* @see CleanUpOptions#TRUE
		676	* @see CleanUpOptions#FALSE
		677	* @since 3.7
		678	*/
		679	public static final String VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER= "cleanup.correct_variable_modifiers_order"; //$NON-NLS-1$
		680
		681	/**
		682	* Correct modifiers order for classes i.e.:
		683	*
		684	* <pre>
		685	* abstract public class A {} -> public abstract class A {}
		686	* </pre>
		687	*
		688	* Only has an effect if {@link #VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER} is TRUE <br>
		689	* <br>
		690	* Possible values: {TRUE, FALSE}<br>
		691	*
		692	* <br>
		693	*
		694	* @see CleanUpOptions#TRUE
		695	* @see CleanUpOptions#FALSE
		696	* @since 3.7
		697	*/
		698	public static final String VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_CLASSES= "cleanup.correct_class_modifiers_order"; //$NON-NLS-1$
		699
		700	/**
		701	* Correct modifiers order for fields i.e.:
		702	*
		703	* <pre>
		704	* static public final int FIELD= 0; -> public static final int FIELD= 0;
		705	* </pre>
		706	*
		707	* Only has an effect if {@link #VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER} is TRUE <br>
		708	* <br>
		709	* Possible values: {TRUE, FALSE}<br>
		710	*
		711	* <br>
		712	*
		713	* @see CleanUpOptions#TRUE
		714	* @see CleanUpOptions#FALSE
		715	* @since 3.7
		716	*/
		717	public static final String VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_FIELDS= "cleanup.correct_field_modifiers_order"; //$NON-NLS-1$
		718
		719	/**
		720	* Correct modifiers order for methods i.e.:
		721	*
		722	* <pre>
		723	* final synchronized protected void foo() {} -> synchronized protected final void foo() {}
		724	* </pre>
		725	*
		726	* Only has an effect if {@link #VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER} is TRUE <br>
		727	* <br>
		728	* Possible values: {TRUE, FALSE}<br>
		729	*
730	* <br>
731	*
732	* @see CleanUpOptions#TRUE
733	* @see CleanUpOptions#FALSE
734	* @since 3.7
735	*/
736	public static final String VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_METHODS= "cleanup.correct_method_modifiers_order"; //$NON-NLS-1$
737
738	/**
666	* Removes unused imports. <br>	739	* Removes unused imports. <br>
667	* <br>	740	* <br>
668	* Possible values: {TRUE, FALSE}<br>	741	* Possible values: {TRUE, FALSE}<br>
Lines 1135-1140 Link Here
1135	options.setOption(VARIABLE_DECLARATIONS_USE_FINAL_LOCAL_VARIABLES, CleanUpOptions.TRUE);	1208	options.setOption(VARIABLE_DECLARATIONS_USE_FINAL_LOCAL_VARIABLES, CleanUpOptions.TRUE);
1136	options.setOption(VARIABLE_DECLARATIONS_USE_FINAL_PARAMETERS, CleanUpOptions.FALSE);	1209	options.setOption(VARIABLE_DECLARATIONS_USE_FINAL_PARAMETERS, CleanUpOptions.FALSE);
1137	options.setOption(VARIABLE_DECLARATIONS_USE_FINAL_PRIVATE_FIELDS, CleanUpOptions.TRUE);	1210	options.setOption(VARIABLE_DECLARATIONS_USE_FINAL_PRIVATE_FIELDS, CleanUpOptions.TRUE);
		1211
		1212	//Modifiers Order
		1213	options.setOption(VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER, CleanUpOptions.FALSE);
		1214	options.setOption(VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_CLASSES, CleanUpOptions.TRUE);
		1215	options.setOption(VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_FIELDS, CleanUpOptions.TRUE);
		1216	options.setOption(VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_METHODS, CleanUpOptions.TRUE);
1138		1217
1139	//Unused Code	1218	//Unused Code
1140	options.setOption(REMOVE_UNUSED_CODE_IMPORTS, CleanUpOptions.TRUE);	1219	options.setOption(REMOVE_UNUSED_CODE_IMPORTS, CleanUpOptions.TRUE);
Lines 1215-1220 Link Here
1215	options.setOption(VARIABLE_DECLARATIONS_USE_FINAL_LOCAL_VARIABLES, CleanUpOptions.FALSE);	1294	options.setOption(VARIABLE_DECLARATIONS_USE_FINAL_LOCAL_VARIABLES, CleanUpOptions.FALSE);
1216	options.setOption(VARIABLE_DECLARATIONS_USE_FINAL_PARAMETERS, CleanUpOptions.FALSE);	1295	options.setOption(VARIABLE_DECLARATIONS_USE_FINAL_PARAMETERS, CleanUpOptions.FALSE);
1217	options.setOption(VARIABLE_DECLARATIONS_USE_FINAL_PRIVATE_FIELDS, CleanUpOptions.TRUE);	1296	options.setOption(VARIABLE_DECLARATIONS_USE_FINAL_PRIVATE_FIELDS, CleanUpOptions.TRUE);
		1297
		1298	//Modifiers Order
		1299	options.setOption(VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER, CleanUpOptions.TRUE);
		1300	options.setOption(VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_CLASSES, CleanUpOptions.FALSE);
		1301	options.setOption(VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_FIELDS, CleanUpOptions.FALSE);
		1302	options.setOption(VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_METHODS, CleanUpOptions.TRUE);
1218		1303
1219	//Unused Code	1304	//Unused Code
1220	options.setOption(REMOVE_UNUSED_CODE_IMPORTS, CleanUpOptions.FALSE);	1305	options.setOption(REMOVE_UNUSED_CODE_IMPORTS, CleanUpOptions.FALSE);

Added Link Here

(-)core (+32 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.corext.dom;
12
13	import org.eclipse.text.edits.TextEditGroup;
14
15	import org.eclipse.jdt.core.dom.AST;
16	import org.eclipse.jdt.core.dom.ASTNode;
17	import org.eclipse.jdt.core.dom.BodyDeclaration;
18	import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
19
20	public class CorrectModifiersOrderRewrite {
21
22	public static void rewriteModifiers(final BodyDeclaration withModifiersNode, final ASTRewrite rewrite, final TextEditGroup group) {
23	AST ast= withModifiersNode.getAST();
24
25	BodyDeclaration withOrderedModifiersReplacementNode= (BodyDeclaration)ASTNode.copySubtree(ast, withModifiersNode);
26	withOrderedModifiersReplacementNode.modifiers().clear();
27	withOrderedModifiersReplacementNode.modifiers().addAll(ASTNodeFactory.newModifiers(ast, withModifiersNode.getModifiers()));
28
29	rewrite.replace(withModifiersNode, withOrderedModifiersReplacementNode, group);
30	}
31
32	}

Added Link Here

(-)core (+184 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.EnumConstantDeclaration;
26	import org.eclipse.jdt.core.dom.EnumDeclaration;
27	import org.eclipse.jdt.core.dom.FieldDeclaration;
28	import org.eclipse.jdt.core.dom.MethodDeclaration;
29	import org.eclipse.jdt.core.dom.SimpleName;
30	import org.eclipse.jdt.core.dom.TypeDeclaration;
31	import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
32
33	import org.eclipse.jdt.internal.corext.dom.CorrectModifiersOrderRewrite;
34	import org.eclipse.jdt.internal.corext.dom.GenericVisitor;
35	import org.eclipse.jdt.internal.corext.refactoring.structure.CompilationUnitRewrite;
36
37	import org.eclipse.jdt.ui.cleanup.ICleanUpFix;
38
39	public class CorrectModifiersOrderFix extends CompilationUnitRewriteOperationsFix {
40
41	private static class WithModifiersNodeFinder extends GenericVisitor {
42
43	private final boolean fCorrectModifiersOrderClasses;
44	private final boolean fCorrectModifiersOrderFields;
45	private final boolean fCorrectModifiersOrderMethods;
46	private final List fWithModifiersNodes;
47	private final List fOperations;
48
49	public WithModifiersNodeFinder(boolean correctModifiersOrderClasses,
50	boolean correctModifiersOrderFields,
51	boolean correctModifiersOrderMethods,
52	List withModifiersNodes,
53	List operations) {
54	fCorrectModifiersOrderClasses= correctModifiersOrderClasses;
55	fCorrectModifiersOrderFields= correctModifiersOrderFields;
56	fCorrectModifiersOrderMethods= correctModifiersOrderMethods;
57	fWithModifiersNodes= withModifiersNodes;
58	fOperations= operations;
59	}
60
61	/**
62	* {@inheritDoc}
63	*/
64	public void endVisit(TypeDeclaration node) {
65	if (fCorrectModifiersOrderClasses && node.modifiers().size() > 1) {
66	fWithModifiersNodes.add(node);
67	fOperations.add(createCorrectModifiersOrderOperation(node));
68	}
69	}
70
71	/**
72	* {@inheritDoc}
73	*/
74	public void endVisit(EnumDeclaration node) {
75	if (fCorrectModifiersOrderClasses && node.modifiers().size() > 1) {
76	fWithModifiersNodes.add(node);
77	fOperations.add(createCorrectModifiersOrderOperation(node));
78	}
79	}
80
81	/**
82	* {@inheritDoc}
83	*/
84	public void endVisit(EnumConstantDeclaration node) {
85	if (fCorrectModifiersOrderClasses && node.modifiers().size() > 1) {
86	fWithModifiersNodes.add(node);
87	fOperations.add(createCorrectModifiersOrderOperation(node));
88	}
89	}
90
91	/**
92	* {@inheritDoc}
93	*/
94	public boolean visit(FieldDeclaration node) {
95	if (fCorrectModifiersOrderFields && node.modifiers().size() > 1) {
96	fWithModifiersNodes.add(node);
97	fOperations.add(createCorrectModifiersOrderOperation(node));
98	}
99	return super.visit(node);
100	}
101
102	/**
103	* {@inheritDoc}
104	*/
105	public boolean visit(MethodDeclaration node) {
106	if (fCorrectModifiersOrderMethods && node.modifiers().size() > 1) {
107	fWithModifiersNodes.add(node);
108	fOperations.add(createCorrectModifiersOrderOperation(node));
109	}
110	return super.visit(node);
111	}
112
113	}
114
115	private static class CorrectModifiersOrderOperation extends CompilationUnitRewriteOperation {
116
117	private final BodyDeclaration fWithModifiersNode;
118
119	public CorrectModifiersOrderOperation(BodyDeclaration withModifiersNode) {
120	fWithModifiersNode= withModifiersNode;
121	}
122
123	/**
124	* {@inheritDoc}
125	*/
126	public void rewriteAST(CompilationUnitRewrite cuRewrite, LinkedProposalModel model) throws CoreException {
127	ASTRewrite rewrite= cuRewrite.getASTRewrite();
128
129	TextEditGroup group= createTextEditGroup(FixMessages.VariableDeclarationFix_correctModifiersOrder_description, cuRewrite);
130
131	CorrectModifiersOrderRewrite.rewriteModifiers(fWithModifiersNode, rewrite, group);
132	}
133	}
134
135	private static CorrectModifiersOrderOperation createCorrectModifiersOrderOperation(BodyDeclaration withModifiersNode) {
136	return new CorrectModifiersOrderOperation(withModifiersNode);
137	}
138
139	public static CorrectModifiersOrderFix createFix(final CompilationUnit compilationUnit, ASTNode[] selectedNodes) {
140	List withModifiersNode= new LinkedList();
141	List operations= new ArrayList();
142	WithModifiersNodeFinder visitor= new WithModifiersNodeFinder(true, true, true, withModifiersNode, operations);
143	compilationUnit.accept(visitor);
144	if (selectedNodes.length == 1) {
145	if (selectedNodes[0] instanceof SimpleName) {
146	selectedNodes[0]= selectedNodes[0].getParent();
147	}
148	selectedNodes[0].accept(visitor);
149	} else {
150	for (int i= 0; i < selectedNodes.length; i++) {
151	ASTNode selectedNode= selectedNodes[i];
152	selectedNode.accept(visitor);
153	}
154	}
155	if (operations.size() == 0)
156	return null;
157
158	CompilationUnitRewriteOperation[] fixRewriteOperations= (CompilationUnitRewriteOperation[])operations.toArray(new CompilationUnitRewriteOperation[operations.size()]);
159
160	return new CorrectModifiersOrderFix(FixMessages.VariableDeclarationFix_correctModifiersOrder_description, compilationUnit, fixRewriteOperations);
161	}
162
163	public static ICleanUpFix createCleanUp(CompilationUnit compilationUnit,
164	boolean correctModifiersOrderClasses,
165	boolean correctModifiersOrderFields,
166	boolean correctModifiersOrderMethods) {
167	if (!correctModifiersOrderClasses && !correctModifiersOrderFields && !correctModifiersOrderMethods)
168	return null;
169
170	List withModifiersNodes= new LinkedList();
171	List operations= new ArrayList();
172	WithModifiersNodeFinder finder= new WithModifiersNodeFinder(correctModifiersOrderClasses, correctModifiersOrderFields, correctModifiersOrderMethods, withModifiersNodes, operations);
173	compilationUnit.accept(finder);
174
175	CompilationUnitRewriteOperation[] fixRewriteOperations= (CompilationUnitRewriteOperation[])operations.toArray(new CompilationUnitRewriteOperation[operations.size()]);
176
177	return new CorrectModifiersOrderFix(FixMessages.VariableDeclarationFix_add_final_change_name, compilationUnit, fixRewriteOperations);
178	}
179
180	protected CorrectModifiersOrderFix(String name, CompilationUnit compilationUnit, CompilationUnitRewriteOperation[] fixRewriteOperations) {
181	super(name, compilationUnit, fixRewriteOperations);
182	}
183
184	}

Added Link Here

(-)ui/org/eclipse/jdt/internal/ui/fix/CorrectModifiersOrderCleanUp.java (+114 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.CorrectModifiersOrderFix;
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 CorrectModifiersOrderCleanUp extends AbstractCleanUp {
29
30	public CorrectModifiersOrderCleanUp(Map options) {
31	super(options);
32	}
33
34	public CorrectModifiersOrderCleanUp() {
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	boolean addFinal= isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER);
47	if (!addFinal)
48	return false;
49
50	return isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_CLASSES) \|\|
51	isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_FIELDS) \|\|
52	isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_METHODS);
53	}
54
55	/**
56	* {@inheritDoc}
57	*/
58	public ICleanUpFix createFix(CleanUpContext context) throws CoreException {
59	CompilationUnit compilationUnit= context.getAST();
60	if (compilationUnit == null)
61	return null;
62
63	boolean addFinal= isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER);
64	if (!addFinal)
65	return null;
66
67	return CorrectModifiersOrderFix.createCleanUp(compilationUnit,
68	isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_CLASSES),
69	isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_FIELDS),
70	isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_METHODS));
71	}
72
73	/**
74	* {@inheritDoc}
75	*/
76	public String[] getStepDescriptions() {
77	List result= new ArrayList();
78	if (isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER) && isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_CLASSES))
79	result.add(MultiFixMessages.VariableDeclarationCleanUp_AddFinalField_description);
80	if (isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER) && isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_FIELDS))
81	result.add(MultiFixMessages.VariableDeclarationCleanUp_AddFinalParameters_description);
82	if (isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER) && isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_METHODS))
83	result.add(MultiFixMessages.VariableDeclarationCleanUp_AddFinalLocals_description);
84
85	return (String[])result.toArray(new String[result.size()]);
86	}
87
88	/**
89	* {@inheritDoc}
90	*/
91	public String getPreview() {
92	StringBuffer buf= new StringBuffer();
93
94	if (isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER) && isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_CLASSES)) {
95	buf.append("abstract public class A {\n"); //$NON-NLS-1$
96	} else {
97	buf.append("public abstract class A {\n"); //$NON-NLS-1$
98	}
99	if (isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER) && isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_FIELDS)) {
100	buf.append(" static public final int FIELD= 0;\n"); //$NON-NLS-1$
101	} else {
102	buf.append(" public static final int FIELD= 0;\n"); //$NON-NLS-1$
103	}
104	if (isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER) && isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_METHODS)) {
105	buf.append(" final synchronized protected void foo() {}\n"); //$NON-NLS-1$
106	} else {
107	buf.append(" synchronized protected final void foo() {}\n"); //$NON-NLS-1$
108	}
109	buf.append("}\n"); //$NON-NLS-1$
110
111	return buf.toString();
112	}
113
114	}

Lines 115-120 Link Here

(-)ui/org/eclipse/jdt/internal/ui/text/correction/QuickAssistProcessor.java (+30 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.CorrectModifiersOrderFix;
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.CorrectModifiersOrderCleanUp;
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	\|\| getCorrectModifiersOrderProposals(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	getCorrectModifiersOrderProposals(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 getCorrectModifiersOrderProposals(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= CorrectModifiersOrderFix.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_CORRECT_MODIFIERS_ORDER, CleanUpOptions.TRUE);
		1897	options.put(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_CLASSES, CleanUpOptions.TRUE);
		1898	options.put(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_FIELDS, CleanUpOptions.TRUE);
		1899	options.put(CleanUpConstants.VARIABLE_DECLARATIONS_CORRECT_MODIFIERS_ORDER_METHODS, CleanUpOptions.TRUE);
		1900	CorrectModifiersOrderCleanUp cleanUp= new CorrectModifiersOrderCleanUp(options);
		1901	FixCorrectionProposal proposal= new FixCorrectionProposal(fix, cleanUp, 5, image, context);
		1902	resultingCollections.add(proposal);
		1903	return true;
		1904	}
1875		1905
1876	private static boolean getInlineLocalProposal(IInvocationContext context, final ASTNode node, Collection proposals) throws CoreException {	1906	private static boolean getInlineLocalProposal(IInvocationContext context, final ASTNode node, Collection proposals) throws CoreException {
1877	if (!(node instanceof SimpleName))	1907	if (!(node instanceof SimpleName))