exctract language-independent part from MoveDirectoryWithClassesProcessor

2026-09-27 10:03:11 +07:00 · 2011-06-23 19:08:25 +04:00
parent 81d7b24a22
commit 7188f54785
11 changed files with 289 additions and 135 deletions
@@ -0,0 +1,112 @@
+package com.intellij.refactoring.move.moveClassesOrPackages;
+
+import com.intellij.codeInsight.ChangeContextUtil;
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.*;
+import com.intellij.psi.search.searches.ReferencesSearch;
+import com.intellij.psi.util.PsiTreeUtil;
+import com.intellij.refactoring.listeners.RefactoringElementListener;
+import com.intellij.usageView.UsageInfo;
+
+import java.util.*;
+
+public class JavaMoveDirectoryWithClassesHelper extends MoveDirectoryWithClassesHelper {
+
+  @Override
+  public void findUsages(Collection<PsiFile> filesToMove,
+                         PsiDirectory[] directoriesToMove,
+                         Collection<UsageInfo> usages,
+                         boolean searchInComments,
+                         boolean searchInNonJavaFiles,
+                         Project project) {
+    final Set<String> packageNames = new HashSet<String>();
+    for (PsiFile psiFile : filesToMove) {
+      if (psiFile instanceof PsiClassOwner) {
+        final PsiClass[] classes = ((PsiClassOwner)psiFile).getClasses();
+        for (PsiClass aClass : classes) {
+          Collections
+            .addAll(usages, MoveClassesOrPackagesUtil.findUsages(aClass, searchInComments, searchInNonJavaFiles, aClass.getName()));
+        }
+        packageNames.add(((PsiClassOwner)psiFile).getPackageName());
+      }
+    }
+
+    final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project);
+    for (String packageName : packageNames) {
+      final PsiPackage aPackage = psiFacade.findPackage(packageName);
+      if (aPackage != null) {
+        boolean remainsNothing = true;
+        for (PsiDirectory packageDirectory : aPackage.getDirectories()) {
+          if (!isUnderRefactoring(packageDirectory, directoriesToMove)) {
+            remainsNothing = false;
+            break;
+          }
+        }
+        if (remainsNothing) {
+          for (PsiReference reference : ReferencesSearch.search(aPackage)) {
+            final PsiElement element = reference.getElement();
+            final PsiImportStatementBase statementBase = PsiTreeUtil.getParentOfType(element, PsiImportStatementBase.class);
+            if (statementBase != null && statementBase.isOnDemand()) {
+              usages.add(new RemoveOnDemandImportStatementsUsageInfo(statementBase));
+            }
+          }
+        }
+      }
+    }
+  }
+
+  private static boolean isUnderRefactoring(PsiDirectory packageDirectory, PsiDirectory[] directoriesToMove) {
+    for (PsiDirectory directory : directoriesToMove) {
+      if (PsiTreeUtil.isAncestor(directory, packageDirectory, true)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  @Override
+  public boolean move(PsiFile file,
+                      PsiDirectory moveDestination,
+                      Map<PsiElement, PsiElement> oldToNewElementsMapping,
+                      List<PsiFile> movedFiles,
+                      RefactoringElementListener listener) {
+    if (!(file instanceof PsiClassOwner)) {
+      return false;
+    }
+
+    for (PsiClass psiClass : ((PsiClassOwner)file).getClasses()) {
+      final PsiClass newClass = MoveClassesOrPackagesUtil.doMoveClass(psiClass, moveDestination);
+      oldToNewElementsMapping.put(psiClass, newClass);
+      listener.elementMoved(newClass);
+    }
+    return true;
+  }
+
+  @Override
+  public void postProcessUsages(UsageInfo[] usages) {
+    for (UsageInfo usage : usages) {
+      if (usage instanceof RemoveOnDemandImportStatementsUsageInfo) {
+        final PsiElement element = usage.getElement();
+        if (element != null) {
+          element.delete();
+        }
+      }
+    }
+  }
+
+  @Override
+  public void beforeMove(PsiFile psiFile) {
+    ChangeContextUtil.encodeContextInfo(psiFile, true);
+  }
+
+  @Override
+  public void afterMove(PsiElement newElement) {
+    ChangeContextUtil.decodeContextInfo(newElement, null, null);
+  }
+
+  private static class RemoveOnDemandImportStatementsUsageInfo extends UsageInfo {
+    public RemoveOnDemandImportStatementsUsageInfo(PsiImportStatementBase statementBase) {
+      super(statementBase);
+    }
+  }
+}
@@ -36,6 +36,7 @@ import com.intellij.refactoring.PackageWrapper;
 import com.intellij.refactoring.RefactoringBundle;
 import com.intellij.refactoring.move.MoveCallback;
 import com.intellij.refactoring.move.MoveClassesOrPackagesCallback;
+import com.intellij.refactoring.move.MoveMultipleElementsViewDescriptor;
 import com.intellij.refactoring.rename.RenameUtil;
 import com.intellij.refactoring.util.*;
 import com.intellij.usageView.UsageInfo;
@@ -93,9 +94,7 @@ public class MoveClassToInnerProcessor extends BaseRefactoringProcessor {
  }

  protected UsageViewDescriptor createUsageViewDescriptor(UsageInfo[] usages) {
-    return new MoveClassesOrPackagesViewDescriptor(myClassesToMove,
-                                                   mySearchInComments, mySearchInNonJavaFiles,
-                                                   myTargetClass.getQualifiedName());
+    return new MoveMultipleElementsViewDescriptor(myClassesToMove, myTargetClass.getQualifiedName());
  }

  @NotNull
@@ -155,7 +154,7 @@ public class MoveClassToInnerProcessor extends BaseRefactoringProcessor {
        oldToNewElementsMapping.put(classToMove, newClass);
      }

-      myNonCodeUsages = MoveClassesOrPackagesProcessor.retargetUsages(usages, oldToNewElementsMapping);
+      myNonCodeUsages = CommonMoveUtil.retargetUsages(usages, oldToNewElementsMapping);
      retargetNonCodeUsages(oldToNewElementsMapping);

      retargetClassRefsInMoved(oldToNewElementsMapping);
@@ -38,6 +38,7 @@ import com.intellij.refactoring.RefactoringBundle;
 import com.intellij.refactoring.listeners.RefactoringElementListener;
 import com.intellij.refactoring.move.MoveCallback;
 import com.intellij.refactoring.move.MoveClassesOrPackagesCallback;
+import com.intellij.refactoring.move.MoveMultipleElementsViewDescriptor;
 import com.intellij.refactoring.rename.RenameUtil;
 import com.intellij.refactoring.util.*;
 import com.intellij.refactoring.util.classRefs.ClassInstanceScanner;
@@ -114,8 +115,7 @@ public class MoveClassesOrPackagesProcessor extends BaseRefactoringProcessor {
  protected UsageViewDescriptor createUsageViewDescriptor(UsageInfo[] usages) {
    PsiElement[] elements = new PsiElement[myElementsToMove.length];
    System.arraycopy(myElementsToMove, 0, elements, 0, myElementsToMove.length);
-    return new MoveClassesOrPackagesViewDescriptor(elements, mySearchInComments, mySearchInNonJavaFiles,
-                                                   MoveClassesOrPackagesUtil.getPackageName(myTargetPackage));
+    return new MoveMultipleElementsViewDescriptor(elements, MoveClassesOrPackagesUtil.getPackageName(myTargetPackage));
  }

  public boolean verifyValidPackageName() {
@@ -486,7 +486,7 @@ public class MoveClassesOrPackagesProcessor extends BaseRefactoringProcessor {
        }
      }

-      myNonCodeUsages = retargetUsages(usages, oldToNewElementsMapping);
+      myNonCodeUsages = CommonMoveUtil.retargetUsages(usages, oldToNewElementsMapping);
    }
    catch (IncorrectOperationException e) {
      myNonCodeUsages = new NonCodeUsageInfo[0];
@@ -494,30 +494,6 @@ public class MoveClassesOrPackagesProcessor extends BaseRefactoringProcessor {
    }
  }

-  public static NonCodeUsageInfo[] retargetUsages(final UsageInfo[] usages, final Map<PsiElement, PsiElement> oldToNewElementsMapping)
-    throws IncorrectOperationException {
-    List<NonCodeUsageInfo> nonCodeUsages = new ArrayList<NonCodeUsageInfo>();
-    for (UsageInfo usage : usages) {
-      if (usage instanceof NonCodeUsageInfo) {
-        nonCodeUsages.add((NonCodeUsageInfo)usage);
-      }
-      else if (usage instanceof MoveRenameUsageInfo) {
-        final MoveRenameUsageInfo moveRenameUsage = (MoveRenameUsageInfo)usage;
-        final PsiElement oldElement = moveRenameUsage.getReferencedElement();
-        final PsiElement newElement = oldToNewElementsMapping.get(oldElement);
-        LOG.assertTrue(newElement != null);
-        final PsiReference reference = moveRenameUsage.getReference();
-        if (reference != null) {
-          try {
-            reference.bindToElement(newElement);
-          } catch (IncorrectOperationException e) {//
-          }
-        }
-      }
-    }
-    return nonCodeUsages.toArray(new NonCodeUsageInfo[nonCodeUsages.size()]);
-  }
-
  protected void performPsiSpoilingRefactoring() {
    RenameUtil.renameNonCodeUsages(myProject, myNonCodeUsages);
    if (myMoveCallback != null) {
@@ -18,11 +18,9 @@
 * created at Sep 17, 2001
 * @author Jeka
 */
-package com.intellij.refactoring.move.moveClassesOrPackages;
+package com.intellij.refactoring.move;

 import com.intellij.openapi.util.text.StringUtil;
-import com.intellij.psi.PsiClass;
-import com.intellij.psi.PsiDirectory;
 import com.intellij.psi.PsiElement;
 import com.intellij.refactoring.RefactoringBundle;
 import com.intellij.usageView.UsageViewBundle;
@@ -30,36 +28,25 @@ import com.intellij.usageView.UsageViewDescriptor;
 import com.intellij.usageView.UsageViewUtil;
 import org.jetbrains.annotations.NotNull;

-class MoveClassesOrPackagesViewDescriptor implements UsageViewDescriptor {
+public class MoveMultipleElementsViewDescriptor implements UsageViewDescriptor {
  private final PsiElement[] myPsiElements;
-  private final boolean mySearchInComments;
-  private final boolean mySearchInNonJavaFiles;
-  private final String myNewParentPackageName;
  private String myProcessedElementsHeader;
  private final String myCodeReferencesText;

-  public MoveClassesOrPackagesViewDescriptor(PsiElement[] psiElements,
-                                             boolean isSearchInComments,
-                                             boolean searchInNonJavaFiles,
-                                             String targetName) {
+  public MoveMultipleElementsViewDescriptor(PsiElement[] psiElements,
+                                            String targetName) {
    myPsiElements = psiElements;
-    mySearchInComments = isSearchInComments;
-    mySearchInNonJavaFiles = searchInNonJavaFiles;
-    myNewParentPackageName = targetName;
    if (psiElements.length == 1) {
      myProcessedElementsHeader = StringUtil.capitalize(
-        RefactoringBundle.message("move.single.element.elements.header", UsageViewUtil.getType(psiElements[0]), myNewParentPackageName));
-      myCodeReferencesText = RefactoringBundle.message("references.in.code.to.0.1", UsageViewUtil.getType(psiElements[0]), UsageViewUtil.getLongName(psiElements[0]));
+        RefactoringBundle.message("move.single.element.elements.header", UsageViewUtil.getType(psiElements[0]), targetName));
+      myCodeReferencesText = RefactoringBundle
+        .message("references.in.code.to.0.1", UsageViewUtil.getType(psiElements[0]), UsageViewUtil.getLongName(psiElements[0]));
    }
    else {
      if (psiElements.length > 0) {
-        if (psiElements[0] instanceof PsiClass) {
-          myProcessedElementsHeader = StringUtil.capitalize(RefactoringBundle.message("move.classes.elements.header", myNewParentPackageName));
-        }
-        else if (psiElements[0] instanceof PsiDirectory){
-          myProcessedElementsHeader =
-            StringUtil.capitalize(RefactoringBundle.message("move.packages.elements.header", myNewParentPackageName));
-        }
+        myProcessedElementsHeader = StringUtil.capitalize(
+          RefactoringBundle
+            .message("move.single.element.elements.header", StringUtil.pluralize(UsageViewUtil.getType(psiElements[0])), targetName));
      }
      myCodeReferencesText = RefactoringBundle.message("references.found.in.code");
    }
@@ -0,0 +1,46 @@
+package com.intellij.refactoring.move.moveClassesOrPackages;
+
+import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiReference;
+import com.intellij.refactoring.util.MoveRenameUsageInfo;
+import com.intellij.refactoring.util.NonCodeUsageInfo;
+import com.intellij.usageView.UsageInfo;
+import com.intellij.util.IncorrectOperationException;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class CommonMoveUtil {
+
+  private CommonMoveUtil() {
+  }
+
+  private static final Logger LOG = Logger.getInstance("#com.intellij.refactoring.move.moveClassesOrPackages.CommonMoveUtil");
+
+  public static NonCodeUsageInfo[] retargetUsages(final UsageInfo[] usages, final Map<PsiElement, PsiElement> oldToNewElementsMapping)
+    throws IncorrectOperationException {
+    List<NonCodeUsageInfo> nonCodeUsages = new ArrayList<NonCodeUsageInfo>();
+    for (UsageInfo usage : usages) {
+      if (usage instanceof NonCodeUsageInfo) {
+        nonCodeUsages.add((NonCodeUsageInfo)usage);
+      }
+      else if (usage instanceof MoveRenameUsageInfo) {
+        final MoveRenameUsageInfo moveRenameUsage = (MoveRenameUsageInfo)usage;
+        final PsiElement oldElement = moveRenameUsage.getReferencedElement();
+        final PsiElement newElement = oldToNewElementsMapping.get(oldElement);
+        LOG.assertTrue(newElement != null);
+        final PsiReference reference = moveRenameUsage.getReference();
+        if (reference != null) {
+          try {
+            reference.bindToElement(newElement);
+          }
+          catch (IncorrectOperationException e) {//
+          }
+        }
+      }
+    }
+    return nonCodeUsages.toArray(new NonCodeUsageInfo[nonCodeUsages.size()]);
+  }
+}
@@ -0,0 +1,86 @@
+package com.intellij.refactoring.move.moveClassesOrPackages;
+
+import com.intellij.openapi.extensions.ExtensionPointName;
+import com.intellij.openapi.extensions.Extensions;
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.PsiDirectory;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiFile;
+import com.intellij.refactoring.listeners.RefactoringElementListener;
+import com.intellij.refactoring.move.moveFilesOrDirectories.MoveFileHandler;
+import com.intellij.refactoring.move.moveFilesOrDirectories.MoveFilesOrDirectoriesUtil;
+import com.intellij.usageView.UsageInfo;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author ksafonov
+ */
+public abstract class MoveDirectoryWithClassesHelper {
+  private static final ExtensionPointName<MoveDirectoryWithClassesHelper> EP_NAME =
+    ExtensionPointName.create("com.intellij.refactoring.moveDirectoryWithClassesHelper");
+
+  public abstract void findUsages(Collection<PsiFile> filesToMove, PsiDirectory[] directoriesToMove, Collection<UsageInfo> result,
+                                  boolean searchInComments, boolean searchInNonJavaFiles, Project project);
+
+  public abstract boolean move(PsiFile file,
+                                  PsiDirectory moveDestination,
+                                  Map<PsiElement, PsiElement> oldToNewElementsMapping,
+                                  List<PsiFile> movedFiles,
+                                  RefactoringElementListener listener);
+
+  public abstract void postProcessUsages(UsageInfo[] usages);
+
+  public abstract void beforeMove(PsiFile psiFile);
+
+  public abstract void afterMove(PsiElement newElement);
+
+  public static MoveDirectoryWithClassesHelper[] findAll() {
+    return Extensions.getExtensions(EP_NAME);
+  }
+
+
+  public static class Default extends MoveDirectoryWithClassesHelper {
+
+    @Override
+    public void findUsages(Collection<PsiFile> filesToMove, PsiDirectory[] directoriesToMove, Collection<UsageInfo> result,
+                           boolean searchInComments, boolean searchInNonJavaFiles, Project project) {
+    }
+
+    @Override
+    public boolean move(PsiFile psiFile,
+                           PsiDirectory moveDestination,
+                           Map<PsiElement, PsiElement> oldToNewElementsMapping,
+                           List<PsiFile> movedFiles,
+                           RefactoringElementListener listener) {
+      if (moveDestination.equals(psiFile.getContainingDirectory())) {
+        return false;
+      }
+
+      MoveFileHandler.forElement(psiFile).prepareMovedFile(psiFile, moveDestination, oldToNewElementsMapping);
+
+      PsiFile moving = moveDestination.findFile(psiFile.getName());
+      if (moving == null) {
+        MoveFilesOrDirectoriesUtil.doMoveFile(psiFile, moveDestination);
+      }
+      moving = moveDestination.findFile(psiFile.getName());
+      movedFiles.add(moving);
+      listener.elementMoved(psiFile);
+      return true;
+    }
+
+    @Override
+    public void postProcessUsages(UsageInfo[] usages) {
+    }
+
+    @Override
+    public void beforeMove(PsiFile psiFile) {
+    }
+
+    @Override
+    public void afterMove(PsiElement newElement) {
+    }
+  }
+}
@@ -21,22 +21,21 @@
 package com.intellij.refactoring.move.moveClassesOrPackages;

 import com.intellij.CommonBundle;
-import com.intellij.codeInsight.ChangeContextUtil;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.ui.Messages;
 import com.intellij.openapi.util.Ref;
 import com.intellij.openapi.vfs.VfsUtil;
-import com.intellij.psi.*;
-import com.intellij.psi.search.searches.ReferencesSearch;
-import com.intellij.psi.util.PsiTreeUtil;
+import com.intellij.psi.PsiDirectory;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiFile;
 import com.intellij.psi.util.PsiUtilBase;
 import com.intellij.refactoring.BaseRefactoringProcessor;
 import com.intellij.refactoring.RefactoringBundle;
 import com.intellij.refactoring.listeners.RefactoringElementListener;
 import com.intellij.refactoring.move.FileReferenceContextUtil;
 import com.intellij.refactoring.move.MoveCallback;
+import com.intellij.refactoring.move.MoveMultipleElementsViewDescriptor;
 import com.intellij.refactoring.move.moveFilesOrDirectories.MoveFileHandler;
-import com.intellij.refactoring.move.moveFilesOrDirectories.MoveFilesOrDirectoriesUtil;
 import com.intellij.refactoring.rename.RenameUtil;
 import com.intellij.refactoring.util.NonCodeUsageInfo;
 import com.intellij.refactoring.util.RefactoringUIUtil;
@@ -69,7 +68,7 @@ public class MoveDirectoryWithClassesProcessor extends BaseRefactoringProcessor
    super(project);
    if (targetDirectory != null) {
      final List<PsiDirectory> dirs = new ArrayList<PsiDirectory>(Arrays.asList(directories));
-      for (Iterator<PsiDirectory> iterator = dirs.iterator(); iterator.hasNext();) {
+      for (Iterator<PsiDirectory> iterator = dirs.iterator(); iterator.hasNext(); ) {
        final PsiDirectory directory = iterator.next();
        if (targetDirectory.equals(directory.getParentDirectory()) || targetDirectory.equals(directory)) {
          iterator.remove();
@@ -88,12 +87,13 @@ public class MoveDirectoryWithClassesProcessor extends BaseRefactoringProcessor
    }
  }

+  @NotNull
  @Override
  protected UsageViewDescriptor createUsageViewDescriptor(UsageInfo[] usages) {
    PsiElement[] elements = new PsiElement[myFilesToMove.size()];
    final PsiFile[] classes = PsiUtilBase.toPsiFileArray(myFilesToMove.keySet());
    System.arraycopy(classes, 0, elements, 0, classes.length);
-    return new MoveClassesOrPackagesViewDescriptor(elements, false, false, getTargetName());
+    return new MoveMultipleElementsViewDescriptor(elements, getTargetName());
  }

  protected String getTargetName() {
@@ -104,51 +104,12 @@ public class MoveDirectoryWithClassesProcessor extends BaseRefactoringProcessor
  @Override
  public UsageInfo[] findUsages() {
    final List<UsageInfo> usages = new ArrayList<UsageInfo>();
-    final Set<String> packageNames = new HashSet<String>();
-    for (PsiFile psiFile : myFilesToMove.keySet()) {
-      if (psiFile instanceof PsiClassOwner) {
-        final PsiClass[] classes = ((PsiClassOwner)psiFile).getClasses();
-        for (PsiClass aClass : classes) {
-          Collections.addAll(usages, MoveClassesOrPackagesUtil.findUsages(aClass, mySearchInComments, mySearchInNonJavaFiles, aClass.getName()));
-        }
-        packageNames.add(((PsiClassOwner)psiFile).getPackageName());
-      }
-    }
-    final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(myProject);
-    for (String packageName : packageNames) {
-      final PsiPackage aPackage = psiFacade.findPackage(packageName);
-      if (aPackage != null) {
-        boolean remainsNothing = true;
-        for (PsiDirectory packageDirectory : aPackage.getDirectories()) {
-          if (!isUnderRefactoring(packageDirectory)) {
-            remainsNothing = false;
-            break;
-          }
-        }
-        if (remainsNothing) {
-          for (PsiReference reference : ReferencesSearch.search(aPackage)) {
-            final PsiElement element = reference.getElement();
-            final PsiImportStatementBase statementBase = PsiTreeUtil.getParentOfType(element, PsiImportStatementBase.class);
-            if (statementBase != null && statementBase.isOnDemand()) {
-              usages.add(new RemoveOnDemandImportStatementsUsageInfo(statementBase));
-            }
-          }
-        }
-      }
+    for (MoveDirectoryWithClassesHelper helper : MoveDirectoryWithClassesHelper.findAll()) {
+      helper.findUsages(myFilesToMove.keySet(), myDirectories, usages, mySearchInComments, mySearchInNonJavaFiles, myProject);
    }
    return UsageViewUtil.removeDuplicatedUsages(usages.toArray(new UsageInfo[usages.size()]));
  }

-  private boolean isUnderRefactoring(PsiDirectory packageDirectory) {
-    for (PsiDirectory directory : myDirectories) {
-      if (PsiTreeUtil.isAncestor(directory, packageDirectory, true)) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-
  @Override
  protected boolean preprocessUsages(Ref<UsageInfo[]> refUsages) {
    final MultiMap<PsiElement, String> conflicts = new MultiMap<PsiElement, String>();
@@ -189,31 +150,23 @@ public class MoveDirectoryWithClassesProcessor extends BaseRefactoringProcessor
    final List<PsiFile> movedFiles = new ArrayList<PsiFile>();
    final Map<PsiElement, PsiElement> oldToNewElementsMapping = new HashMap<PsiElement, PsiElement>();
    for (PsiFile psiFile : myFilesToMove.keySet()) {
-      ChangeContextUtil.encodeContextInfo(psiFile, true);
+      for (MoveDirectoryWithClassesHelper helper : MoveDirectoryWithClassesHelper.findAll()) {
+        helper.beforeMove(psiFile);
+      }
      final RefactoringElementListener listener = getTransaction().getElementListener(psiFile);
      final PsiDirectory moveDestination = myFilesToMove.get(psiFile).getTargetDirectory();
-      if (psiFile instanceof PsiClassOwner) {
-        for (PsiClass psiClass : ((PsiClassOwner)psiFile).getClasses()) {
-          final PsiClass newClass = MoveClassesOrPackagesUtil.doMoveClass(psiClass, moveDestination);
-          oldToNewElementsMapping.put(psiClass, newClass);
-          listener.elementMoved(newClass);
-        }
-      } else {
-        if (!moveDestination.equals(psiFile.getContainingDirectory())) {
-          MoveFileHandler.forElement(psiFile).prepareMovedFile(psiFile, moveDestination, oldToNewElementsMapping);

-          PsiFile moving = moveDestination.findFile(psiFile.getName());
-          if (moving == null) {
-            MoveFilesOrDirectoriesUtil.doMoveFile(psiFile, moveDestination);
-          }
-          moving = moveDestination.findFile(psiFile.getName());
-          movedFiles.add(moving);
-          listener.elementMoved(psiFile);
+      for (MoveDirectoryWithClassesHelper helper : MoveDirectoryWithClassesHelper.findAll()) {
+        boolean processed = helper.move(psiFile, moveDestination, oldToNewElementsMapping, movedFiles, listener);
+        if (processed) {
+          break;
        }
      }
    }
    for (PsiElement newElement : oldToNewElementsMapping.values()) {
-      ChangeContextUtil.decodeContextInfo(newElement, null, null);
+      for (MoveDirectoryWithClassesHelper helper : MoveDirectoryWithClassesHelper.findAll()) {
+        helper.afterMove(newElement);
+      }
    }

    // fix references in moved files to outer files
@@ -222,14 +175,9 @@ public class MoveDirectoryWithClassesProcessor extends BaseRefactoringProcessor
      FileReferenceContextUtil.decodeFileReferences(movedFile);
    }

-    myNonCodeUsages = MoveClassesOrPackagesProcessor.retargetUsages(usages, oldToNewElementsMapping);
-    for (UsageInfo usage : usages) {
-      if (usage instanceof RemoveOnDemandImportStatementsUsageInfo) {
-        final PsiElement element = usage.getElement();
-        if (element != null) {
-          element.delete();
-        }
-      }
+    myNonCodeUsages = CommonMoveUtil.retargetUsages(usages, oldToNewElementsMapping);
+    for (MoveDirectoryWithClassesHelper helper : MoveDirectoryWithClassesHelper.findAll()) {
+      helper.postProcessUsages(usages);
    }
    for (PsiDirectory directory : myDirectories) {
      directory.delete();
@@ -273,12 +221,6 @@ public class MoveDirectoryWithClassesProcessor extends BaseRefactoringProcessor
    return new TargetDirectoryWrapper(myTargetDirectory);
  }

-  private static class RemoveOnDemandImportStatementsUsageInfo extends UsageInfo {
-    public RemoveOnDemandImportStatementsUsageInfo(PsiImportStatementBase statementBase) {
-      super(statementBase);
-    }
-  }
-  
  public static class TargetDirectoryWrapper {
    private TargetDirectoryWrapper myParentDirectory;
    private PsiDirectory myTargetDirectory;
@@ -220,6 +220,7 @@

  <extensionPoint name="refactoring.copyHandler" interface="com.intellij.refactoring.copy.CopyHandlerDelegate"/>
  <extensionPoint name="refactoring.moveHandler" interface="com.intellij.refactoring.move.MoveHandlerDelegate"/>
+  <extensionPoint name="refactoring.moveDirectoryWithClassesHelper" interface="com.intellij.refactoring.move.moveClassesOrPackages.MoveDirectoryWithClassesHelper"/>
  <extensionPoint name="refactoring.moveClassHandler" interface="com.intellij.refactoring.move.moveClassesOrPackages.MoveClassHandler"/>
  <extensionPoint name="refactoring.moveMemberHandler" beanClass="com.intellij.lang.LanguageExtensionPoint"/>
  <extensionPoint name="refactoring.moveInnerHandler" beanClass="com.intellij.lang.LanguageExtensionPoint"/>
@@ -629,4 +629,6 @@
  <inspectionsReportConverter implementation="com.intellij.codeInspection.ex.PlainTextFormatter" />

  <documentationProvider implementation="com.intellij.openapi.paths.WebReferenceDocumentationProvider"/>
+
+  <refactoring.moveDirectoryWithClassesHelper implementation="com.intellij.refactoring.move.moveClassesOrPackages.MoveDirectoryWithClassesHelper$Default" order="last"/>
 </extensions>
@@ -27,6 +27,7 @@ import com.intellij.refactoring.listeners.RefactoringElementListener;
 import com.intellij.refactoring.move.MoveCallback;
 import com.intellij.refactoring.move.moveClassesOrPackages.MoveClassesOrPackagesProcessor;
 import com.intellij.refactoring.move.moveClassesOrPackages.MoveClassesOrPackagesUtil;
+import com.intellij.refactoring.move.moveClassesOrPackages.CommonMoveUtil;
 import com.intellij.refactoring.util.NonCodeUsageInfo;
 import com.intellij.refactoring.util.RefactoringUIUtil;
 import com.intellij.usageView.UsageInfo;
@@ -128,7 +129,7 @@ public class MoveGroovyScriptProcessor extends MoveClassesOrPackagesProcessor {
        GroovyChangeContextUtil.decodeContextInfo(element, null, null);
      }

-      myNonCodeUsages = retargetUsages(usages, oldToNewElementsMapping);
+      myNonCodeUsages = CommonMoveUtil.retargetUsages(usages, oldToNewElementsMapping);
    }
    catch (IncorrectOperationException e) {
      myNonCodeUsages = new NonCodeUsageInfo[0];
@@ -722,6 +722,8 @@
    <refactoring.moveHandler implementation="com.intellij.refactoring.move.moveInner.MoveInnerToUpperOrMembersHandler"/>
    <refactoring.moveHandler implementation="com.intellij.refactoring.anonymousToInner.MoveAnonymousToInnerHandler"/>

+    <refactoring.moveDirectoryWithClassesHelper implementation="com.intellij.refactoring.move.moveClassesOrPackages.JavaMoveDirectoryWithClassesHelper"/>
+
    <moveFileHandler implementation="com.intellij.refactoring.move.moveClassesOrPackages.MoveJavaFileHandler" id="java"/>

    <refactoring.moveClassHandler implementation="com.intellij.refactoring.move.moveClassesOrPackages.MoveJavaClassHandler" id="java"/>