Java RenameUtil类代码示例

import com.intellij.refactoring.rename.RenameUtil; //导入依赖的package包/类
private static boolean checkMovePackage(Project project, PsiPackage aPackage) {
  final PsiDirectory[] directories = aPackage.getDirectories();
  final VirtualFile[] virtualFiles = aPackage.occursInPackagePrefixes();
  if (directories.length > 1 || virtualFiles.length > 0) {
    final StringBuffer message = new StringBuffer();
    RenameUtil.buildPackagePrefixChangedMessage(virtualFiles, message, aPackage.getQualifiedName());
    if (directories.length > 1) {
      DirectoryAsPackageRenameHandlerBase.buildMultipleDirectoriesInPackageMessage(message, aPackage.getQualifiedName(), directories);
      message.append("\n\n");
      String report = RefactoringBundle
        .message("all.these.directories.will.be.moved.and.all.references.to.0.will.be.changed", aPackage.getQualifiedName());
      message.append(report);
    }
    message.append("\n");
    message.append(RefactoringBundle.message("do.you.wish.to.continue"));
    int ret =
      Messages.showYesNoDialog(project, message.toString(), RefactoringBundle.message("warning.title"), Messages.getWarningIcon());
    if (ret != Messages.YES) {
      return false;
    }
  }
  return true;
}
 

import com.intellij.refactoring.rename.RenameUtil; //导入依赖的package包/类
private static void processFunctionDeclaration(@NotNull PyChangeInfo changeInfo, @NotNull PyFunction function) {
  if (changeInfo.isParameterNamesChanged()) {
    final PyParameter[] oldParameters = function.getParameterList().getParameters();
    for (PyParameterInfo paramInfo: changeInfo.getNewParameters()) {
      if (paramInfo.getOldIndex() >= 0 && paramInfo.isRenamed()) {
        final String newName = StringUtil.trimLeading(paramInfo.getName(), '*').trim();
        final UsageInfo[] usages = RenameUtil.findUsages(oldParameters[paramInfo.getOldIndex()], newName, true, false, null);
        for (UsageInfo info : usages) {
          RenameUtil.rename(info, newName);
        }
      }
    }
  }
  if (changeInfo.isParameterSetOrOrderChanged()) {
    fixDoc(changeInfo, function);
    updateParameterList(changeInfo, function);
  }
  if (changeInfo.isNameChanged()) {
    RenameUtil.doRenameGenericNamedElement(function, changeInfo.getNewName(), UsageInfo.EMPTY_ARRAY, null);
  }
}
 

import com.intellij.refactoring.rename.RenameUtil; //导入依赖的package包/类
@Nullable
@Override
protected PsiElement processRef(PsiReference ref, String newName) {
  PsiElement element = ref.getElement();
  if (RenameUtil.isValidName(element.getProject(), element, newName) || element instanceof GrReferenceElement) {
    return super.processRef(ref, newName);
  }

  PsiElement nameElement;
  if (element instanceof PsiReferenceExpression) {
    nameElement = ((PsiReferenceExpression)element).getReferenceNameElement();
  }
  else {
    return null;
  }
  TextRange range = nameElement.getTextRange();
  Document document = PsiDocumentManager.getInstance(element.getProject()).getDocument(nameElement.getContainingFile());
  document.replaceString(range.getStartOffset(), range.getEndOffset(), newName);

  return null;
}
 

import com.intellij.refactoring.rename.RenameUtil; //导入依赖的package包/类
public MultiMap<PsiElement, String> findConflicts(Ref<UsageInfo[]> refUsages) {
  MultiMap<PsiElement, String> conflictDescriptions = new MultiMap<PsiElement, String>();
  addMethodConflicts(conflictDescriptions);
  UsageInfo[] usagesIn = refUsages.get();
  RenameUtil.addConflictDescriptions(usagesIn, conflictDescriptions);
  Set<UsageInfo> usagesSet = new HashSet<UsageInfo>(Arrays.asList(usagesIn));
  RenameUtil.removeConflictUsages(usagesSet);
  if (myChangeInfo.isVisibilityChanged()) {
    try {
      addInaccessibilityDescriptions(usagesSet, conflictDescriptions);
    }
    catch (IncorrectOperationException e) {
      LOG.error(e);
    }
  }

  return conflictDescriptions;
}
 

import com.intellij.refactoring.rename.RenameUtil; //导入依赖的package包/类
@Before
public void setUp() {
    MockitoAnnotations.initMocks(this);
    PowerMockito.mockStatic(CommandUtils.class, TFSVcs.class, PersistentFS.class, RenameUtil.class);

    when(mockPsiFile.getVirtualFile()).thenReturn(mockVirtualFile);
    when(mockPsiFile.getProject()).thenReturn(mockProject);
    when(mockPsiDirectory.getVirtualFile()).thenReturn(mockVirtualFile);
    when(mockPsiDirectory.getProject()).thenReturn(mockProject);
    when(mockVirtualParent.getPath()).thenReturn(PARENT_PATH);
    when(mockVirtualFile.getParent()).thenReturn(mockVirtualParent);

    when(mockTFSVcs.getServerContext(anyBoolean())).thenReturn(mockServerContext);
    when(TFSVcs.getInstance(mockProject)).thenReturn(mockTFSVcs);
    when(PersistentFS.getInstance()).thenReturn(mockPersistentFS);
}
 

import com.intellij.refactoring.rename.RenameUtil; //导入依赖的package包/类
@Test
public void testExecute_RenameFileNoChanges() {
    when(mockVirtualFile.getPath()).thenReturn(CURRENT_FILE_PATH);
    when(CommandUtils.getStatusForFiles(mockServerContext, ImmutableList.of(CURRENT_FILE_PATH)))
            .thenReturn(Collections.EMPTY_LIST);

    RenameFileDirectory.execute(mockPsiFile, NEW_FILE_NAME, usageInfos, mockListener);

    verifyStatic(times(1));
    CommandUtils.renameFile(eq(mockServerContext), eq(CURRENT_FILE_PATH), eq(NEW_FILE_PATH));
    PersistentFS.getInstance().processEvents(any(List.class));
    verify(mockListener).elementRenamed(mockPsiFile);

    verifyStatic(never());
    RenameUtil.doRenameGenericNamedElement(any(PsiElement.class), any(String.class), any(UsageInfo[].class), any(RefactoringElementListener.class));
}
 

import com.intellij.refactoring.rename.RenameUtil; //导入依赖的package包/类
@Test
public void testExecute_RenameDirectoryNoChanges() {
    String dirName = Path.combine("/path/to/the", "directory");
    when(mockVirtualFile.getPath()).thenReturn(dirName);
    when(CommandUtils.getStatusForFiles(mockServerContext, ImmutableList.of(dirName)))
            .thenReturn(Collections.EMPTY_LIST);

    RenameFileDirectory.execute(mockPsiFile, NEW_DIRECTORY_NAME, usageInfos, mockListener);

    verifyStatic(times(1));
    CommandUtils.renameFile(eq(mockServerContext), eq(dirName), eq(Path.combine("/path/to/the", "newDirectory")));
    PersistentFS.getInstance().processEvents(any(List.class));
    verify(mockListener).elementRenamed(mockPsiFile);

    verifyStatic(never());
    RenameUtil.doRenameGenericNamedElement(any(PsiElement.class), any(String.class), any(UsageInfo[].class), any(RefactoringElementListener.class));
}
 

import com.intellij.refactoring.rename.RenameUtil; //导入依赖的package包/类
@Test
public void testExecute_RenameFileEditChanges() {
    when(mockPendingChange.getChangeTypes()).thenReturn(ImmutableList.of(ServerStatusType.EDIT));
    when(mockVirtualFile.getPath()).thenReturn(CURRENT_FILE_PATH);
    when(CommandUtils.getStatusForFiles(mockServerContext, ImmutableList.of(CURRENT_FILE_PATH)))
            .thenReturn(ImmutableList.of(mockPendingChange));

    RenameFileDirectory.execute(mockPsiFile, NEW_FILE_NAME, usageInfos, mockListener);

    verifyStatic(times(1));
    CommandUtils.renameFile(eq(mockServerContext), eq(CURRENT_FILE_PATH), eq(NEW_FILE_PATH));
    PersistentFS.getInstance().processEvents(any(List.class));
    verify(mockListener).elementRenamed(mockPsiFile);

    verifyStatic(never());
    RenameUtil.doRenameGenericNamedElement(any(PsiElement.class), any(String.class), any(UsageInfo[].class), any(RefactoringElementListener.class));
}
 

import com.intellij.refactoring.rename.RenameUtil; //导入依赖的package包/类
@Test
public void testExecute_RenameFileEditRenameChanges() {
    when(mockPendingChange.getChangeTypes()).thenReturn(ImmutableList.of(ServerStatusType.EDIT, ServerStatusType.RENAME));
    when(mockVirtualFile.getPath()).thenReturn(CURRENT_FILE_PATH);
    when(CommandUtils.getStatusForFiles(mockServerContext, ImmutableList.of(CURRENT_FILE_PATH)))
            .thenReturn(ImmutableList.of(mockPendingChange));

    RenameFileDirectory.execute(mockPsiFile, NEW_FILE_NAME, usageInfos, mockListener);

    verifyStatic(times(1));
    CommandUtils.renameFile(eq(mockServerContext), eq(CURRENT_FILE_PATH), eq(NEW_FILE_PATH));
    PersistentFS.getInstance().processEvents(any(List.class));
    verify(mockListener).elementRenamed(mockPsiFile);

    verifyStatic(never());
    RenameUtil.doRenameGenericNamedElement(any(PsiElement.class), any(String.class), any(UsageInfo[].class), any(RefactoringElementListener.class));
}
 

import com.intellij.refactoring.rename.RenameUtil; //导入依赖的package包/类
@Test
public void testExecute_RenameFileUnversionedChange() {
    when(mockPendingChange.getChangeTypes()).thenReturn(ImmutableList.of(ServerStatusType.ADD));
    when(mockVirtualFile.getPath()).thenReturn(CURRENT_FILE_PATH);
    when(CommandUtils.getStatusForFiles(mockServerContext, ImmutableList.of(CURRENT_FILE_PATH)))
            .thenReturn(ImmutableList.of(mockPendingChange));

    RenameFileDirectory.execute(mockPsiFile, NEW_FILE_NAME, usageInfos, mockListener);

    verifyStatic(times(1));
    RenameUtil.doRenameGenericNamedElement(mockPsiFile, NEW_FILE_NAME, usageInfos, mockListener);
    verify(mockListener).elementRenamed(mockPsiFile);

    verifyStatic(never());
    CommandUtils.renameFile(any(ServerContext.class), any(String.class), any(String.class));
    PersistentFS.getInstance().processEvents(any(List.class));
}
 

import com.intellij.refactoring.rename.RenameUtil; //导入依赖的package包/类
private static boolean checkMovePackage(Project project, PsiPackage aPackage) {
  final PsiDirectory[] directories = aPackage.getDirectories();
  final VirtualFile[] virtualFiles = aPackage.occursInPackagePrefixes();
  if (directories.length > 1 || virtualFiles.length > 0) {
    final StringBuffer message = new StringBuffer();
    RenameUtil.buildPackagePrefixChangedMessage(virtualFiles, message, aPackage.getQualifiedName());
    if (directories.length > 1) {
      DirectoryAsPackageRenameHandlerBase.buildMultipleDirectoriesInPackageMessage(message, aPackage.getQualifiedName(), directories);
      message.append("\n\n");
      String report = RefactoringBundle
        .message("all.these.directories.will.be.moved.and.all.references.to.0.will.be.changed", aPackage.getQualifiedName());
      message.append(report);
    }
    message.append("\n");
    message.append(RefactoringBundle.message("do.you.wish.to.continue"));
    int ret =
      Messages.showYesNoDialog(project, message.toString(), RefactoringBundle.message("warning.title"), Messages.getWarningIcon());
    if (ret != 0) {
      return false;
    }
  }
  return true;
}
 

import com.intellij.refactoring.rename.RenameUtil; //导入依赖的package包/类
private static boolean checkMovePackage(Project project, PsiJavaPackage aPackage) {
  final PsiDirectory[] directories = aPackage.getDirectories();
  final VirtualFile[] virtualFiles = aPackage.occursInPackagePrefixes();
  if (directories.length > 1 || virtualFiles.length > 0) {
    final StringBuffer message = new StringBuffer();
    RenameUtil.buildPackagePrefixChangedMessage(virtualFiles, message, aPackage.getQualifiedName());
    if (directories.length > 1) {
      DirectoryAsPackageRenameHandlerBase.buildMultipleDirectoriesInPackageMessage(message, aPackage.getQualifiedName(), directories);
      message.append("\n\n");
      String report = RefactoringBundle
        .message("all.these.directories.will.be.moved.and.all.references.to.0.will.be.changed", aPackage.getQualifiedName());
      message.append(report);
    }
    message.append("\n");
    message.append(RefactoringBundle.message("do.you.wish.to.continue"));
    int ret =
      Messages.showYesNoDialog(project, message.toString(), RefactoringBundle.message("warning.title"), Messages.getWarningIcon());
    if (ret != 0) {
      return false;
    }
  }
  return true;
}
 

import com.intellij.refactoring.rename.RenameUtil; //导入依赖的package包/类
private void renameManifoldTypeRefs( PsiElement element, RefactoringElementListener elementListener )
{
  ApplicationManager.getApplication().invokeLater( () ->
    WriteCommandAction.runWriteCommandAction( element.getProject(), () ->
    {
      Module ijModule = ModuleUtilCore.findModuleForPsiElement( element );
      if( ijModule == null )
      {
        return;
      }

      ManModule module = ManProject.getModule( ijModule );
      PsiClass psiClass = findPsiClass( (PsiFileSystemItem)element, module );
      if( psiClass == null )
      {
        return;
      }

      RenameUtil.doRename( psiClass, psiClass.getName(), _usages.toArray( new UsageInfo[_usages.size()] ), element.getProject(), elementListener );

      // for plain text files, also rename a class name declaration if such a thing exists e.g., javascript class declaration
      if( _classDeclElement != null )
      {
        _classDeclElement.setName( psiClass.getName() == null ? "" : psiClass.getName() );
      }
    } ) );
}
 

import com.intellij.refactoring.rename.RenameUtil; //导入依赖的package包/类
private void handleManifoldRename( PsiElement element, RefactoringElementListener elementListener )
{
  if( !(element instanceof PsiNamedElement) || _javaUsages.isEmpty() )
  {
    return;
  }

  String name = ((PsiNamedElement)element).getName();
  String newBaseName = JsonUtil.makeIdentifier( name );

  //## find a way to add this as part of the overall rename Undo?

  ApplicationManager.getApplication().saveAll();

  ApplicationManager.getApplication().invokeLater( () ->
                                                     WriteCommandAction.runWriteCommandAction( element.getProject(), () ->
                                                     {
                                                       for( Map.Entry<Pair<FeaturePath, PsiElement>, List<UsageInfo>> entry : _javaUsages.entrySet() )
                                                       {
                                                         Pair<FeaturePath, PsiElement> key = entry.getKey();
                                                         List<UsageInfo> value = entry.getValue();
                                                         String newFeatureName = newBaseName;
                                                         FeaturePath path = key.getFirst();
                                                         if( path != null )
                                                         {
                                                           newFeatureName = findFeatureName( path );
                                                           if( newFeatureName == null )
                                                           {
                                                             newFeatureName = newBaseName;
                                                           }
                                                         }
                                                         if( newFeatureName != null )
                                                         {
                                                           RenameUtil.doRename( key.getSecond(), newFeatureName, value.toArray( new UsageInfo[value.size()] ), element.getProject(), elementListener );
                                                         }
                                                       }
                                                     } ) );
}
 

import com.intellij.refactoring.rename.RenameUtil; //导入依赖的package包/类
protected void performPsiSpoilingRefactoring() {
  RenameUtil.renameNonCodeUsages(myProject, myNonCodeUsages);
  if (myMoveCallback != null) {
    if (myMoveCallback instanceof MoveClassesOrPackagesCallback) {
      ((MoveClassesOrPackagesCallback) myMoveCallback).classesOrPackagesMoved(myMoveDestination);
    }
    myMoveCallback.refactoringCompleted();
  }
}