private PsiClass getPsiClassByName(Project project, String cls) { GlobalSearchScope searchScope = GlobalSearchScope.allScope(project); JavaPsiFacade javaPsiFacade = JavaPsiFacade.getInstance(project); return javaPsiFacade.findClass(cls, searchScope); }
public static boolean isClassAvailableForProject(Project project, String className) { PsiClass classInModule = JavaPsiFacade.getInstance(project).findClass(className, new EverythingGlobalScope(project)); return classInModule != null; }
@NotNull public static Optional<PsiClass> findClazz(@NotNull Project project, @NotNull String clazzName) { return Optional.fromNullable(JavaPsiFacade.getInstance(project).findClass(clazzName, GlobalSearchScope.allScope(project))); }
private PsiClass findClassSafe(String className) { if (className == null) return null; try { return myFacade.findClass(className, GlobalSearchScope.allScope(myFacade.getProject())); } catch (IndexNotReadyException e) { return null; } }
@NotNull public Optional<PsiClass> toPsiClass(@NotNull Project project) { return Optional.fromNullable(JavaPsiFacade.getInstance(project).findClass(getQualifiedName(), GlobalSearchScope.allScope(project))); }
public static PsiClass createPsiClass(String qualifiedName, Project project) { final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project); final GlobalSearchScope searchScope = GlobalSearchScope.allScope(project); return psiFacade.findClass(qualifiedName, searchScope); }
@NotNull public Optional<PsiClass> findPsiClass(@Nullable PsiElement element, @NotNull String shortName) { PsiClass clazz = javaPsiFacade.findClass(shortName, GlobalSearchScope.allScope(project)); if (null != clazz) { return Optional.of(clazz); } for (AliasResolver resolver : resolvers) { for (AliasDesc desc : resolver.getClassAliasDescriptions(element)) { if (desc.getAlias().equals(shortName)) { return Optional.of(desc.getClazz()); } } } return Optional.absent(); }
public static PsiClass createPsiClass(String qualifiedName, Project project) { final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project); final GlobalSearchScope searchScope = GlobalSearchScope.allScope(project); return psiFacade.findClass(qualifiedName, searchScope); }
private static PsiClass find(String fqClassname, Project project) { return JavaPsiFacade.getInstance(project).findClass(fqClassname, GlobalSearchScope.allScope(project)); }
public static boolean isAnnotatingApplicable(@NotNull PsiElement elt, @NotNull String annotationFQN) { final Project project = elt.getProject(); return PsiUtil.isLanguageLevel5OrHigher(elt) && JavaPsiFacade.getInstance(project).findClass(annotationFQN, elt.getResolveScope()) != null; }
public static void addException(@NotNull PsiMethod method, @NotNull @NonNls String exceptionFQName) throws IncorrectOperationException { PsiClass exceptionClass = JavaPsiFacade.getInstance(method.getProject()).findClass(exceptionFQName, method.getResolveScope()); addException(method, exceptionClass, exceptionFQName); }
@Contract("null, _, _ -> false") public static boolean isInheritor(@Nullable PsiClass psiClass, final boolean strict, @NotNull final String baseClassName) { if (psiClass == null) { return false; } final PsiClass base = JavaPsiFacade.getInstance(psiClass.getProject()).findClass(baseClassName, psiClass.getResolveScope()); if (base == null) { return false; } return strict ? psiClass.isInheritor(base, true) : isInheritorOrSelf(psiClass, base, true); }
@Nullable private VirtualFile fileForClass() { PsiClass clazz = JavaPsiFacade.getInstance(project).findClass(className, projectScope(project)); if ((clazz != null) && (clazz.getContainingFile() != null)) { return clazz.getContainingFile().getVirtualFile(); } return null; } }
public static ImpexProcessorModifierValue[] values() { final Project project = currentProject(); final PsiClass clazz; if (project != null) { clazz = JavaPsiFacade.getInstance(project) .findClass( "de.hybris.platform.impex.jalo.imp.ImportProcessor", allScope(project) ); if (clazz != null) { final Query<PsiClass> psiClasses = ClassInheritorsSearch.search(clazz, allScope(project), true); return psiClasses.findAll() .stream() .map(ImpexProcessorModifierValue::new) .toArray(ImpexProcessorModifierValue[]::new); } } return new ImpexProcessorModifierValue[]{}; }
@Nullable public PsiClassType getBoxedType(final PsiManager manager, final GlobalSearchScope resolveScope) { final String boxedQName = getBoxedTypeName(); //[ven]previous call returns null for NULL, VOID if (boxedQName == null) return null; final PsiClass aClass = JavaPsiFacade.getInstance(manager.getProject()).findClass(boxedQName, resolveScope); if (aClass == null) return null; return JavaPsiFacade.getInstance(manager.getProject()).getElementFactory().createType(aClass); }
@Nullable public static PsiMethod getResourceCloserMethodForType(@NotNull final PsiClassType resourceType) { final PsiClass resourceClass = resourceType.resolve(); if (resourceClass == null) return null; final Project project = resourceClass.getProject(); final JavaPsiFacade facade = JavaPsiFacade.getInstance(project); final PsiClass autoCloseable = facade.findClass(CommonClassNames.JAVA_LANG_AUTO_CLOSEABLE, ProjectScope.getLibrariesScope(project)); if (autoCloseable == null) return null; if (JavaClassSupers.getInstance().getSuperClassSubstitutor(autoCloseable, resourceClass, resourceType.getResolveScope(), PsiSubstitutor.EMPTY) == null) return null; final PsiMethod[] closes = autoCloseable.findMethodsByName("close", false); return closes.length == 1 ? resourceClass.findMethodBySignature(closes[0], true) : null; }
@Nullable public static PsiMethod getAnnotationMethod(@NotNull PsiNameValuePair pair) { final PsiAnnotation annotation = PsiTreeUtil.getParentOfType(pair.getParent(), PsiAnnotation.class); assert annotation != null; final String fqn = annotation.getQualifiedName(); if (fqn == null) return null; final PsiClass psiClass = JavaPsiFacade.getInstance(pair.getProject()).findClass(fqn, pair.getResolveScope()); if (psiClass != null && psiClass.isAnnotationType()) { final String name = pair.getName(); return ArrayUtil.getFirstElement(psiClass.findMethodsByName(name != null ? name : "value", false)); } return null; }
@Nullable public static PsiType createJavaLangClassType(@NotNull PsiElement context, @Nullable PsiType qualifierType, boolean captureTopLevelWildcards) { if (qualifierType != null) { PsiUtil.ensureValidType(qualifierType); JavaPsiFacade facade = JavaPsiFacade.getInstance(context.getProject()); PsiClass javaLangClass = facade.findClass(CommonClassNames.JAVA_LANG_CLASS, context.getResolveScope()); if (javaLangClass != null && javaLangClass.getTypeParameters().length == 1) { PsiSubstitutor substitutor = PsiSubstitutor.EMPTY. put(javaLangClass.getTypeParameters()[0], PsiWildcardType.createExtends(context.getManager(), qualifierType)); final PsiClassType classType = facade.getElementFactory().createType(javaLangClass, substitutor, PsiUtil.getLanguageLevel(context)); return captureTopLevelWildcards ? PsiUtil.captureToplevelWildcards(classType, context) : classType; } } return null; }
/** * Checks if MapStruct is withing the provided module. * * @param module that needs to be checked * * @return {@code true} if MapStruct is present within the {@code module}, {@code false} otherwise */ private static boolean isMapStructPresent(@NotNull Module module) { return CachedValuesManager.getManager( module.getProject() ).getCachedValue( module, () -> { boolean foundMarkerClass = JavaPsiFacade.getInstance( module.getProject() ) .findClass( MAPPER_ANNOTATION_FQN, module.getModuleRuntimeScope( false ) ) != null; return CachedValueProvider.Result.createSingleDependency( foundMarkerClass, ProjectRootManager.getInstance( module.getProject() ) ); } ); }
@Override public Result<Set<String>> compute() { final JavaPsiFacade facade = JavaPsiFacade.getInstance(project); final Set<String> set = new THashSet<String>(); for (final String qname : PsiPrimitiveType.getAllBoxedTypeNames()) { final PsiClass boxedClass = facade.findClass(qname, GlobalSearchScope.allScope(project)); InheritanceUtil.processSupers(boxedClass, true, new Processor<PsiClass>() { @Override public boolean process(PsiClass psiClass) { ContainerUtil.addIfNotNull(psiClass.getQualifiedName(), set); return true; } }); } return Result.create(set, ProjectRootModificationTracker.getInstance(project)); } }, false));