Java PsiShortNamesCache.getFieldsByName方法代码示例

import com.intellij.psi.search.PsiShortNamesCache; //导入方法依赖的package包/类
@NotNull
@Override
public ResolveResult[] multiResolve(final boolean incompleteCode) {
    Project project = myElement.getProject();
    final String enumLiteralJavaModelName = myElement.getText().replaceAll("\"", "").toUpperCase();

    final PsiShortNamesCache psiShortNamesCache = PsiShortNamesCache.getInstance(project);
    final PsiField[] javaEnumLiteralFields = psiShortNamesCache.getFieldsByName(
        enumLiteralJavaModelName, GlobalSearchScope.allScope(project)
    );

    final Set<PsiField> enumFields = stream(javaEnumLiteralFields)
        .filter(literal -> literal.getParent() != null)
        .filter(literal -> literal.getParent() instanceof ClsClassImpl)
        .filter(literal -> ((ClsClassImpl) literal.getParent()).isEnum())
        .collect(Collectors.toSet());

    return PsiElementResolveResult.createResults(enumFields);
}
 

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 PsiField[] getFieldsByName(@NotNull String name, @NotNull GlobalSearchScope scope)
{
	Merger<PsiField> merger = null;
	for(PsiShortNamesCache cache : myCaches)
	{
		PsiField[] classes = cache.getFieldsByName(name, scope);
		if(classes.length != 0)
		{
			if(merger == null)
			{
				merger = new Merger<PsiField>();
			}
			merger.add(classes);
		}
	}
	PsiField[] result = merger == null ? null : merger.getResult();
	return result == null ? PsiField.EMPTY_ARRAY : result;
}
 

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

import com.intellij.psi.search.PsiShortNamesCache; //导入方法依赖的package包/类
@Override
@NotNull
public PsiField[] findDeclaredFields(@NotNull final PsiManager manager, @NotNull String name) {
  final PsiShortNamesCache cache = PsiShortNamesCache.getInstance(manager.getProject());
  GlobalSearchScope scope = GlobalSearchScope.allScope(manager.getProject());
  return cache.getFieldsByName(name, scope);
}
 

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包/类
@Override
@NotNull
public PsiField[] findDeclaredFields(@NotNull final PsiManager manager, @NotNull String name)
{
	final PsiShortNamesCache cache = PsiShortNamesCache.getInstance(manager.getProject());
	GlobalSearchScope scope = GlobalSearchScope.allScope(manager.getProject());
	return cache.getFieldsByName(name, scope);
}
 

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包/类
public static ExpectedTypeInfo[] guessExpectedTypes (PsiExpression expression, boolean allowVoidType) {
      PsiManager manager = expression.getManager();
  GlobalSearchScope resolveScope = expression.getResolveScope();

  List<ExpectedTypeInfo[]> typesList = new ArrayList<ExpectedTypeInfo[]>();
  List<String> expectedMethodNames = new ArrayList<String>();
  List<String> expectedFieldNames  = new ArrayList<String>();

  getExpectedInformation(expression, typesList, expectedMethodNames, expectedFieldNames);


  if (typesList.size() == 1 && (!expectedFieldNames.isEmpty() || !expectedMethodNames.isEmpty())) {
    ExpectedTypeInfo[] infos = typesList.get(0);
    if (infos.length == 1 && infos[0].getKind() == ExpectedTypeInfo.TYPE_OR_SUBTYPE &&
        infos[0].getType().equals(PsiType.getJavaLangObject(manager, resolveScope))) {
      typesList.clear();
    }
  }

  if (typesList.isEmpty()) {
    final JavaPsiFacade facade = JavaPsiFacade.getInstance(expression.getProject());
    final PsiShortNamesCache cache = PsiShortNamesCache.getInstance(expression.getProject());
    PsiElementFactory factory = facade.getElementFactory();
    for (String fieldName : expectedFieldNames) {
      PsiField[] fields = cache.getFieldsByName(fieldName, resolveScope);
      addMemberInfo(fields, expression, typesList, factory);
    }

    for (String methodName : expectedMethodNames) {
      PsiMethod[] methods = cache.getMethodsByName(methodName, resolveScope);
      addMemberInfo(methods, expression, typesList, factory);
    }
  }

  ExpectedTypeInfo[] expectedTypes = ExpectedTypeUtil.intersect(typesList);
  if (expectedTypes.length == 0 && !typesList.isEmpty()) {
    List<ExpectedTypeInfo> union = new ArrayList<ExpectedTypeInfo>();
    for (ExpectedTypeInfo[] aTypesList : typesList) {
      ContainerUtil.addAll(union, (ExpectedTypeInfo[])aTypesList);
    }
    expectedTypes = union.toArray(new ExpectedTypeInfo[union.size()]);
  }

  if (expectedTypes.length == 0) {
    PsiType t = allowVoidType ? PsiType.VOID : PsiType.getJavaLangObject(manager, resolveScope);
    expectedTypes = new ExpectedTypeInfo[] {ExpectedTypesProvider.createInfo(t, ExpectedTypeInfo.TYPE_OR_SUBTYPE, t, TailType.NONE)};
  }

  return expectedTypes;
}