Java PsiShortNamesCache.getClassesByName方法代码示例

import com.intellij.psi.search.PsiShortNamesCache; //导入方法依赖的package包/类
@NotNull
public Collection<PsiElement> findClassesForTest(@NotNull PsiElement element) {
  PsiClass klass = findSourceElement(element);
  if (klass == null) return Collections.emptySet();

  GlobalSearchScope scope = getSearchScope(element, true);

  PsiShortNamesCache cache = PsiShortNamesCache.getInstance(element.getProject());

  List<Pair<? extends PsiNamedElement, Integer>> classesWithWeights = new ArrayList<Pair<? extends PsiNamedElement, Integer>>();
  for (Pair<String, Integer> eachNameWithWeight : TestFinderHelper.collectPossibleClassNamesWithWeights(klass.getName())) {
    for (PsiClass eachClass : cache.getClassesByName(eachNameWithWeight.first, scope)) {
      if (isTestSubjectClass(eachClass)) {
        classesWithWeights.add(Pair.create(eachClass, eachNameWithWeight.second));
      }
    }
  }

  return TestFinderHelper.getSortedElements(classesWithWeights, false);
}
 

import com.intellij.psi.search.PsiShortNamesCache; //导入方法依赖的package包/类
private boolean collectTests(PsiClass klass, Processor<Pair<? extends PsiNamedElement, Integer>> processor) {
  GlobalSearchScope scope = getSearchScope(klass, false);

  PsiShortNamesCache cache = PsiShortNamesCache.getInstance(klass.getProject());

  String klassName = klass.getName();
  Pattern pattern = Pattern.compile(".*" + StringUtil.escapeToRegexp(klassName) + ".*", Pattern.CASE_INSENSITIVE);

  HashSet<String> names = new HashSet<String>();
  cache.getAllClassNames(names);
  final TestFrameworks frameworks = TestFrameworks.getInstance();
  for (String eachName : names) {
    if (pattern.matcher(eachName).matches()) {
      for (PsiClass eachClass : cache.getClassesByName(eachName, scope)) {
        if (eachClass.isPhysical() && (frameworks.isTestClass(eachClass) || frameworks.isPotentialTestClass(eachClass))) {
          if (!processor.process(Pair.create(eachClass, TestFinderHelper.calcTestNameProximity(klassName, eachName)))) {
            return true;
          }
        }
      }
    }
  }
  return false;
}
 

import com.intellij.psi.search.PsiShortNamesCache; //导入方法依赖的package包/类
private void appendTestClass(PsiClass aClass, String testSuffix, final GlobalSearchScope moduleScope) {
  PsiShortNamesCache cache = PsiShortNamesCache.getInstance(aClass.getProject());

  String klassName = aClass.getName();
  Pattern pattern = Pattern.compile(".*" + klassName + ".*" + testSuffix);

  HashSet<String> names = new HashSet<String>();
  cache.getAllClassNames(names);
  for (String eachName : names) {
    if (pattern.matcher(eachName).matches()) {
      for (PsiClass eachClass : cache.getClassesByName(eachName, moduleScope)) {
        if (TestFrameworks.getInstance().isTestClass(eachClass)) {
          myElements.add(eachClass);
        }
      }
    }
  }
}
 

import com.intellij.psi.search.PsiShortNamesCache; //导入方法依赖的package包/类
@Override
@NotNull
public NavigationItem[] getItemsByName(String name, final String pattern, Project project, boolean includeNonProjectItems) {
  GlobalSearchScope scope = includeNonProjectItems ? GlobalSearchScope.allScope(project) : GlobalSearchScope.projectScope(project);
  PsiShortNamesCache cache = PsiShortNamesCache.getInstance(project);

  List<PsiMember> result = new ArrayList<PsiMember>();
  for (PsiMethod method : cache.getMethodsByName(name, scope)) {
    if (!method.isConstructor() && isOpenable(method) && !hasSuperMethod(method)) {
      result.add(method);
    }
  }
  for (PsiField field : cache.getFieldsByName(name, scope)) {
    if (isOpenable(field)) {
      result.add(field);
    }
  }
  for (PsiClass aClass : cache.getClassesByName(name, scope)) {
    if (isOpenable(aClass)) {
      result.add(aClass);
    }
  }
  PsiMember[] array = result.toArray(new PsiMember[result.size()]);
  Arrays.sort(array, MyComparator.INSTANCE);
  return array;
}
 

import com.intellij.psi.search.PsiShortNamesCache; //导入方法依赖的package包/类
@Override
@NotNull
public PsiClass[] getClassesByName(@NotNull String name, @NotNull GlobalSearchScope scope)
{
	Merger<PsiClass> merger = null;
	for(PsiShortNamesCache cache : myCaches)
	{
		PsiClass[] classes = cache.getClassesByName(name, scope);
		if(classes.length != 0)
		{
			if(merger == null)
			{
				merger = new Merger<PsiClass>();
			}
			merger.add(classes);
		}
	}
	PsiClass[] result = merger == null ? null : merger.getResult();
	return result != null ? result : PsiClass.EMPTY_ARRAY;
}
 

import com.intellij.psi.search.PsiShortNamesCache; //导入方法依赖的package包/类
@Override
@NotNull
public PsiClass[] getClassesByName(@NotNull String name, @NotNull GlobalSearchScope scope) {
  Merger<PsiClass> merger = null;
  for (PsiShortNamesCache cache : myCaches) {
    PsiClass[] classes = cache.getClassesByName(name, scope);
    if (classes.length != 0) {
      if (merger == null) merger = new Merger<PsiClass>();
      merger.add(classes);
    }
  }
  PsiClass[] result = merger == null ? null : merger.getResult();
  return result != null ? result : PsiClass.EMPTY_ARRAY;
}
 

import com.intellij.psi.search.PsiShortNamesCache; //导入方法依赖的package包/类
private static void registerVariableParameterizedTypeFixes(HighlightInfo highlightInfo,
                                                           @NotNull PsiVariable variable,
                                                           @NotNull PsiReferenceParameterList parameterList,
                                                           @NotNull JavaSdkVersion version) {
  PsiType type = variable.getType();
  if (!(type instanceof PsiClassType)) return;

  if (DumbService.getInstance(variable.getProject()).isDumb()) return;

  String shortName = ((PsiClassType)type).getClassName();
  PsiManager manager = parameterList.getManager();
  final JavaPsiFacade facade = JavaPsiFacade.getInstance(manager.getProject());
  PsiShortNamesCache shortNamesCache = PsiShortNamesCache.getInstance(parameterList.getProject());
  PsiClass[] classes = shortNamesCache.getClassesByName(shortName, GlobalSearchScope.allScope(manager.getProject()));
  PsiElementFactory factory = facade.getElementFactory();
  for (PsiClass aClass : classes) {
    if (checkReferenceTypeArgumentList(aClass, parameterList, PsiSubstitutor.EMPTY, false, version) == null) {
      PsiType[] actualTypeParameters = parameterList.getTypeArguments();
      PsiTypeParameter[] classTypeParameters = aClass.getTypeParameters();
      Map<PsiTypeParameter, PsiType> map = new java.util.HashMap<PsiTypeParameter, PsiType>();
      for (int j = 0; j < classTypeParameters.length; j++) {
        PsiTypeParameter classTypeParameter = classTypeParameters[j];
        PsiType actualTypeParameter = actualTypeParameters[j];
        map.put(classTypeParameter, actualTypeParameter);
      }
      PsiSubstitutor substitutor = factory.createSubstitutor(map);
      PsiType suggestedType = factory.createType(aClass, substitutor);
      HighlightUtil.registerChangeVariableTypeFixes(variable, suggestedType, variable.getInitializer(), highlightInfo);
    }
  }
}
 

import com.intellij.psi.search.PsiShortNamesCache; //导入方法依赖的package包/类
@Override
@NotNull
public NavigationItem[] getItemsByName(String name, final String pattern, Project project, boolean includeNonProjectItems) {
  GlobalSearchScope scope = includeNonProjectItems ? GlobalSearchScope.allScope(project) : GlobalSearchScope.projectScope(project);
  PsiShortNamesCache cache = PsiShortNamesCache.getInstance(project);

  Condition<PsiMember> qualifiedMatcher = getQualifiedNameMatcher(pattern);

  List<PsiMember> result = new ArrayList<PsiMember>();
  for (PsiMethod method : cache.getMethodsByName(name, scope)) {
    if (!method.isConstructor() && isOpenable(method) && !hasSuperMethod(method, scope, qualifiedMatcher)) {
      result.add(method);
    }
  }
  for (PsiField field : cache.getFieldsByName(name, scope)) {
    if (isOpenable(field)) {
      result.add(field);
    }
  }
  for (PsiClass aClass : cache.getClassesByName(name, scope)) {
    if (isOpenable(aClass)) {
      result.add(aClass);
    }
  }
  PsiMember[] array = result.toArray(new PsiMember[result.size()]);
  Arrays.sort(array, MyComparator.INSTANCE);
  return array;
}
 

import com.intellij.psi.search.PsiShortNamesCache; //导入方法依赖的package包/类
@NotNull
protected List<PsiClass> getClassesByName(final String name,
                                          final boolean checkBoxState,
                                          final String pattern,
                                          final GlobalSearchScope searchScope) {
  final PsiShortNamesCache cache = PsiShortNamesCache.getInstance(getProject());
  PsiClass[] classes =
    cache.getClassesByName(name, checkBoxState ? searchScope : GlobalSearchScope.projectScope(getProject()).intersectWith(searchScope));
  return ContainerUtil.newArrayList(classes);
}
 

import com.intellij.psi.search.PsiShortNamesCache; //导入方法依赖的package包/类
@Override
public void addImportCandidates(PsiReference reference, String name, AutoImportQuickFix quickFix) {
  final PsiElement element = reference.getElement();
  final Project project = element.getProject();
  Module module = ModuleUtil.findModuleForPsiElement(element);
  GlobalSearchScope scope = module == null ? ProjectScope.getAllScope(project) : module.getModuleWithDependenciesAndLibrariesScope(false);
  PsiShortNamesCache cache = PsiShortNamesCache.getInstance(project);
  final PsiClass[] classesByName = cache.getClassesByName(name, scope);
  for (PsiClass psiClass : classesByName) {
    final QualifiedName packageQName = QualifiedName.fromDottedString(psiClass.getQualifiedName()).removeLastComponent();
    quickFix.addImport(psiClass, psiClass.getContainingFile(), packageQName);
  }
}
 

import com.intellij.psi.search.PsiShortNamesCache; //导入方法依赖的package包/类
private Map<PsiElement,Item> getGlobalEnvItems() {
  if (global_envitems_ready) {
    return global_envitems;
  } else {

    synchronized (global_envitems_lock) {

      if (global_envitems == null) {
        // get all classes from IntelliJ
        global_envitems = new HashMap<PsiElement, Item>();
      }

      logger.info("making global_envitems (" + global_envitems.size() + " items already there)");

      PsiShortNamesCache cache = PsiShortNamesCache.getInstance(project);
      String[] classnames = cache.getAllClassNames();
      GlobalSearchScope scope = new ProjectAndLibrariesScope(project, true);

      // Add all classes.  TODO: This includes local classes, but probably shouldn't
      Map<PsiElement,Item> fake_globals = new HashMap<PsiElement,Item>();
      for (String name : classnames)
        for (PsiClass cls : cache.getClassesByName(name, scope))
          if (!isInaccessible(cls, true))
            addClass(fake_globals, global_envitems, cls, true, true);

      logger.info("making global_env with " + global_envitems.size() + " items.");

      // update global_env
      global_env = Tarski.environment(global_envitems.values());

      logger.info("global_env ready.");

      global_envitems_ready = true;

    }

    return global_envitems;
  }
}
 

import com.intellij.psi.search.PsiShortNamesCache; //导入方法依赖的package包/类
public static void registerIntentions(HighlightInfo highlightInfo, PsiVariable variable, PsiReferenceParameterList parameterList) {
  PsiType type = variable.getType();
  if (!(type instanceof PsiClassType)) return;

  if (DumbService.getInstance(variable.getProject()).isDumb()) return;

  String shortName = ((PsiClassType)type).getClassName();
  PsiManager manager = parameterList.getManager();
  final JavaPsiFacade facade = JavaPsiFacade.getInstance(manager.getProject());
  PsiShortNamesCache shortNamesCache = PsiShortNamesCache.getInstance(parameterList.getProject());
  PsiClass[] classes = shortNamesCache.getClassesByName(shortName, GlobalSearchScope.allScope(manager.getProject()));
  PsiElementFactory factory = facade.getElementFactory();
  JavaSdkVersion version = JavaSdkVersionUtil.getJavaSdkVersion(parameterList);
  for (PsiClass aClass : classes) {
    if (GenericsHighlightUtil.checkReferenceTypeArgumentList(aClass, parameterList, PsiSubstitutor.EMPTY, false, version) == null) {
      PsiType[] actualTypeParameters = parameterList.getTypeArguments();
      PsiTypeParameter[] classTypeParameters = aClass.getTypeParameters();
      HashMap<PsiTypeParameter, PsiType> map = new HashMap<PsiTypeParameter, PsiType>();
      for (int j = 0; j < classTypeParameters.length; j++) {
        PsiTypeParameter classTypeParameter = classTypeParameters[j];
        PsiType actualTypeParameter = actualTypeParameters[j];
        map.put(classTypeParameter, actualTypeParameter);
      }
      PsiSubstitutor substitutor = factory.createSubstitutor(map);
      PsiType suggestedType = factory.createType(aClass, substitutor);
      HighlightUtil.registerChangeVariableTypeFixes(variable, suggestedType, highlightInfo);
    }
  }
}
 

import com.intellij.psi.search.PsiShortNamesCache; //导入方法依赖的package包/类
@NotNull
public Collection<PsiElement> findClassesForTest(@NotNull PsiElement element) {
  PsiClass klass = findSourceElement(element);
  if (klass == null) return Collections.emptySet();

  GlobalSearchScope scope;
  Module module = getModule(element);
  if (module != null) {
    scope = GlobalSearchScope.moduleWithDependenciesScope(module);
  }
  else {
    scope = GlobalSearchScope.projectScope(element.getProject());
  }

  PsiShortNamesCache cache = PsiShortNamesCache.getInstance(element.getProject());

  List<Pair<? extends PsiNamedElement, Integer>> classesWithWeights = new ArrayList<Pair<? extends PsiNamedElement, Integer>>();
  for (Pair<String, Integer> eachNameWithWeight : TestFinderHelper.collectPossibleClassNamesWithWeights(klass.getName())) {
    for (PsiClass eachClass : cache.getClassesByName(eachNameWithWeight.first, scope)) {
      if (isTestSubjectClass(eachClass)) {
        classesWithWeights.add(new Pair<PsiClass, Integer>(eachClass, eachNameWithWeight.second));
      }
    }
  }

  return TestFinderHelper.getSortedElements(classesWithWeights, false);
}
 

import com.intellij.psi.search.PsiShortNamesCache; //导入方法依赖的package包/类
@NotNull
public Collection<PsiElement> findTestsForClass(@NotNull PsiElement element) {
  PsiClass klass = findSourceElement(element);
  if (klass == null) return Collections.emptySet();

  GlobalSearchScope scope;
  Module module = getModule(element);
  if (module != null) {
    scope = GlobalSearchScope.moduleWithDependentsScope(module);
  }
  else {
    scope = GlobalSearchScope.projectScope(element.getProject());
  }

  PsiShortNamesCache cache = PsiShortNamesCache.getInstance(element.getProject());

  String klassName = klass.getName();
  Pattern pattern = Pattern.compile(".*" + klassName + ".*");

  List<Pair<? extends PsiNamedElement, Integer>> classesWithProximities = new ArrayList<Pair<? extends PsiNamedElement, Integer>>();

  HashSet<String> names = new HashSet<String>();
  cache.getAllClassNames(names);
  for (String eachName : names) {
    if (pattern.matcher(eachName).matches()) {
      for (PsiClass eachClass : cache.getClassesByName(eachName, scope)) {
        if (TestFrameworks.getInstance().isTestClass(eachClass)) {
          classesWithProximities.add(
              new Pair<PsiClass, Integer>(eachClass, TestFinderHelper.calcTestNameProximity(klassName, eachName)));
        }
      }
    }
  }

  return TestFinderHelper.getSortedElements(classesWithProximities, true);
}
 

import com.intellij.psi.search.PsiShortNamesCache; //导入方法依赖的package包/类
@Override
@NotNull
public NavigationItem[] getItemsByName(String name, final String pattern, Project project, boolean includeNonProjectItems)
{
	GlobalSearchScope scope = includeNonProjectItems ? GlobalSearchScope.allScope(project) : GlobalSearchScope.projectScope(project);
	PsiShortNamesCache cache = PsiShortNamesCache.getInstance(project);

	List<PsiMember> result = new ArrayList<PsiMember>();
	for(PsiMethod method : cache.getMethodsByName(name, scope))
	{
		if(!method.isConstructor() && isOpenable(method) && !hasSuperMethod(method))
		{
			result.add(method);
		}
	}
	for(PsiField field : cache.getFieldsByName(name, scope))
	{
		if(isOpenable(field))
		{
			result.add(field);
		}
	}
	for(PsiClass aClass : cache.getClassesByName(name, scope))
	{
		if(isOpenable(aClass))
		{
			result.add(aClass);
		}
	}
	PsiMember[] array = result.toArray(new PsiMember[result.size()]);
	Arrays.sort(array, MyComparator.INSTANCE);
	return array;
}