--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2000, 2011 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.internal.corext.fix;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import org.eclipse.swt.widgets.Display;
+
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.core.runtime.OperationCanceledException;
+import org.eclipse.core.runtime.SubProgressMonitor;
+import org.eclipse.core.runtime.jobs.ISchedulingRule;
+
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.ProjectScope;
+import org.eclipse.core.resources.ResourcesPlugin;
+
+import org.eclipse.text.edits.MalformedTreeException;
+import org.eclipse.text.edits.TextEdit;
+import org.eclipse.text.edits.TextEditGroup;
+import org.eclipse.text.edits.UndoEdit;
+
+import org.eclipse.jface.text.BadLocationException;
+import org.eclipse.jface.text.Document;
+import org.eclipse.jface.text.IDocument;
+
+import org.eclipse.ltk.core.refactoring.CategorizedTextEditGroup;
+import org.eclipse.ltk.core.refactoring.Change;
+import org.eclipse.ltk.core.refactoring.CompositeChange;
+import org.eclipse.ltk.core.refactoring.ContentStamp;
+import org.eclipse.ltk.core.refactoring.GroupCategory;
+import org.eclipse.ltk.core.refactoring.GroupCategorySet;
+import org.eclipse.ltk.core.refactoring.NullChange;
+import org.eclipse.ltk.core.refactoring.Refactoring;
+import org.eclipse.ltk.core.refactoring.RefactoringStatus;
+import org.eclipse.ltk.core.refactoring.RefactoringTickProvider;
+import org.eclipse.ltk.core.refactoring.TextChange;
+import org.eclipse.ltk.core.refactoring.TextEditBasedChangeGroup;
+import org.eclipse.ltk.core.refactoring.TextFileChange;
+
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.IPackageFragment;
+import org.eclipse.jdt.core.JavaModelException;
+import org.eclipse.jdt.core.WorkingCopyOwner;
+import org.eclipse.jdt.core.dom.ASTParser;
+import org.eclipse.jdt.core.dom.ASTRequestor;
+import org.eclipse.jdt.core.dom.CompilationUnit;
+import org.eclipse.jdt.core.refactoring.CompilationUnitChange;
+
+import org.eclipse.jdt.internal.corext.dom.ASTBatchParser;
+import org.eclipse.jdt.internal.corext.refactoring.Checks;
+import org.eclipse.jdt.internal.corext.refactoring.changes.DynamicValidationStateChange;
+import org.eclipse.jdt.internal.corext.refactoring.changes.MultiStateCompilationUnitChange;
+import org.eclipse.jdt.internal.corext.refactoring.util.RefactoringASTParser;
+import org.eclipse.jdt.internal.corext.refactoring.util.TextEditUtil;
+import org.eclipse.jdt.internal.corext.util.Messages;
+
+import org.eclipse.jdt.ui.JavaElementLabels;
+import org.eclipse.jdt.ui.cleanup.CleanUpContext;
+import org.eclipse.jdt.ui.cleanup.CleanUpOptions;
+import org.eclipse.jdt.ui.cleanup.ICleanUp;
+import org.eclipse.jdt.ui.cleanup.ICleanUpFix;
+import org.eclipse.jdt.ui.text.java.IProblemLocation;
+
+import org.eclipse.jdt.internal.ui.JavaPlugin;
+import org.eclipse.jdt.internal.ui.fix.IMultiFix.MultiFixContext;
+import org.eclipse.jdt.internal.ui.fix.MapCleanUpOptions;
+import org.eclipse.jdt.internal.ui.javaeditor.ASTProvider;
+import org.eclipse.jdt.internal.ui.refactoring.IScheduledRefactoring;
+import org.eclipse.jdt.internal.ui.viewsupport.BasicElementLabels;
+
+public class CleanUpRefactoring extends Refactoring implements IScheduledRefactoring {
+
+ public static class CleanUpTarget {
+
+ private final ICompilationUnit fCompilationUnit;
+
+ public CleanUpTarget(ICompilationUnit unit) {
+ fCompilationUnit= unit;
+ }
+
+ public ICompilationUnit getCompilationUnit() {
+ return fCompilationUnit;
+ }
+ }
+
+ public static class MultiFixTarget extends CleanUpTarget {
+
+ private final IProblemLocation[] fProblems;
+
+ public MultiFixTarget(ICompilationUnit unit, IProblemLocation[] problems) {
+ super(unit);
+ fProblems= problems;
+ }
+
+ public IProblemLocation[] getProblems() {
+ return fProblems;
+ }
+ }
+
+ public static class CleanUpChange extends CompilationUnitChange {
+
+ private UndoEdit fUndoEdit;
+
+ public CleanUpChange(String name, ICompilationUnit cunit) {
+ super(name, cunit);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ protected Change createUndoChange(UndoEdit edit, ContentStamp stampToRestore) {
+ fUndoEdit= edit;
+ return super.createUndoChange(edit, stampToRestore);
+ }
+
+ public UndoEdit getUndoEdit() {
+ return fUndoEdit;
+ }
+
+ /*
+ * @see org.eclipse.ltk.core.refactoring.TextChange#perform(org.eclipse.core.runtime.IProgressMonitor)
+ */
+ @Override
+ public Change perform(final IProgressMonitor pm) throws CoreException {
+ if (Display.getCurrent() == null) {
+ final Change[] result= new Change[1];
+ final CoreException[] exs= new CoreException[1];
+ Display.getDefault().syncExec(new Runnable() {
+ public void run() {
+ try {
+ result[0]= CleanUpChange.super.perform(pm);
+ } catch (CoreException e) {
+ exs[0]= e;
+ }
+ }
+ });
+
+ if (exs[0] != null)
+ throw exs[0];
+
+ return result[0];
+ } else {
+ return super.perform(pm);
+ }
+ }
+ }
+
+ private static class FixCalculationException extends RuntimeException {
+
+ private static final long serialVersionUID= 3807273310144726165L;
+
+ private final CoreException fException;
+
+ public FixCalculationException(CoreException exception) {
+ fException= exception;
+ }
+
+ public CoreException getException() {
+ return fException;
+ }
+ }
+
+ private static class ParseListElement {
+
+ private final CleanUpTarget fTarget;
+ private final ICleanUp[] fCleanUpsArray;
+
+ public ParseListElement(CleanUpTarget cleanUpTarget, ICleanUp[] cleanUps) {
+ fTarget= cleanUpTarget;
+ fCleanUpsArray= cleanUps;
+ }
+
+ public CleanUpTarget getTarget() {
+ return fTarget;
+ }
+
+ public ICleanUp[] getCleanUps() {
+ return fCleanUpsArray;
+ }
+ }
+
+ private final class CleanUpRefactoringProgressMonitor extends SubProgressMonitor {
+
+ private double fRealWork;
+ private int fFlushCount;
+ private final int fSize;
+ private final int fIndex;
+
+ private CleanUpRefactoringProgressMonitor(IProgressMonitor monitor, int ticks, int size, int index) {
+ super(monitor, ticks);
+ fFlushCount= 0;
+ fSize= size;
+ fIndex= index;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void internalWorked(double work) {
+ fRealWork+= work;
+ }
+
+ public void flush() {
+ super.internalWorked(fRealWork);
+ reset();
+ fFlushCount++;
+ }
+
+ public void reset() {
+ fRealWork= 0.0;
+ }
+
+ @Override
+ public void done() {}
+
+ public int getIndex() {
+ return fIndex + fFlushCount;
+ }
+
+ public String getSubTaskMessage(ICompilationUnit source) {
+ String typeName= BasicElementLabels.getFileName(source);
+ return Messages.format(FixMessages.CleanUpRefactoring_ProcessingCompilationUnit_message, new Object[] {new Integer(getIndex()), new Integer(fSize), typeName});
+ }
+ }
+
+ private static class CleanUpASTRequestor extends ASTRequestor {
+
+ private final List<ParseListElement> fUndoneElements;
+ private final Hashtable<ICompilationUnit, List<CleanUpChange>> fSolutions;
+ private final Hashtable<ICompilationUnit, ParseListElement> fCompilationUnitParseElementMap;
+ private final CleanUpRefactoringProgressMonitor fMonitor;
+
+ public CleanUpASTRequestor(List<ParseListElement> parseList, Hashtable<ICompilationUnit, List<CleanUpChange>> solutions, CleanUpRefactoringProgressMonitor monitor) {
+ fSolutions= solutions;
+ fMonitor= monitor;
+ fUndoneElements= new ArrayList<ParseListElement>();
+ fCompilationUnitParseElementMap= new Hashtable<ICompilationUnit, ParseListElement>(parseList.size());
+ for (Iterator<ParseListElement> iter= parseList.iterator(); iter.hasNext();) {
+ ParseListElement element= iter.next();
+ fCompilationUnitParseElementMap.put(element.getTarget().getCompilationUnit(), element);
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void acceptAST(ICompilationUnit source, CompilationUnit ast) {
+
+ fMonitor.subTask(fMonitor.getSubTaskMessage(source));
+
+ ICompilationUnit primary= (ICompilationUnit)source.getPrimaryElement();
+ ParseListElement element= fCompilationUnitParseElementMap.get(primary);
+ CleanUpTarget target= element.getTarget();
+
+ CleanUpContext context;
+ if (target instanceof MultiFixTarget) {
+ context= new MultiFixContext(source, ast, ((MultiFixTarget)target).getProblems());
+ } else {
+ context= new CleanUpContext(source, ast);
+ }
+ ICleanUp[] rejectedCleanUps= calculateSolutions(context, element.getCleanUps());
+
+ if (rejectedCleanUps.length > 0) {
+ fUndoneElements.add(new ParseListElement(target, rejectedCleanUps));
+ fMonitor.reset();
+ } else {
+ fMonitor.flush();
+ }
+ }
+
+ public void acceptSource(ICompilationUnit source) {
+ acceptAST(source, null);
+ }
+
+ public List<ParseListElement> getUndoneElements() {
+ return fUndoneElements;
+ }
+
+ private ICleanUp[] calculateSolutions(CleanUpContext context, ICleanUp[] cleanUps) {
+ List<ICleanUp>result= new ArrayList<ICleanUp>();
+ CleanUpChange solution;
+ try {
+ solution= calculateChange(context, cleanUps, result, null);
+ } catch (CoreException e) {
+ throw new FixCalculationException(e);
+ }
+
+ if (solution != null) {
+ integrateSolution(solution, context.getCompilationUnit());
+ }
+
+ return result.toArray(new ICleanUp[result.size()]);
+ }
+
+ private void integrateSolution(CleanUpChange solution, ICompilationUnit source) {
+ ICompilationUnit primary= source.getPrimary();
+
+ List<CleanUpChange> changes= fSolutions.get(primary);
+ if (changes == null) {
+ changes= new ArrayList<CleanUpChange>();
+ fSolutions.put(primary, changes);
+ }
+ changes.add(solution);
+ }
+ }
+
+ private class CleanUpFixpointIterator {
+
+ private List<ParseListElement> fParseList;
+ private final Hashtable<ICompilationUnit, List<CleanUpChange>> fSolutions;
+ private final Hashtable<ICompilationUnit, ICompilationUnit> fWorkingCopies; // map from primary to working copy
+ private final Map<String, String> fCleanUpOptions;
+ private final int fSize;
+ private int fIndex;
+
+ public CleanUpFixpointIterator(CleanUpTarget[] targets, ICleanUp[] cleanUps) {
+ fSolutions= new Hashtable<ICompilationUnit, List<CleanUpChange>>(targets.length);
+ fWorkingCopies= new Hashtable<ICompilationUnit, ICompilationUnit>();
+
+ fParseList= new ArrayList<ParseListElement>(targets.length);
+ for (int i= 0; i < targets.length; i++) {
+ fParseList.add(new ParseListElement(targets[i], cleanUps));
+ }
+
+ fCleanUpOptions= new Hashtable<String, String>();
+ for (int i= 0; i < cleanUps.length; i++) {
+ ICleanUp cleanUp= cleanUps[i];
+ Map<String, String> currentCleanUpOption= cleanUp.getRequirements().getCompilerOptions();
+ if (currentCleanUpOption != null)
+ fCleanUpOptions.putAll(currentCleanUpOption);
+ }
+
+ fSize= targets.length;
+ fIndex= 1;
+ }
+
+ public boolean hasNext() {
+ return !fParseList.isEmpty();
+ }
+
+ public void next(IProgressMonitor monitor) throws CoreException {
+ List<ICompilationUnit> parseList= new ArrayList<ICompilationUnit>();
+ List<ICompilationUnit> sourceList= new ArrayList<ICompilationUnit>();
+
+ try {
+ for (Iterator<ParseListElement> iter= fParseList.iterator(); iter.hasNext();) {
+ ParseListElement element= iter.next();
+
+ ICompilationUnit compilationUnit= element.getTarget().getCompilationUnit();
+ if (fSolutions.containsKey(compilationUnit)) {
+ if (fWorkingCopies.containsKey(compilationUnit)) {
+ compilationUnit= fWorkingCopies.get(compilationUnit);
+ } else {
+ compilationUnit= compilationUnit.getWorkingCopy(new WorkingCopyOwner() {}, null);
+ fWorkingCopies.put(compilationUnit.getPrimary(), compilationUnit);
+ }
+ applyChange(compilationUnit, fSolutions.get(compilationUnit.getPrimary()));
+ }
+
+ if (requiresAST(element.getCleanUps())) {
+ parseList.add(compilationUnit);
+ } else {
+ sourceList.add(compilationUnit);
+ }
+ }
+
+ CleanUpRefactoringProgressMonitor cuMonitor= new CleanUpRefactoringProgressMonitor(monitor, parseList.size() + sourceList.size(), fSize, fIndex);
+ CleanUpASTRequestor requestor= new CleanUpASTRequestor(fParseList, fSolutions, cuMonitor);
+ if (parseList.size() > 0) {
+ ASTBatchParser parser= new ASTBatchParser() {
+ @Override
+ protected ASTParser createParser(IJavaProject project) {
+ ASTParser result= createCleanUpASTParser();
+ result.setProject(project);
+
+ Map<String, String> options= RefactoringASTParser.getCompilerOptions(project);
+ options.putAll(fCleanUpOptions);
+ result.setCompilerOptions(options);
+ return result;
+ }
+ };
+ try {
+ ICompilationUnit[] units= parseList.toArray(new ICompilationUnit[parseList.size()]);
+ parser.createASTs(units, new String[0], requestor, cuMonitor);
+ } catch (FixCalculationException e) {
+ throw e.getException();
+ }
+ }
+
+ for (Iterator<ICompilationUnit> iterator= sourceList.iterator(); iterator.hasNext();) {
+ ICompilationUnit cu= iterator.next();
+
+ monitor.worked(1);
+
+ requestor.acceptSource(cu);
+
+ if (monitor.isCanceled())
+ throw new OperationCanceledException();
+ }
+
+ fParseList= requestor.getUndoneElements();
+ fIndex= cuMonitor.getIndex();
+ } finally {
+ }
+ }
+
+ public void dispose() {
+ for (Iterator<ICompilationUnit> iterator= fWorkingCopies.values().iterator(); iterator.hasNext();) {
+ ICompilationUnit cu= iterator.next();
+ try {
+ cu.discardWorkingCopy();
+ } catch (JavaModelException e) {
+ JavaPlugin.log(e);
+ }
+ }
+ fWorkingCopies.clear();
+ }
+
+ private boolean requiresAST(ICleanUp[] cleanUps) {
+ for (int i= 0; i < cleanUps.length; i++) {
+ if (cleanUps[i].getRequirements().requiresAST())
+ return true;
+ }
+ return false;
+ }
+
+ public Change[] getResult() {
+
+ Change[] result= new Change[fSolutions.size()];
+ int i=0;
+ for (Iterator<Entry<ICompilationUnit, List<CleanUpChange>>> iterator= fSolutions.entrySet().iterator(); iterator.hasNext();) {
+ Entry<ICompilationUnit, List<CleanUpChange>> entry= iterator.next();
+
+ List<CleanUpChange> changes= entry.getValue();
+ ICompilationUnit unit= entry.getKey();
+
+ int saveMode;
+ if (fLeaveFilesDirty) {
+ saveMode= TextFileChange.LEAVE_DIRTY;
+ } else {
+ saveMode= TextFileChange.KEEP_SAVE_STATE;
+ }
+
+ if (changes.size() == 1) {
+ CleanUpChange change= changes.get(0);
+ change.setSaveMode(saveMode);
+ result[i]= change;
+ } else {
+ MultiStateCompilationUnitChange mscuc= new MultiStateCompilationUnitChange(getChangeName(unit), unit);
+ for (int j= 0; j < changes.size(); j++) {
+ mscuc.addChange(createGroupFreeChange(changes.get(j)));
+ }
+ mscuc.setSaveMode(saveMode);
+ result[i]= mscuc;
+ }
+
+ i++;
+ }
+
+ return result;
+ }
+
+ private TextChange createGroupFreeChange(CleanUpChange change) {
+ CleanUpChange result= new CleanUpChange(change.getName(), change.getCompilationUnit());
+ result.setEdit(change.getEdit());
+ result.setSaveMode(change.getSaveMode());
+ return result;
+ }
+
+ private void applyChange(ICompilationUnit compilationUnit, List<CleanUpChange> changes) throws JavaModelException, CoreException {
+ IDocument document= new Document(changes.get(0).getCurrentContent(new NullProgressMonitor()));
+ for (int i= 0; i < changes.size(); i++) {
+ CleanUpChange change= changes.get(i);
+ TextEdit edit= change.getEdit().copy();
+
+ try {
+ edit.apply(document, TextEdit.UPDATE_REGIONS);
+ } catch (MalformedTreeException e) {
+ JavaPlugin.log(e);
+ } catch (BadLocationException e) {
+ JavaPlugin.log(e);
+ }
+ }
+ compilationUnit.getBuffer().setContents(document.get());
+ }
+ }
+
+ private static final RefactoringTickProvider CLEAN_UP_REFACTORING_TICK_PROVIDER= new RefactoringTickProvider(0, 1, 0, 0);
+
+ /**
+ * A clean up is considered slow if its execution lasts longer then the value of
+ * SLOW_CLEAN_UP_THRESHOLD in ms.
+ */
+ private static final int SLOW_CLEAN_UP_THRESHOLD= 2000;
+
+ private final List<ICleanUp> fCleanUps;
+ private final Hashtable<IJavaProject, List<CleanUpTarget>> fProjects;
+ private Change fChange;
+ private boolean fLeaveFilesDirty;
+ private final String fName;
+
+ private boolean fUseOptionsFromProfile;
+
+ public CleanUpRefactoring() {
+ this(FixMessages.CleanUpRefactoring_Refactoring_name);
+ }
+
+ public CleanUpRefactoring(String name) {
+ fName= name;
+ fCleanUps= new ArrayList<ICleanUp>();
+ fProjects= new Hashtable<IJavaProject, List<CleanUpTarget>>();
+ fUseOptionsFromProfile= false;
+ }
+
+ public void setUseOptionsFromProfile(boolean enabled) {
+ fUseOptionsFromProfile= enabled;
+ }
+
+ public void addCompilationUnit(ICompilationUnit unit) {
+ addCleanUpTarget(new CleanUpTarget(unit));
+ }
+
+ public void addCleanUpTarget(CleanUpTarget target) {
+
+ IJavaProject javaProject= target.getCompilationUnit().getJavaProject();
+ if (!fProjects.containsKey(javaProject))
+ fProjects.put(javaProject, new ArrayList<CleanUpTarget>());
+
+ List<CleanUpTarget> targets= fProjects.get(javaProject);
+ targets.add(target);
+ }
+
+ public CleanUpTarget[] getCleanUpTargets() {
+ List<CleanUpTarget> result= new ArrayList<CleanUpTarget>();
+ for (Iterator<List<CleanUpTarget>> iter= fProjects.values().iterator(); iter.hasNext();) {
+ List<CleanUpTarget> projectTargets= iter.next();
+ result.addAll(projectTargets);
+ }
+ return result.toArray(new CleanUpTarget[result.size()]);
+ }
+
+ public int getCleanUpTargetsSize() {
+ int result= 0;
+ for (Iterator<List<CleanUpTarget>> iter= fProjects.values().iterator(); iter.hasNext();) {
+ List<CleanUpTarget> projectTargets= iter.next();
+ result+= projectTargets.size();
+ }
+ return result;
+ }
+
+ public void addCleanUp(ICleanUp fix) {
+ fCleanUps.add(fix);
+ }
+
+ public void clearCleanUps() {
+ fCleanUps.clear();
+ }
+
+ public boolean hasCleanUps() {
+ return !fCleanUps.isEmpty();
+ }
+
+ public ICleanUp[] getCleanUps() {
+ return fCleanUps.toArray(new ICleanUp[fCleanUps.size()]);
+ }
+
+ public IJavaProject[] getProjects() {
+ return fProjects.keySet().toArray(new IJavaProject[fProjects.keySet().size()]);
+ }
+
+ public void setLeaveFilesDirty(boolean leaveFilesDirty) {
+ fLeaveFilesDirty= leaveFilesDirty;
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.ltk.core.refactoring.Refactoring#getName()
+ */
+ @Override
+ public String getName() {
+ return fName;
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.ltk.core.refactoring.Refactoring#checkInitialConditions(org.eclipse.core.runtime.IProgressMonitor)
+ */
+ @Override
+ public RefactoringStatus checkInitialConditions(IProgressMonitor pm) throws CoreException, OperationCanceledException {
+ if (pm != null) {
+ pm.beginTask("", 1); //$NON-NLS-1$
+ pm.worked(1);
+ pm.done();
+ }
+ return new RefactoringStatus();
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.ltk.core.refactoring.Refactoring#createChange(org.eclipse.core.runtime.IProgressMonitor)
+ */
+ @Override
+ public Change createChange(IProgressMonitor pm) throws CoreException, OperationCanceledException {
+ if (pm != null) {
+ pm.beginTask("", 1); //$NON-NLS-1$
+ pm.worked(1);
+ pm.done();
+ }
+ return fChange;
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.ltk.core.refactoring.Refactoring#checkFinalConditions(org.eclipse.core.runtime.IProgressMonitor)
+ */
+ @Override
+ public RefactoringStatus checkFinalConditions(IProgressMonitor pm) throws CoreException, OperationCanceledException {
+
+ if (pm == null)
+ pm= new NullProgressMonitor();
+
+ if (fProjects.size() == 0 || fCleanUps.size() == 0) {
+ pm.beginTask("", 1); //$NON-NLS-1$
+ pm.worked(1);
+ pm.done();
+ fChange= new NullChange();
+
+ return new RefactoringStatus();
+ }
+
+ int cuCount= getCleanUpTargetsSize();
+
+ RefactoringStatus result= new RefactoringStatus();
+
+ ICleanUp[] cleanUps= getCleanUps();
+ pm.beginTask("", cuCount * 2 * fCleanUps.size() + 4 * cleanUps.length); //$NON-NLS-1$
+ try {
+ DynamicValidationStateChange change= new DynamicValidationStateChange(getName());
+ change.setSchedulingRule(getSchedulingRule());
+ for (Iterator<Entry<IJavaProject, List<CleanUpTarget>>> projectIter= fProjects.entrySet().iterator(); projectIter.hasNext();) {
+ Entry<IJavaProject, List<CleanUpTarget>> entry= projectIter.next();
+ IJavaProject project= entry.getKey();
+ List<CleanUpTarget> targetsList= entry.getValue();
+ CleanUpTarget[] targets= targetsList.toArray(new CleanUpTarget[targetsList.size()]);
+
+ if (fUseOptionsFromProfile) {
+ result.merge(setOptionsFromProfile(project, cleanUps));
+ if (result.hasFatalError())
+ return result;
+ }
+
+ result.merge(checkPreConditions(project, targets, new SubProgressMonitor(pm, 3 * cleanUps.length)));
+ if (result.hasFatalError())
+ return result;
+
+ Change[] changes= cleanUpProject(project, targets, cleanUps, pm);
+
+ result.merge(checkPostConditions(new SubProgressMonitor(pm, cleanUps.length)));
+ if (result.hasFatalError())
+ return result;
+
+ for (int i= 0; i < changes.length; i++) {
+ change.add(changes[i]);
+ }
+ }
+ fChange= change;
+
+ List<IResource> files= new ArrayList<IResource>();
+ findFilesToBeModified(change, files);
+ result.merge(Checks.validateModifiesFiles(files.toArray(new IFile[files.size()]), getValidationContext()));
+ } finally {
+ pm.done();
+ }
+
+ return result;
+ }
+
+ private void findFilesToBeModified(CompositeChange change, List<IResource> result) throws JavaModelException {
+ Change[] children= change.getChildren();
+ for (int i= 0; i < children.length; i++) {
+ Change child= children[i];
+ if (child instanceof CompositeChange) {
+ findFilesToBeModified((CompositeChange)child, result);
+ } else if (child instanceof MultiStateCompilationUnitChange) {
+ result.add(((MultiStateCompilationUnitChange)child).getCompilationUnit().getCorrespondingResource());
+ } else if (child instanceof CompilationUnitChange) {
+ result.add(((CompilationUnitChange)child).getCompilationUnit().getCorrespondingResource());
+ }
+ }
+ }
+
+ private Change[] cleanUpProject(IJavaProject project, CleanUpTarget[] targets, ICleanUp[] cleanUps, IProgressMonitor monitor) throws CoreException {
+ CleanUpFixpointIterator iter= new CleanUpFixpointIterator(targets, cleanUps);
+
+ SubProgressMonitor subMonitor= new SubProgressMonitor(monitor, 2 * targets.length * cleanUps.length);
+ subMonitor.beginTask("", targets.length); //$NON-NLS-1$
+ subMonitor.subTask(Messages.format(FixMessages.CleanUpRefactoring_Parser_Startup_message, BasicElementLabels.getResourceName(project.getProject())));
+ try {
+ while (iter.hasNext()) {
+ iter.next(subMonitor);
+ }
+
+ return iter.getResult();
+ } finally {
+ iter.dispose();
+ subMonitor.done();
+ }
+ }
+
+ private RefactoringStatus setOptionsFromProfile(IJavaProject javaProject, ICleanUp[] cleanUps) {
+ Map<String, String> options= CleanUpPreferenceUtil.loadOptions(new ProjectScope(javaProject.getProject()));
+ if (options == null)
+ return RefactoringStatus.createFatalErrorStatus(Messages.format(FixMessages.CleanUpRefactoring_could_not_retrive_profile, BasicElementLabels.getResourceName(javaProject.getProject())));
+
+ CleanUpOptions cleanUpOptions= new MapCleanUpOptions(options);
+ for (int i= 0; i < cleanUps.length; i++)
+ cleanUps[i].setOptions(cleanUpOptions);
+
+ return new RefactoringStatus();
+ }
+
+ private RefactoringStatus checkPreConditions(IJavaProject javaProject, CleanUpTarget[] targets, IProgressMonitor monitor) throws CoreException {
+ RefactoringStatus result= new RefactoringStatus();
+
+ ICompilationUnit[] compilationUnits= new ICompilationUnit[targets.length];
+ for (int i= 0; i < targets.length; i++) {
+ compilationUnits[i]= targets[i].getCompilationUnit();
+ }
+
+ ICleanUp[] cleanUps= getCleanUps();
+ monitor.beginTask("", compilationUnits.length * cleanUps.length); //$NON-NLS-1$
+ monitor.subTask(Messages.format(FixMessages.CleanUpRefactoring_Initialize_message, BasicElementLabels.getResourceName(javaProject.getProject())));
+ try {
+ for (int j= 0; j < cleanUps.length; j++) {
+ result.merge(cleanUps[j].checkPreConditions(javaProject, compilationUnits, new SubProgressMonitor(monitor, compilationUnits.length)));
+ if (result.hasFatalError())
+ return result;
+ }
+ } finally {
+ monitor.done();
+ }
+
+ return result;
+ }
+
+ private RefactoringStatus checkPostConditions(SubProgressMonitor monitor) throws CoreException {
+ RefactoringStatus result= new RefactoringStatus();
+
+ ICleanUp[] cleanUps= getCleanUps();
+ monitor.beginTask("", cleanUps.length); //$NON-NLS-1$
+ monitor.subTask(FixMessages.CleanUpRefactoring_checkingPostConditions_message);
+ try {
+ for (int j= 0; j < cleanUps.length; j++) {
+ result.merge(cleanUps[j].checkPostConditions(new SubProgressMonitor(monitor, 1)));
+ }
+ } finally {
+ monitor.done();
+ }
+ return result;
+ }
+
+ private static String getChangeName(ICompilationUnit compilationUnit) {
+ StringBuffer buf= new StringBuffer();
+ JavaElementLabels.getCompilationUnitLabel(compilationUnit, JavaElementLabels.ALL_DEFAULT, buf);
+ buf.append(JavaElementLabels.CONCAT_STRING);
+
+ StringBuffer buf2= new StringBuffer();
+ JavaElementLabels.getPackageFragmentLabel((IPackageFragment)compilationUnit.getParent(), JavaElementLabels.P_QUALIFIED, buf2);
+ buf.append(buf2.toString().replace('.', '/'));
+
+ return buf.toString();
+ }
+
+ public static CleanUpChange calculateChange(CleanUpContext context, ICleanUp[] cleanUps, List<ICleanUp> undoneCleanUps, HashSet<ICleanUp> slowCleanUps) throws CoreException {
+ if (cleanUps.length == 0)
+ return null;
+
+ CleanUpChange solution= null;
+ int i= 0;
+ do {
+ ICleanUp cleanUp= cleanUps[i];
+ ICleanUpFix fix;
+ if (slowCleanUps != null) {
+ long timeBefore= System.currentTimeMillis();
+ fix= cleanUp.createFix(context);
+ if (System.currentTimeMillis() - timeBefore > SLOW_CLEAN_UP_THRESHOLD)
+ slowCleanUps.add(cleanUp);
+ } else {
+ fix= cleanUp.createFix(context);
+ }
+ if (fix != null) {
+ CompilationUnitChange current= fix.createChange(null);
+ TextEdit currentEdit= current.getEdit();
+
+ if (solution != null) {
+ if (TextEditUtil.overlaps(currentEdit, solution.getEdit())) {
+ undoneCleanUps.add(cleanUp);
+ } else {
+ CleanUpChange merge= new CleanUpChange(FixMessages.CleanUpRefactoring_clean_up_multi_chang_name, context.getCompilationUnit());
+ merge.setEdit(TextEditUtil.merge(currentEdit, solution.getEdit()));
+
+ copyChangeGroups(merge, solution);
+ copyChangeGroups(merge, current);
+
+ solution= merge;
+ }
+ } else {
+ solution= new CleanUpChange(current.getName(), context.getCompilationUnit());
+ solution.setEdit(currentEdit);
+
+ copyChangeGroups(solution, current);
+ }
+ }
+ i++;
+ } while (i < cleanUps.length && (context.getAST() == null || !cleanUps[i].getRequirements().requiresFreshAST()));
+
+ for (; i < cleanUps.length; i++) {
+ undoneCleanUps.add(cleanUps[i]);
+ }
+ return solution;
+ }
+
+ private static void copyChangeGroups(CompilationUnitChange target, CompilationUnitChange source) {
+ TextEditBasedChangeGroup[] changeGroups= source.getChangeGroups();
+ for (int i= 0; i < changeGroups.length; i++) {
+ TextEditGroup textEditGroup= changeGroups[i].getTextEditGroup();
+ TextEditGroup newGroup;
+ if (textEditGroup instanceof CategorizedTextEditGroup) {
+ String label= textEditGroup.getName();
+ newGroup= new CategorizedTextEditGroup(label, new GroupCategorySet(new GroupCategory(label, label, label)));
+ } else {
+ newGroup= new TextEditGroup(textEditGroup.getName());
+ }
+ TextEdit[] textEdits= textEditGroup.getTextEdits();
+ for (int j= 0; j < textEdits.length; j++) {
+ newGroup.addTextEdit(textEdits[j]);
+ }
+ target.addTextEditGroup(newGroup);
+ }
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.ltk.core.refactoring.Refactoring#getRefactoringTickProvider()
+ */
+ @Override
+ protected RefactoringTickProvider doGetRefactoringTickProvider() {
+ return CLEAN_UP_REFACTORING_TICK_PROVIDER;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public ISchedulingRule getSchedulingRule() {
+ return ResourcesPlugin.getWorkspace().getRoot();
+ }
+
+ public static ASTParser createCleanUpASTParser() {
+ ASTParser result= ASTParser.newParser(ASTProvider.SHARED_AST_LEVEL);
+
+ result.setResolveBindings(true);
+ result.setStatementsRecovery(ASTProvider.SHARED_AST_STATEMENT_RECOVERY);
+ result.setBindingsRecovery(ASTProvider.SHARED_BINDING_RECOVERY);
+
+ return result;
+ }
+
+}
git://git.uio.no / ifi-stolz-refaktor.git / blobdiff