Java JavaPsiFacade.findClass方法代码示例

import com.intellij.psi.JavaPsiFacade; //导入方法依赖的package包/类
@Override
protected MultiMap<PsiFile, T> computeChildren(@Nullable PsiFile psiFile) {
    MultiMap<PsiFile, T> children = new MultiMap<>();
    Project project = getProject();
    if (project != null) {
        JavaPsiFacade javaPsiFacade = JavaPsiFacade.getInstance(project);
        PsiClass serviceAnnotation = javaPsiFacade.findClass(getAnnotationQName(), GlobalSearchScope.allScope(project));
        if (serviceAnnotation != null) {
            AnnotatedElementsSearch.searchPsiClasses(serviceAnnotation, GlobalSearchScope.allScope(project)).forEach(psiClass -> {
                if (psiClass.isInterface() && isSatisfying(psiClass)) {
                    children.putValue(psiClass.getContainingFile(), createChild(psiClass));
                }
                return true;
            });
        }
    }
    return children;
}
 

import com.intellij.psi.JavaPsiFacade; //导入方法依赖的package包/类
@Override
protected MultiMap<PsiFile, ClassNode> computeChildren(@Nullable PsiFile psiFile) {
    MultiMap<PsiFile, ClassNode> children = new MultiMap<>();
    children.putValue(aggregateRoot.getContainingFile(), new AggregateRootNode(this, aggregateRoot));
    Project project = getProject();
    if (project != null) {
        JavaPsiFacade javaPsiFacade = JavaPsiFacade.getInstance(project);
        PsiClass entityInterface = javaPsiFacade.findClass(ENTITY_INTERFACE, GlobalSearchScope.allScope(project));
        PsiClass valueObjectInterface = javaPsiFacade.findClass(VO_INTERFACE, GlobalSearchScope.allScope(project));
        if (entityInterface != null && valueObjectInterface != null) {
            for (PsiClass psiClass : psiPackage.getClasses(GlobalSearchScope.allScope(project))) {
                if (psiClass.isInheritor(entityInterface, true) && !psiClass.equals(aggregateRoot)) {
                    children.putValue(psiClass.getContainingFile(), new EntityNode(this, psiClass));
                } else if (psiClass.isInheritor(valueObjectInterface, true)) {
                    children.putValue(psiClass.getContainingFile(), new ValueObjectNode(this, psiClass));
                }
            }
        }
    }
    return children;
}
 

import com.intellij.psi.JavaPsiFacade; //导入方法依赖的package包/类
@Override
protected MultiMap computeChildren(@Nullable PsiFile psiFile) {
    MultiMap<PsiFile, AggregateNode> children = new MultiMap<>();
    Project project = getProject();
    if (project != null) {
        JavaPsiFacade javaPsiFacade = JavaPsiFacade.getInstance(project);
        PsiClass psiClass = javaPsiFacade.findClass(AGGREGATE_ROOT_INTERFACE, GlobalSearchScope.allScope(project));
        if (psiClass != null) {
            ClassInheritorsSearch.search(psiClass, GlobalSearchScope.allScope(project), true).forEach(candidate -> {
                String qualifiedName = candidate.getQualifiedName();
                if (qualifiedName != null && !qualifiedName.startsWith(BUSINESS_PACKAGE) && !isAbstract(candidate)) {
                    children.putValue(candidate.getContainingFile(), new AggregateNode(this, candidate));
                }
            });
        }

    }
    return children;
}
 

import com.intellij.psi.JavaPsiFacade; //导入方法依赖的package包/类
@Override
public MultiMap<PsiFile, ResourceNode> computeChildren(PsiFile psiFile) {
    Project project = getProject();
    MultiMap<PsiFile, ResourceNode> children = new MultiMap<>();
    if (project != null) {
        JavaPsiFacade javaPsiFacade = JavaPsiFacade.getInstance(project);
        PsiClass pathAnnotation = javaPsiFacade.findClass(PATH_ANNOTATION, GlobalSearchScope.allScope(project));
        if (pathAnnotation != null) {
            AnnotatedElementsSearch.searchPsiClasses(pathAnnotation, GlobalSearchScope.allScope(project)).forEach(psiClass -> {
                if (!psiClass.isInterface() && !NavigatorUtil.isAbstract(psiClass)) {
                    children.putValue(psiClass.getContainingFile(), new ResourceNode(ResourcesNode.this, pathAnnotation, psiClass));
                }
                return true;
            });
        }
    }
    return children;
}
 

import com.intellij.psi.JavaPsiFacade; //导入方法依赖的package包/类
public static boolean isJarAttached(@NotNull Location location,
                                    final String fqn,
                                    final PsiDirectory[] directories) {
  final JavaPsiFacade facade = JavaPsiFacade.getInstance(location.getProject());
  boolean testngJarFound = false;
  final Module locationModule = location.getModule();
  if (locationModule != null) {
    testngJarFound = facade.findClass(fqn, GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(locationModule, true)) != null;
  }
  else {
    for (PsiDirectory directory : directories) {
      final Module module = ModuleUtilCore.findModuleForFile(directory.getVirtualFile(), location.getProject());
      if (module != null) {
        if (facade.findClass(fqn, GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(module, true)) != null) {
          testngJarFound = true;
          break;
        }
      }
    }
  }
  return testngJarFound;
}
 

import com.intellij.psi.JavaPsiFacade; //导入方法依赖的package包/类
@Nullable
public PsiElement resolveImportReference(QualifiedName name, QualifiedNameResolveContext context, boolean withRoots) {
  String fqn = name.toString();
  final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(context.getProject());
  final PsiPackage aPackage = psiFacade.findPackage(fqn);
  if (aPackage != null) {
    return aPackage;
  }

  Module module = context.getModule();
  if (module != null) {
    final PsiClass aClass = psiFacade.findClass(fqn, module.getModuleWithDependenciesAndLibrariesScope(false));
    if (aClass != null) return aClass;
  }
  return null;
}
 

import com.intellij.psi.JavaPsiFacade; //导入方法依赖的package包/类
@Override
public int getContentType() {
  if (myDeclarationClass != null) {
    final GlobalSearchScope scope = myDeclarationClass.getResolveScope();
    final JavaPsiFacade facade = JavaPsiFacade.getInstance(myDeclarationClass.getProject());
    final PsiClass view = facade.findClass(SdkConstants.CLASS_VIEW, scope);

    if (view != null && myDeclarationClass.isInheritor(view, true)) {
      final PsiClass viewGroup = facade.findClass(SdkConstants.CLASS_VIEWGROUP, scope);

      if (viewGroup != null) {
        return myDeclarationClass.isInheritor(viewGroup, true) ? CONTENT_TYPE_MIXED : CONTENT_TYPE_EMPTY;
      }
    }
  }
  return myParentDescriptor.getContentType();
}
 

import com.intellij.psi.JavaPsiFacade; //导入方法依赖的package包/类
@Nullable
private static PsiClass getActivityClass(Location location, ConfigurationContext context) {
  final Module module = context.getModule();
  if (module == null) return null;
  location = JavaExecutionUtil.stepIntoSingleClass(location);
  if (location == null) {
    return null;
  }
  PsiElement element = location.getPsiElement();
  JavaPsiFacade facade = JavaPsiFacade.getInstance(element.getProject());
  GlobalSearchScope scope = module.getModuleWithDependenciesAndLibrariesScope(true);
  PsiClass activityClass = facade.findClass(AndroidUtils.ACTIVITY_BASE_CLASS_NAME, scope);
  if (activityClass == null) return null;

  PsiClass elementClass = PsiTreeUtil.getParentOfType(element, PsiClass.class, false);
  while (elementClass != null) {
    if (elementClass.isInheritor(activityClass, true)) {
      return elementClass;
    }
    elementClass = PsiTreeUtil.getParentOfType(elementClass, PsiClass.class);
  }
  return null;
}
 

import com.intellij.psi.JavaPsiFacade; //导入方法依赖的package包/类
@Override
protected String showDialog() {
  Project project = getProject();
  final JavaPsiFacade facade = JavaPsiFacade.getInstance(project);
  Module module = myModuleSelector.getModule();
  if (module == null) {
    Messages.showErrorDialog(project, ExecutionBundle.message("module.not.specified.error.text"), CommonBundle.getErrorTitle());
    return null;
  }
  GlobalSearchScope scope =
    myIncludeLibraryClasses ? module.getModuleWithDependenciesAndLibrariesScope(true) : module.getModuleWithDependenciesScope();
  PsiClass initialSelection = facade.findClass(getText(), scope);
  TreeClassChooser chooser = createTreeClassChooser(project, scope, initialSelection, new ClassFilter() {
    @Override
    public boolean isAccepted(PsiClass aClass) {
      if (aClass.isInterface()) return false;
      final PsiModifierList modifierList = aClass.getModifierList();
      return modifierList == null || !modifierList.hasModifierProperty(PsiModifier.ABSTRACT);
    }
  });
  if (chooser == null) return null;
  chooser.showDialog();
  PsiClass selClass = chooser.getSelected();
  return selClass != null ? selClass.getQualifiedName() : null;
}
 

import com.intellij.psi.JavaPsiFacade; //导入方法依赖的package包/类
public void testFindingInternalResourceClasses() throws Exception {
  configureMockSdk();
  final JavaPsiFacade facade = JavaPsiFacade.getInstance(getProject());
  PsiClass activity = facade.findClass("android.app.Activity", GlobalSearchScope.allScope(getProject()));
  assertNotNull(activity);

  GlobalSearchScope scope = activity.getNavigationElement().getResolveScope();
  assertInstanceOf(scope, AndroidSdkResolveScopeProvider.MyJdkScope.class);

  assertNotNull(facade.findClass(AndroidPsiElementFinder.INTERNAL_R_CLASS_QNAME, scope));
  assertNotNull(facade.findClass(AndroidPsiElementFinder.INTERNAL_R_CLASS_QNAME + ".string", scope));

  PsiClass[] classes = facade.findClasses(AndroidPsiElementFinder.INTERNAL_R_CLASS_QNAME, scope);
  assertEquals(1, classes.length);
  classes = facade.findClasses(AndroidPsiElementFinder.INTERNAL_R_CLASS_QNAME + ".string", scope);
  assertEquals(1, classes.length);
}
 

import com.intellij.psi.JavaPsiFacade; //导入方法依赖的package包/类
public static boolean supportSerializationProtocol(TestNGConfiguration config) {
  final Project project = config.getProject();
  final GlobalSearchScope scopeToDetermineTestngIn;
  if (config.getPersistantData().getScope() == TestSearchScope.WHOLE_PROJECT) {
    scopeToDetermineTestngIn = GlobalSearchScope.allScope(project);
  }
  else {
    final Module module = config.getConfigurationModule().getModule();
    scopeToDetermineTestngIn = module != null ? GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(module) 
                                              : GlobalSearchScope.allScope(project);
  }

  final JavaPsiFacade facade = JavaPsiFacade.getInstance(project);
  final PsiClass aClass = facade.findClass(SerializedMessageSender.class.getName(), scopeToDetermineTestngIn);
  if (aClass == null) return false;

  final PsiClass[] starters = facade.findClasses(RemoteTestNG.class.getName(), scopeToDetermineTestngIn);
  for (PsiClass starter : starters) {
    if (starter.findFieldByName("m_serPort", false) == null) {
      LOG.info("Multiple TestNG versions found");
      return false;
    }
  }
  return Registry.is("testng.serialized.protocol.enabled") && !TestNGVersionChecker.isVersionIncompatible(project, scopeToDetermineTestngIn);
}
 

import com.intellij.psi.JavaPsiFacade; //导入方法依赖的package包/类
public SrcClass make( String fqn, ManModule module )
{
   JavaPsiFacade javaPsiFacade = JavaPsiFacade.getInstance( module.getIjProject() );
   PsiClass psiClass = javaPsiFacade.findClass( fqn, GlobalSearchScope.moduleScope( module.getIjModule() ) );
   if( psiClass == null )
   {
     psiClass = javaPsiFacade.findClass( fqn, GlobalSearchScope.allScope( module.getIjProject() ) );
   }
  return makeSrcClass( fqn, psiClass, module );
}
 

import com.intellij.psi.JavaPsiFacade; //导入方法依赖的package包/类
private static boolean isFqnsOk(Project project, List<String> fqns) {
  if (fqns.isEmpty()) return false;
  final JavaPsiFacade facade = JavaPsiFacade.getInstance(project);
  final GlobalSearchScope scope = GlobalSearchScope.allScope(project);
  for (String fqn : fqns) {
    if (facade.findClass(fqn, scope) != null) return false;
  }
  return true;
}
 

import com.intellij.psi.JavaPsiFacade; //导入方法依赖的package包/类
PerformAction createAction(final String className, final IntroduceVariableBase testMe) {
  return (vroot, rootAfter) -> {
    final JavaPsiFacade psiManager = getJavaFacade();
    final PsiClass aClass = psiManager.findClass(className, GlobalSearchScope.allScope(myProject));
    assertTrue(className + " class not found", aClass != null);
    final PsiFile containingFile = aClass.getContainingFile();
    final VirtualFile virtualFile = containingFile.getVirtualFile();
    assertTrue(virtualFile != null);
    final Editor editor = createEditor(virtualFile);
    setupCursorAndSelection(editor);
    testMe.invoke(myProject, editor, containingFile, null);
    FileDocumentManager.getInstance().saveAllDocuments();
  };
}
 

import com.intellij.psi.JavaPsiFacade; //导入方法依赖的package包/类
@Override
public Converter getConverter(@NotNull GenericDomValue domElement) {
  Project project = domElement.getManager().getProject();

  JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project);
  PsiClass psiClass = psiFacade.findClass(myType, GlobalSearchScope.allScope(project));
  if (psiClass != null) {
    GenericDomValueConvertersRegistry convertersRegistry = MavenDomConvertersRegistry.getInstance().getConvertersRegistry();
    return convertersRegistry.getConverter(domElement, psiFacade.getElementFactory().createType(psiClass));
  }

  return null;
}