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; } } }