public void testLocation() {
assertNull(mySuite.getLocation(getProject(), GlobalSearchScope.allScope(getProject())));
mySuite.addChild(mySimpleTest);
assertNull(mySuite.getLocation(getProject(), GlobalSearchScope.allScope(getProject())));
assertNull(mySimpleTest.getLocation(getProject(), GlobalSearchScope.allScope(getProject())));
}
public void testExternalFileModificationWhileProjectClosed() throws Exception {
VirtualFile root = ProjectRootManager.getInstance(myProject).getContentRoots()[0];
PsiClass objectClass =
myJavaFacade.findClass(
CommonClassNames.JAVA_LANG_OBJECT, GlobalSearchScope.allScope(getProject()));
assertNotNull(objectClass);
checkUsages(objectClass, new String[] {});
FileBasedIndex.getInstance()
.getContainingFiles(
TodoIndex.NAME,
new TodoIndexEntry("todo", true),
GlobalSearchScope.allScope(getProject()));
final String projectLocation = myProject.getPresentableUrl();
assert projectLocation != null : myProject;
PlatformTestUtil.saveProject(myProject);
final VirtualFile content = ModuleRootManager.getInstance(getModule()).getContentRoots()[0];
Project project = myProject;
ProjectUtil.closeAndDispose(project);
InjectedLanguageManagerImpl.checkInjectorsAreDisposed(project);
assertTrue("Project was not disposed", myProject.isDisposed());
myModule = null;
final File file = new File(root.getPath(), "1.java");
assertTrue(file.exists());
FileUtil.writeToFile(file, "class A{ Object o;}".getBytes(CharsetToolkit.UTF8_CHARSET));
root.refresh(false, true);
LocalFileSystem.getInstance().refresh(false);
myProject = ProjectManager.getInstance().loadAndOpenProject(projectLocation);
InjectedLanguageManagerImpl.pushInjectors(getProject());
setUpModule();
setUpJdk();
ProjectManagerEx.getInstanceEx().openTestProject(myProject);
UIUtil.dispatchAllInvocationEvents(); // startup activities
runStartupActivities();
PsiTestUtil.addSourceContentToRoots(getModule(), content);
assertNotNull(myProject);
myPsiManager = (PsiManagerImpl) PsiManager.getInstance(myProject);
myJavaFacade = JavaPsiFacadeEx.getInstanceEx(myProject);
objectClass =
myJavaFacade.findClass(
CommonClassNames.JAVA_LANG_OBJECT, GlobalSearchScope.allScope(getProject()));
assertNotNull(objectClass);
checkUsages(objectClass, new String[] {"1.java"});
}
private static String compoundLambdaOrMethodReference(
PsiParameter parameter,
PsiExpression expression,
String samQualifiedName,
PsiType[] samParamTypes) {
String result = "";
final Project project = parameter.getProject();
final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project);
final PsiClass functionClass =
psiFacade.findClass(samQualifiedName, GlobalSearchScope.allScope(project));
for (int i = 0; i < samParamTypes.length; i++) {
if (samParamTypes[i] instanceof PsiPrimitiveType) {
samParamTypes[i] = ((PsiPrimitiveType) samParamTypes[i]).getBoxedType(expression);
}
}
final PsiClassType functionalInterfaceType =
functionClass != null
? psiFacade.getElementFactory().createType(functionClass, samParamTypes)
: null;
final PsiParameter[] parameters = {parameter};
final String methodReferenceText =
LambdaCanBeMethodReferenceInspection.convertToMethodReference(
expression, parameters, functionalInterfaceType, null);
if (methodReferenceText != null) {
LOG.assertTrue(functionalInterfaceType != null);
result += "(" + functionalInterfaceType.getCanonicalText() + ")" + methodReferenceText;
} else {
result += parameter.getName() + " -> " + expression.getText();
}
return result;
}
public void testLibraryClassUsageFromDecompiledSource() {
PsiElement decompiled =
((PsiCompiledElement)
myJavaFacade.findClass("javax.swing.JLabel", GlobalSearchScope.allScope(myProject)))
.getMirror();
assertEquals(2, ReferencesSearch.search(decompiled).findAll().size());
}
public void testRemoveSourceRoot() {
final VirtualFile root = ModuleRootManager.getInstance(myModule).getContentRoots()[0];
PsiTodoSearchHelper.SERVICE
.getInstance(myProject)
.findFilesWithTodoItems(); // to initialize caches
new WriteCommandAction.Simple(getProject()) {
@Override
protected void run() throws Throwable {
VirtualFile newFile = createChildData(root, "New.java");
setFileText(newFile, "class A{ Exception e;} //todo");
}
}.execute().throwException();
PsiDocumentManager.getInstance(myProject).commitAllDocuments();
PsiTodoSearchHelper.SERVICE.getInstance(myProject).findFilesWithTodoItems(); // to update caches
VirtualFile[] sourceRoots = ModuleRootManager.getInstance(myModule).getSourceRoots();
LOG.assertTrue(sourceRoots.length == 1);
PsiTestUtil.removeSourceRoot(myModule, sourceRoots[0]);
PsiClass exceptionClass =
myJavaFacade.findClass("java.lang.Exception", GlobalSearchScope.allScope(getProject()));
assertNotNull(exceptionClass);
// currently it actually finds usages by FQN due to Java PSI enabled for out-of-source java
// files
// so the following check is disabled
// checkUsages(exceptionClass, new String[]{});
checkTodos(new String[] {"2.java", "New.java"});
}
private void doTest(
@NotNull String fileName, int lineNumber, @NotNull Function1<VirtualFile, String> className) {
if (rootDir == null) {
configure();
}
assert rootDir != null;
Filter filter = new JetExceptionFilterFactory().create(GlobalSearchScope.allScope(myProject));
VirtualFile expectedFile = VfsUtilCore.findRelativeFile(fileName, rootDir);
assertNotNull(expectedFile);
String line = createStackTraceElementLine(fileName, className.invoke(expectedFile), lineNumber);
Filter.Result result = filter.applyFilter(line, 0);
assertNotNull(result);
HyperlinkInfo info = result.getFirstHyperlinkInfo();
assertNotNull(info);
assertInstanceOf(info, OpenFileHyperlinkInfo.class);
OpenFileDescriptor descriptor = ((OpenFileHyperlinkInfo) info).getDescriptor();
assertNotNull(descriptor);
assertEquals(expectedFile, descriptor.getFile());
Document document = FileDocumentManager.getInstance().getDocument(expectedFile);
assertNotNull(document);
int expectedOffset = document.getLineStartOffset(lineNumber - 1);
assertEquals(expectedOffset, descriptor.getOffset());
}
public void merge(final Binding b, final boolean removeObject) {
for (final PsiTypeVariable var : b.getBoundVariables()) {
final int index = var.getIndex();
if (myBindings.get(index) != null) {
LOG.error("Oops... Binding conflict...");
} else {
final PsiType type = b.apply(var);
final PsiClassType javaLangObject =
PsiType.getJavaLangObject(
PsiManager.getInstance(myProject), GlobalSearchScope.allScope(myProject));
if (removeObject && javaLangObject.equals(type)) {
final HashSet<PsiTypeVariable> cluster = myFactory.getClusterOf(var.getIndex());
if (cluster != null) {
for (final PsiTypeVariable war : cluster) {
final PsiType wtype = b.apply(war);
if (!javaLangObject.equals(wtype)) {
myBindings.put(index, type);
break;
}
}
}
} else {
myBindings.put(index, type);
}
}
}
}
public static boolean proveArrayTypeDistinct(Project project, PsiArrayType type, PsiType bound) {
final JavaPsiFacade facade = JavaPsiFacade.getInstance(project);
final GlobalSearchScope searchScope = GlobalSearchScope.allScope(project);
final Set<PsiClass> possibleClasses = new HashSet<PsiClass>();
possibleClasses.add(facade.findClass(CommonClassNames.JAVA_IO_SERIALIZABLE, searchScope));
possibleClasses.add(facade.findClass(CommonClassNames.JAVA_LANG_CLONEABLE, searchScope));
possibleClasses.add(facade.findClass(CommonClassNames.JAVA_LANG_OBJECT, searchScope));
if (type.getArrayDimensions() == bound.getArrayDimensions()) {
final PsiType componentType = type.getComponentType();
final PsiType boundComponentType = ((PsiArrayType) bound).getComponentType();
if (boundComponentType instanceof PsiClassType && componentType instanceof PsiClassType) {
return proveExtendsBoundsDistinct(
boundComponentType,
componentType,
((PsiClassType) boundComponentType).resolve(),
((PsiClassType) componentType).resolve());
} else {
return !bound.equals(type);
}
} else if (bound.getArrayDimensions() + 1 == type.getArrayDimensions()
&& bound.getDeepComponentType() instanceof PsiClassType) {
return !possibleClasses.contains(((PsiClassType) bound.getDeepComponentType()).resolve());
} else if (bound.getArrayDimensions() == type.getArrayDimensions() + 1
&& type.getDeepComponentType() instanceof PsiClassType) {
return !possibleClasses.contains(((PsiClassType) type.getDeepComponentType()).resolve());
} else if (bound instanceof PsiClassType) {
return !possibleClasses.contains(((PsiClassType) bound).resolve());
} else if (bound instanceof PsiWildcardType) {
final PsiType boundBound = ((PsiWildcardType) bound).getBound();
return boundBound != null && !boundBound.equals(type);
}
return true;
}
public void _testCollectedPsiWithChangedDocument() throws IOException {
VirtualFile dir = getVirtualFile(createTempDirectory());
PsiTestUtil.addSourceContentToRoots(myModule, dir);
final VirtualFile vFile = createChildData(dir, "Foo.java");
VfsUtil.saveText(vFile, "class Foo {}");
final GlobalSearchScope scope = GlobalSearchScope.allScope(getProject());
final JavaPsiFacade facade = JavaPsiFacade.getInstance(getProject());
assertNotNull(facade.findClass("Foo", scope));
ApplicationManager.getApplication()
.runWriteAction(
new Runnable() {
@Override
public void run() {
PsiFile psiFile = PsiManager.getInstance(getProject()).findFile(vFile);
assertNotNull(psiFile);
Document document = FileDocumentManager.getInstance().getDocument(vFile);
document.deleteString(0, document.getTextLength());
assertNotNull(facade.findClass("Foo", scope));
psiFile = null;
PlatformTestUtil.tryGcSoftlyReachableObjects();
assertNull(
((PsiManagerEx) PsiManager.getInstance(getProject()))
.getFileManager()
.getCachedPsiFile(vFile));
// should be assertNull(facade.findClass("Foo", scope));
// or the file should not be allowed to be gc'ed
facade.findClass("Foo", scope).getText();
}
});
}
public void testAddSourceRoot() throws Exception {
File dir = createTempDirectory();
final VirtualFile root =
LocalFileSystem.getInstance()
.refreshAndFindFileByPath(dir.getCanonicalPath().replace(File.separatorChar, '/'));
new WriteCommandAction.Simple(getProject()) {
@Override
protected void run() throws Throwable {
PsiTestUtil.addContentRoot(myModule, root);
VirtualFile newFile = createChildData(root, "New.java");
setFileText(newFile, "class A{ Exception e;} //todo");
}
}.execute().throwException();
PsiDocumentManager.getInstance(myProject).commitAllDocuments();
PsiTodoSearchHelper.SERVICE
.getInstance(myProject)
.findFilesWithTodoItems(); // to initialize caches
PsiTestUtil.addSourceRoot(myModule, root);
PsiClass exceptionClass =
myJavaFacade.findClass("java.lang.Exception", GlobalSearchScope.allScope(getProject()));
assertNotNull(exceptionClass);
checkUsages(exceptionClass, new String[] {"1.java", "2.java", "New.java"});
checkTodos(new String[] {"2.java", "New.java"});
}
private PsiClass findClassPreferringMyScope(String className) {
JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(myProject);
PsiClass result = psiFacade.findClass(className, mySearchScope);
return result != null
? result
: psiFacade.findClass(className, GlobalSearchScope.allScope(myProject));
}
private static Collection<FqName> getJetExtensionFunctions(
@NotNull final String referenceName,
@NotNull JetSimpleNameExpression expression,
@NotNull Project project) {
JetShortNamesCache namesCache = JetCacheManager.getInstance(project).getNamesCache();
Collection<DeclarationDescriptor> jetCallableExtensions =
namesCache.getJetCallableExtensions(
new Condition<String>() {
@Override
public boolean value(String callableExtensionName) {
return callableExtensionName.equals(referenceName);
}
},
expression,
GlobalSearchScope.allScope(project));
return Sets.newHashSet(
Collections2.transform(
jetCallableExtensions,
new Function<DeclarationDescriptor, FqName>() {
@Override
public FqName apply(@Nullable DeclarationDescriptor declarationDescriptor) {
assert declarationDescriptor != null;
return DescriptorUtils.getFQName(declarationDescriptor).toSafe();
}
}));
}
public void testCantCreateConfiguration() {
PsiClass objectClass =
JavaPsiFacade.getInstance(myProject)
.findClass(CommonClassNames.JAVA_LANG_OBJECT, GlobalSearchScope.allScope(myProject));
assertNull(createConfiguration(objectClass));
assertNull(createConfiguration(JUnitUtil.getContainingPackage(objectClass)));
}
public void testProtectedMethodInPackageLocalClass() throws Throwable {
PsiMethod method =
myJavaFacade.findClass("foo.PackageLocal", GlobalSearchScope.allScope(myProject))
.getMethods()[0];
assertEquals(1, OverridingMethodsSearch.search(method).findAll().size());
assertEquals(1, ReferencesSearch.search(method).findAll().size());
}
private void findUsagesForStaticMethod(PsiMethod method, List<FixableUsageInfo> usages) {
final PsiManager psiManager = method.getManager();
final Project project = psiManager.getProject();
final GlobalSearchScope scope = GlobalSearchScope.allScope(project);
final Iterable<PsiReference> calls = ReferencesSearch.search(method, scope);
final String fullyQualifiedName = getQualifiedName();
for (PsiReference reference : calls) {
final PsiElement referenceElement = reference.getElement();
final PsiElement parent = referenceElement.getParent();
if (parent instanceof PsiMethodCallExpression) {
final PsiMethodCallExpression call = (PsiMethodCallExpression) parent;
if (!isInMovedElement(call)) {
usages.add(new RetargetStaticMethodCall(call, fullyQualifiedName));
}
} else if (parent instanceof PsiImportStaticStatement) {
final PsiJavaCodeReferenceElement importReference =
((PsiImportStaticStatement) parent).getImportReference();
if (importReference != null) {
final PsiElement qualifier = importReference.getQualifier();
if (qualifier instanceof PsiJavaCodeReferenceElement) {
usages.add(
new ReplaceClassReference(
(PsiJavaCodeReferenceElement) qualifier, fullyQualifiedName));
}
}
}
}
usages.add(new RemoveMethod(method));
}
private void findUsagesForMethod(PsiMethod method, List<FixableUsageInfo> usages) {
final PsiManager psiManager = method.getManager();
final Project project = psiManager.getProject();
final GlobalSearchScope scope = GlobalSearchScope.allScope(project);
final Iterable<PsiReference> calls = ReferencesSearch.search(method, scope);
for (PsiReference reference : calls) {
final PsiElement referenceElement = reference.getElement();
final PsiElement parent = referenceElement.getParent();
if (parent instanceof PsiMethodCallExpression) {
final PsiMethodCallExpression call = (PsiMethodCallExpression) parent;
if (isInMovedElement(call)) {
continue;
}
final PsiReferenceExpression methodExpression = call.getMethodExpression();
final PsiExpression qualifier = methodExpression.getQualifierExpression();
if (qualifier == null || qualifier instanceof PsiThisExpression) {
usages.add(new ReplaceThisCallWithDelegateCall(call, delegateFieldName));
}
delegationRequired = true;
}
}
if (!delegationRequired && MethodInheritanceUtils.hasSiblingMethods(method)) {
delegationRequired = true;
}
if (delegationRequired) {
usages.add(new MakeMethodDelegate(method, delegateFieldName));
} else {
usages.add(new RemoveMethod(method));
}
}
private void findUsagesForInnerClass(PsiClass innerClass, List<FixableUsageInfo> usages) {
final PsiManager psiManager = innerClass.getManager();
final Project project = psiManager.getProject();
final GlobalSearchScope scope = GlobalSearchScope.allScope(project);
final Iterable<PsiReference> calls = ReferencesSearch.search(innerClass, scope);
final String innerName = innerClass.getQualifiedName();
assert innerName != null;
final String sourceClassQualifiedName = sourceClass.getQualifiedName();
assert sourceClassQualifiedName != null;
final String newInnerClassName =
getQualifiedName() + innerName.substring(sourceClassQualifiedName.length());
boolean hasExternalReference = false;
for (PsiReference reference : calls) {
final PsiElement referenceElement = reference.getElement();
if (referenceElement instanceof PsiJavaCodeReferenceElement) {
if (!isInMovedElement(referenceElement)) {
usages.add(
new ReplaceClassReference(
(PsiJavaCodeReferenceElement) referenceElement, newInnerClassName));
hasExternalReference = true;
}
}
}
if (hasExternalReference) {
innerClassesToMakePublic.add(innerClass);
}
}
@Override
public boolean canHandle(RunConfiguration configuration, Project project) {
if (!(configuration instanceof JUnitConfiguration)) {
return false;
} else {
JUnitConfiguration.Data data = ((JUnitConfiguration) configuration).getPersistentData();
String mainClassName = data.getMainClassName();
String methodName = data.getMethodName();
JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project);
PsiClass referencedClass =
psiFacade.findClass(mainClassName, GlobalSearchScope.allScope(project));
PsiFile containingFile = referencedClass.getContainingFile();
FileEditorManager fileEditorManager = FileEditorManager.getInstance(project);
if (methodName == null) {
fileEditorManager.openFile(containingFile.getVirtualFile(), true);
} else {
PsiMethod[] methodsByName = referencedClass.findMethodsByName(methodName, false);
fileEditorManager.openEditor(
new OpenFileDescriptor(
project, containingFile.getVirtualFile(), methodsByName[0].getTextOffset()),
true);
}
return true;
}
}
public static boolean inheritsITestListener(@NotNull PsiClass psiClass) {
final Project project = psiClass.getProject();
final PsiClass aListenerClass =
JavaPsiFacade.getInstance(project)
.findClass(ITestNGListener.class.getName(), GlobalSearchScope.allScope(project));
return aListenerClass != null && psiClass.isInheritor(aListenerClass, true);
}
public void testSCR6066() throws Exception {
ProjectRootManagerEx rootManager =
(ProjectRootManagerEx) ProjectRootManager.getInstance(myProject);
final VirtualFile root = rootManager.getContentRoots()[0];
PsiTodoSearchHelper.SERVICE
.getInstance(myProject)
.findFilesWithTodoItems(); // to initialize caches
new WriteCommandAction.Simple(getProject()) {
@Override
protected void run() throws Throwable {
VirtualFile newFile = createChildData(root, "New.java");
setFileText(newFile, "class A{ Exception e;} //todo");
}
}.execute().throwException();
PsiDocumentManager.getInstance(myProject).commitAllDocuments();
PsiTodoSearchHelper.SERVICE.getInstance(myProject).findFilesWithTodoItems(); // to update caches
PsiTestUtil.addExcludedRoot(myModule, root);
PsiClass exceptionClass =
myJavaFacade.findClass("java.lang.Exception", GlobalSearchScope.allScope(getProject()));
assertNotNull(exceptionClass);
checkUsages(exceptionClass, new String[] {});
checkTodos(new String[] {});
}
public void updateThrowsList(PsiClassType exceptionType) {
if (!getSuperMethods().isEmpty()) {
for (RefMethod refSuper : getSuperMethods()) {
((RefMethodImpl) refSuper).updateThrowsList(exceptionType);
}
} else if (myUnThrownExceptions != null) {
if (exceptionType == null) {
myUnThrownExceptions = null;
return;
}
PsiClass exceptionClass = exceptionType.resolve();
JavaPsiFacade facade = JavaPsiFacade.getInstance(myManager.getProject());
for (int i = myUnThrownExceptions.size() - 1; i >= 0; i--) {
String exceptionFqn = myUnThrownExceptions.get(i);
PsiClass classType =
facade.findClass(
exceptionFqn, GlobalSearchScope.allScope(getRefManager().getProject()));
if (InheritanceUtil.isInheritorOrSelf(exceptionClass, classType, true)
|| InheritanceUtil.isInheritorOrSelf(classType, exceptionClass, true)) {
myUnThrownExceptions.remove(i);
}
}
if (myUnThrownExceptions.isEmpty()) myUnThrownExceptions = null;
}
}
private static boolean isIndexOfCall(@NotNull PsiMethodCallExpression expression) {
final PsiReferenceExpression methodExpression = expression.getMethodExpression();
final String methodName = methodExpression.getReferenceName();
if (!HardcodedMethodConstants.INDEX_OF.equals(methodName)) {
return false;
}
final PsiExpressionList argumentList = expression.getArgumentList();
final PsiExpression[] arguments = argumentList.getExpressions();
if (arguments.length != 1) {
return false;
}
final PsiExpression qualifier = methodExpression.getQualifierExpression();
if (qualifier == null) {
return false;
}
final PsiType qualifierType = qualifier.getType();
if (qualifierType == null) {
return false;
}
final Project project = expression.getProject();
final GlobalSearchScope projectScope = GlobalSearchScope.allScope(project);
final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project);
final PsiClass javaUtilListClass =
psiFacade.findClass(CommonClassNames.JAVA_UTIL_LIST, projectScope);
if (javaUtilListClass == null) {
return false;
}
final PsiElementFactory factory = psiFacade.getElementFactory();
final PsiClassType javaUtilListType = factory.createType(javaUtilListClass);
return javaUtilListType.isAssignableFrom(qualifierType);
}
public IntroduceParameterObjectProcessor(
String className,
String packageName,
MoveDestination moveDestination,
PsiMethod method,
VariableData[] parameters,
boolean keepMethodAsDelegate,
final boolean useExistingClass,
final boolean createInnerClass,
String newVisibility,
boolean generateAccessors) {
super(method.getProject());
myMoveDestination = moveDestination;
this.method = method;
this.className = className;
this.packageName = packageName;
this.keepMethodAsDelegate = keepMethodAsDelegate;
myUseExistingClass = useExistingClass;
myCreateInnerClass = createInnerClass;
myNewVisibility = newVisibility;
myGenerateAccessors = generateAccessors;
this.parameters = new ArrayList<ParameterChunk>();
for (VariableData parameter : parameters) {
this.parameters.add(new ParameterChunk(parameter));
}
final PsiParameterList parameterList = method.getParameterList();
final PsiParameter[] methodParams = parameterList.getParameters();
paramsToMerge = new int[parameters.length];
for (int p = 0; p < parameters.length; p++) {
VariableData parameter = parameters[p];
for (int i = 0; i < methodParams.length; i++) {
final PsiParameter methodParam = methodParams[i];
if (parameter.variable.equals(methodParam)) {
paramsToMerge[p] = i;
break;
}
}
}
final Set<PsiTypeParameter> typeParamSet = new HashSet<PsiTypeParameter>();
final PsiTypeVisitor<Object> typeParametersVisitor =
new PsiTypeVisitor<Object>() {
@Override
public Object visitClassType(PsiClassType classType) {
final PsiClass referent = classType.resolve();
if (referent instanceof PsiTypeParameter) {
typeParamSet.add((PsiTypeParameter) referent);
}
return super.visitClassType(classType);
}
};
for (VariableData parameter : parameters) {
parameter.type.accept(typeParametersVisitor);
}
typeParams = new ArrayList<PsiTypeParameter>(typeParamSet);
final String qualifiedName = StringUtil.getQualifiedName(packageName, className);
final GlobalSearchScope scope = GlobalSearchScope.allScope(myProject);
existingClass = JavaPsiFacade.getInstance(myProject).findClass(qualifiedName, scope);
}
@Nullable
public PsiClass getPsiElement() {
final String qualifiedName = data.getMainClassName();
return qualifiedName != null
? JavaPsiFacade.getInstance(getProject())
.findClass(qualifiedName, GlobalSearchScope.allScope(project))
: null;
}
public void testParamWithImplicitConstructors() throws Exception {
final PsiMethod method = getPrimaryMethod();
parameterPropagationTest(
method,
collectDefaultConstructorsToPropagate(method),
JavaPsiFacade.getElementFactory(getProject())
.createTypeByFQClassName("java.lang.Class", GlobalSearchScope.allScope(getProject())));
}
private static PsiClassType createDefaultConsumerType(Project project, PsiParameter parameter) {
final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project);
final PsiClass consumerClass =
psiFacade.findClass("java.util.function.Consumer", GlobalSearchScope.allScope(project));
return consumerClass != null
? psiFacade.getElementFactory().createType(consumerClass, parameter.getType())
: null;
}
@Nullable
public static Location<PsiClass> fromClassQualifiedName(
final Project project, final String qualifiedName) {
final PsiClass psiClass =
JavaPsiFacade.getInstance(project)
.findClass(qualifiedName.replace('$', '.'), GlobalSearchScope.allScope(project));
return psiClass != null ? new PsiLocation<PsiClass>(project, psiClass) : null;
}
public void testXml() throws Exception {
PsiClass aClass = myJavaFacade.findClass("com.Foo", GlobalSearchScope.allScope(myProject));
doTest(aClass, new String[] {"Test.xml"}, new int[] {32}, new int[] {35});
final PsiFile nonCodeUsage =
PsiFileFactory.getInstance(myProject)
.createFileFromText("a.xml", StdFileTypes.XML, "<root action='com.Foo'/>", 0, true);
assertTrue(new UsageInfo(nonCodeUsage, 14, 21, true).getNavigationOffset() > 0);
}
/**
* Get jet non-extension top-level function names. Method is allowed to give invalid names - all
* result should be checked with getTopLevelFunctionDescriptorsByName().
*
* @return
*/
@NotNull
public Collection<String> getAllTopLevelFunctionNames() {
Set<String> functionNames = new HashSet<String>();
functionNames.addAll(JetShortFunctionNameIndex.getInstance().getAllKeys(project));
functionNames.addAll(
JetFromJavaDescriptorHelper.getPossiblePackageDeclarationsNames(
project, GlobalSearchScope.allScope(project)));
return functionNames;
}
public void processIncludes(PsiFile file, Processor<FileIncludeInfo> processor) {
GlobalSearchScope scope = GlobalSearchScope.allScope(myProject);
List<FileIncludeInfoImpl> infoList = FileIncludeIndex.getIncludes(file.getVirtualFile(), scope);
for (FileIncludeInfoImpl info : infoList) {
if (!processor.process(info)) {
return;
}
}
}