Java MoveRenameUsageInfo类代码示例

import com.intellij.refactoring.util.MoveRenameUsageInfo; //导入依赖的package包/类
@Nullable
@Override
public List<UsageInfo> findUsages( PsiFile psiFile, PsiDirectory newParent, boolean searchInComments, boolean searchInNonJavaFiles )
{
  Module mod = ModuleUtilCore.findModuleForPsiElement( psiFile );
  ManModule module = ManProject.getModule( mod );
  PsiClass psiClass = findPsiClass( psiFile );
  if( psiClass == null )
  {
    return Collections.emptyList();
  }

  Query<PsiReference> search = ReferencesSearch.search( psiClass, GlobalSearchScope.moduleWithDependenciesAndLibrariesScope( module.getIjModule() ) );
  List<UsageInfo> usages = new ArrayList<>();
  for( PsiReference ref: search.findAll() )
  {
    usages.add( new MoveRenameUsageInfo( ref.getElement(), ref, ref.getRangeInElement().getStartOffset(),
      ref.getRangeInElement().getEndOffset(), psiClass,
      ref.resolve() == null && !(ref instanceof PsiPolyVariantReference && ((PsiPolyVariantReference)ref).multiResolve( true ).length > 0) ) );
  }
  return usages;
}
 

import com.intellij.refactoring.util.MoveRenameUsageInfo; //导入依赖的package包/类
private static List<UsageInfo> findUsages( PsiElement element, PsiElement ctx )
  {
//    Module mod = ModuleUtilCore.findModuleForPsiElement( element );
//    if( mod == null )
//    {
//      return Collections.emptyList();
//    }

    Query<PsiReference> search = ReferencesSearch.search( element, GlobalSearchScope.moduleScope( ModuleUtilCore.findModuleForPsiElement( ctx ) ) );
    List<UsageInfo> usages = new ArrayList<>();
    for( PsiReference ref : search.findAll() )
    {
      MoveRenameUsageInfo usageInfo = new MoveRenameUsageInfo( ref.getElement(), ref, ref.getRangeInElement().getStartOffset(),
                                                               ref.getRangeInElement().getEndOffset(), element,
                                                               ref.resolve() == null && !(ref instanceof PsiPolyVariantReference && ((PsiPolyVariantReference)ref).multiResolve( true ).length > 0) );
      usages.add( usageInfo );
    }
    return usages;
  }
 

import com.intellij.refactoring.util.MoveRenameUsageInfo; //导入依赖的package包/类
@Override
public void retargetUsages(List<UsageInfo> usageInfos, Map<PsiElement, PsiElement> oldToNewMap) {
  for (UsageInfo usage : usageInfos) {
    if (usage instanceof MoveRenameUsageInfo) {
      final MoveRenameUsageInfo moveRenameUsage = (MoveRenameUsageInfo)usage;
      final PsiElement oldElement = moveRenameUsage.getReferencedElement();
      final PsiElement newElement = oldToNewMap.get(oldElement);
      final PsiReference reference = moveRenameUsage.getReference();
      if (reference != null) {
        try {
          LOG.assertTrue(newElement != null, oldElement != null ? oldElement : reference);
          reference.bindToElement(newElement);
        } catch (IncorrectOperationException ex) {
          LOG.error(ex);
        }
      }
    }
  }
}
 

import com.intellij.refactoring.util.MoveRenameUsageInfo; //导入依赖的package包/类
public static UsageInfo[] findUsages(final PsiElement element,
                                     boolean searchInStringsAndComments,
                                     boolean searchInNonJavaFiles,
                                     final String newQName) {
  PsiManager manager = element.getManager();

  ArrayList<UsageInfo> results = new ArrayList<UsageInfo>();
  Set<PsiReference> foundReferences = new HashSet<PsiReference>();

  GlobalSearchScope projectScope = GlobalSearchScope.projectScope(manager.getProject());
  for (PsiReference reference : ReferencesSearch.search(element, projectScope, false)) {
    TextRange range = reference.getRangeInElement();
    if (foundReferences.contains(reference)) continue;
    results.add(new MoveRenameUsageInfo(reference.getElement(), reference, range.getStartOffset(), range.getEndOffset(), element, false));
    foundReferences.add(reference);
  }

  findNonCodeUsages(searchInStringsAndComments, searchInNonJavaFiles, element, newQName, results);
  preprocessUsages(results);
  return results.toArray(new UsageInfo[results.size()]);
}
 

import com.intellij.refactoring.util.MoveRenameUsageInfo; //导入依赖的package包/类
protected List<UsageInfo> filterUsages(List<UsageInfo> infos) {
  Map<PsiElement, MoveRenameUsageInfo> moveRenameInfos = new HashMap<PsiElement, MoveRenameUsageInfo>();
  Set<PsiElement> usedElements = new HashSet<PsiElement>();

  List<UsageInfo> result = new ArrayList<UsageInfo>(infos.size() / 2);
  for (UsageInfo info : infos) {
    LOG.assertTrue(info != null, getClass());
    PsiElement element = info.getElement();
    if (info instanceof MoveRenameUsageInfo) {
      if (usedElements.contains(element)) continue;
      moveRenameInfos.put(element, (MoveRenameUsageInfo)info);
    }
    else {
      moveRenameInfos.remove(element);
      usedElements.add(element);
      if (!(info instanceof PossiblyIncorrectUsage) || ((PossiblyIncorrectUsage)info).isCorrect()) {
        result.add(info);
      }
    }
  }
  result.addAll(moveRenameInfos.values());
  return result;
}
 

import com.intellij.refactoring.util.MoveRenameUsageInfo; //导入依赖的package包/类
@Override
public void retargetUsages(List<UsageInfo> usageInfos, Map<PsiElement, PsiElement> oldToNewMap) {
  for (UsageInfo usage : usageInfos) {
    if (usage instanceof MoveRenameUsageInfo) {
      final MoveRenameUsageInfo moveRenameUsage = (MoveRenameUsageInfo)usage;
      final PsiElement oldElement = moveRenameUsage.getReferencedElement();
      final PsiElement newElement = oldToNewMap.get(oldElement);
      final PsiReference reference = moveRenameUsage.getReference();
      if (reference != null) {
        try {
          LOG.assertTrue(newElement != null, oldElement != null ? oldElement : reference);
          reference.bindToElement(newElement);
        }
        catch (IncorrectOperationException ex) {
          LOG.error(ex);
        }
      }
    }
  }
}
 

import com.intellij.refactoring.util.MoveRenameUsageInfo; //导入依赖的package包/类
@Nullable
public UsageGroup groupUsage(@NotNull Usage usage) {
    if (usage instanceof UsageInfo2UsageAdapter) {
        final UsageInfo2UsageAdapter u = (UsageInfo2UsageAdapter)usage;
        final UsageInfo usageInfo = u.getUsageInfo();
        if (usageInfo instanceof MoveRenameUsageInfo) {
            final MoveRenameUsageInfo info = (MoveRenameUsageInfo)usageInfo;
            return buildGroup(info.getReferencedElement(), usageInfo, true);
        } else {
            final PsiReference[] references = u.getElement().getReferences();
            for (PsiReference reference : references) {
                if (reference.getRangeInElement().equals(usageInfo.getRangeInElement())) {
                    return buildGroup(reference.resolve(), usageInfo, false);
                }
            }
        }
    }
    return null;
}
 

import com.intellij.refactoring.util.MoveRenameUsageInfo; //导入依赖的package包/类
private static void findInstancesOfPackageLocal(final PsiClass aClass,
                                         final UsageInfo[] usages,
                                         final MyClassInstanceReferenceVisitor instanceReferenceVisitor) {
  ClassReferenceScanner referenceScanner = new ClassReferenceScanner(aClass) {
    public PsiReference[] findReferences() {
      ArrayList<PsiReference> result = new ArrayList<PsiReference>();
      for (UsageInfo usage : usages) {
        if (usage instanceof MoveRenameUsageInfo && ((MoveRenameUsageInfo)usage).getReferencedElement() == aClass) {
          final PsiReference reference = usage.getReference();
          if (reference != null) {
            result.add(reference);
          }
        }
      }
      return result.toArray(new PsiReference[result.size()]);
    }
  };
  referenceScanner.processReferences(new ClassInstanceScanner(aClass, instanceReferenceVisitor));
}
 

import com.intellij.refactoring.util.MoveRenameUsageInfo; //导入依赖的package包/类
private void storeTypeManifoldReferences( @NotNull PsiElement element )
{
  Module mod = ModuleUtilCore.findModuleForPsiElement( element );
  if( mod == null )
  {
    return;
  }

  ManModule module = ManProject.getModule( mod );

  PsiClass psiClass = findPsiClass( (PsiFileSystemItem)element, module );
  if( psiClass == null )
  {
    return;
  }

  Query<PsiReference> search = ReferencesSearch.search( psiClass, GlobalSearchScope.projectScope( mod.getProject() ) );
  List<UsageInfo> usages = new ArrayList<>();
  for( PsiReference ref: search.findAll() )
  {
    usages.add( new MoveRenameUsageInfo( ref.getElement(), ref, ref.getRangeInElement().getStartOffset(),
      ref.getRangeInElement().getEndOffset(), element,
      ref.resolve() == null && !(ref instanceof PsiPolyVariantReference && ((PsiPolyVariantReference)ref).multiResolve( true ).length > 0) ) );
  }
  _usages = usages;

  if( psiClass instanceof ManifoldPsiClass )
  {
    PsiElement fakeElement = ManGotoDeclarationHandler.find( psiClass, (ManifoldPsiClass)psiClass );
    if( fakeElement instanceof PsiNamedElement && isTopLevelClassDeclaration( fakeElement ) )
    {
      _classDeclElement = (PsiNamedElement)fakeElement;
    }
  }
}
 

import com.intellij.refactoring.util.MoveRenameUsageInfo; //导入依赖的package包/类
public void findCollisions(final PsiElement element, final String newName, final Map<? extends PsiElement, String> allRenames, final List<UsageInfo> result) {
  final PsiClass aClass = (PsiClass)element;
  final ClassCollisionsDetector classCollisionsDetector = new ClassCollisionsDetector(aClass);
  Collection<UsageInfo> initialResults = new ArrayList<UsageInfo>(result);
  for(UsageInfo usageInfo: initialResults) {
    if (usageInfo instanceof MoveRenameUsageInfo) {
      classCollisionsDetector.addClassCollisions(usageInfo.getElement(), newName, result);
    }
  }
  findSubmemberHidesMemberCollisions(aClass, newName, result);

  if (aClass instanceof PsiTypeParameter) {
    final PsiTypeParameterListOwner owner = ((PsiTypeParameter)aClass).getOwner();
    if (owner != null) {
      for (PsiTypeParameter typeParameter : owner.getTypeParameters()) {
        if (Comparing.equal(newName, typeParameter.getName())) {
          result.add(new UnresolvableCollisionUsageInfo(aClass, typeParameter) {
            @Override
            public String getDescription() {
              return "There is already type parameter in " + RefactoringUIUtil.getDescription(aClass, false) + " with name " + newName;
            }
          });
        }
      }
    }
  }
}
 

import com.intellij.refactoring.util.MoveRenameUsageInfo; //导入依赖的package包/类
public void testAllUsagesInCode() throws Exception {
  configureByFile(BASE_PATH + getTestName(false) + ".java");
  PsiElement element = TargetElementUtil
      .findTargetElement(myEditor, TargetElementUtil.ELEMENT_NAME_ACCEPTED | TargetElementUtil.REFERENCED_ELEMENT_ACCEPTED);
  assertNotNull(element);
  final UsageInfo[] usageInfos = RenameUtil.findUsages(element, "newName", true, true, new HashMap<>());
  assertSize(1, usageInfos);
  for (UsageInfo usageInfo : usageInfos) {
    assertTrue(usageInfo instanceof MoveRenameUsageInfo);
    assertFalse(usageInfo.isNonCodeUsage);
  }
}
 

import com.intellij.refactoring.util.MoveRenameUsageInfo; //导入依赖的package包/类
public static MultiMap<PsiElement, UsageInfo> classifyUsages(Collection<? extends PsiElement> elements, UsageInfo[] usages) {
  final MultiMap<PsiElement, UsageInfo> result = new MultiMap<PsiElement, UsageInfo>();
  for (UsageInfo usage : usages) {
    LOG.assertTrue(usage instanceof MoveRenameUsageInfo);
    if (usage.getReference() instanceof LightElement) {
      continue; //filter out implicit references (e.g. from derived class to super class' default constructor)
    }
    MoveRenameUsageInfo usageInfo = (MoveRenameUsageInfo)usage;
    if (usage instanceof RelatedUsageInfo) {
      final PsiElement relatedElement = ((RelatedUsageInfo)usage).getRelatedElement();
      if (elements.contains(relatedElement)) {
        result.putValue(relatedElement, usage);
      }
    } else {
      PsiElement referenced = usageInfo.getReferencedElement();
      if (elements.contains(referenced)) {
        result.putValue(referenced, usage);
      } else if (referenced != null) {
        PsiElement indirect = referenced.getNavigationElement();
        if (elements.contains(indirect)) {
          result.putValue(indirect, usage);
        }
      }

    }
  }
  return result;
}
 

import com.intellij.refactoring.util.MoveRenameUsageInfo; //导入依赖的package包/类
private static UsageInfo[] extractUsagesForElement(PsiElement element, UsageInfo[] usages) {
  final ArrayList<UsageInfo> extractedUsages = new ArrayList<UsageInfo>(usages.length);
  for (UsageInfo usage : usages) {
    if (usage instanceof MoveRenameUsageInfo) {
      MoveRenameUsageInfo usageInfo = (MoveRenameUsageInfo)usage;
      if (element.equals(usageInfo.getReferencedElement())) {
        extractedUsages.add(usageInfo);
      }
    }
  }
  return extractedUsages.toArray(new UsageInfo[extractedUsages.size()]);
}
 

import com.intellij.refactoring.util.MoveRenameUsageInfo; //导入依赖的package包/类
@Override
public void findCollisions(PsiElement element,
                           String newName,
                           Map<? extends PsiElement, String> allRenames,
                           List<UsageInfo> result) {
  List<UsageInfo> collisions = new ArrayList<UsageInfo>();

  for (UsageInfo info : result) {
    if (!(info instanceof MoveRenameUsageInfo)) continue;
    final PsiElement infoElement = info.getElement();
    final PsiElement referencedElement = ((MoveRenameUsageInfo)info).getReferencedElement();

    if (!(infoElement instanceof GrReferenceExpression)) continue;

    final GrReferenceExpression refExpr = (GrReferenceExpression)infoElement;

    if (!(referencedElement instanceof GrField || refExpr.advancedResolve().isInvokedOnProperty())) continue;

    if (!(refExpr.getParent() instanceof GrCall)) continue;

    final PsiType[] argTypes = PsiUtil.getArgumentTypes(refExpr, false);
    final PsiType[] typeArguments = refExpr.getTypeArguments();
    final MethodResolverProcessor processor =
      new MethodResolverProcessor(newName, refExpr, false, null, argTypes, typeArguments);
    final PsiMethod resolved = ResolveUtil.resolveExistingElement(refExpr, processor, PsiMethod.class);
    if (resolved == null) continue;

    collisions.add(new UnresolvableCollisionUsageInfo(resolved, refExpr) {
      @Override
      public String getDescription() {
        return GroovyRefactoringBundle.message("usage.will.be.overriden.by.method", refExpr.getParent().getText(), PsiFormatUtil
          .formatMethod(resolved, PsiSubstitutor.EMPTY, PsiFormatUtilBase.SHOW_NAME, PsiFormatUtilBase.SHOW_TYPE));
      }
    });
  }
  result.addAll(collisions);
  super.findCollisions(element, newName, allRenames, result);
}
 

import com.intellij.refactoring.util.MoveRenameUsageInfo; //导入依赖的package包/类
public void testAllUsagesInCode() throws Exception {
  configureByFile(BASE_PATH + getTestName(false) + ".java");
  PsiElement element = TargetElementUtilBase
      .findTargetElement(myEditor, TargetElementUtilBase.ELEMENT_NAME_ACCEPTED | TargetElementUtilBase.REFERENCED_ELEMENT_ACCEPTED);
  assertNotNull(element);
  final UsageInfo[] usageInfos = RenameUtil.findUsages(element, "newName", true, true, new HashMap<PsiElement, String>());
  assertSize(1, usageInfos);
  for (UsageInfo usageInfo : usageInfos) {
    assertTrue(usageInfo instanceof MoveRenameUsageInfo);
    assertFalse(usageInfo.isNonCodeUsage);
  }
}