@Nullable public static PsiFile findMainFileInDirectory(@NotNull VirtualFile packageDirectory, @NotNull Project project) { for (VirtualFile file : packageDirectory.getChildren()) { if (file == null) { continue; } PsiFile psiFile = PsiManager.getInstance(project).findFile(file); if (isMainGoFile(psiFile)) { return psiFile; } } return null; }
PsiDirectory directory = PsiManager.getInstance(project).findDirectory(aPackage); if (directory == null) { continue; String organizationName = "ballerina"; for (VirtualFile aPackage : packages) { PsiDirectory directory = PsiManager.getInstance(project).findDirectory(aPackage); if (directory == null) { continue; packages = BallerinaPathModificationTracker.getPackagesFromOrganization(organizationName); for (VirtualFile aPackage : packages) { PsiDirectory directory = PsiManager.getInstance(project).findDirectory(aPackage); if (directory == null) { continue;
private static com.intellij.lang.Language templateDataLanguage(@NotNull PsiManager psiManager, @NotNull VirtualFile virtualFile) { Project project = psiManager.getProject(); com.intellij.lang.Language templateDataLanguage = TemplateDataLanguageMappings.getInstance(project).getMapping(virtualFile); if (templateDataLanguage == null) { templateDataLanguage = onlyTemplateDataFileType(virtualFile) .filter(LanguageFileType.class::isInstance) .map(LanguageFileType.class::cast) .map(LanguageFileType::getLanguage) .orElse(null); } if (templateDataLanguage == null) { templateDataLanguage = Language.defaultTemplateLanguageFileType().getLanguage(); } com.intellij.lang.Language substituteLang = LanguageSubstitutors.INSTANCE.substituteLanguage(templateDataLanguage, virtualFile, project); // only use a substituted language if it's templateable if (TemplateDataLanguageMappings.getTemplateableLanguages().contains(substituteLang)) { templateDataLanguage = substituteLang; } return templateDataLanguage; }
/** * Finds {@link PsiFile} for the given {@link VirtualFile} instance. If file is outside current project, * it's required to create new {@link PsiFile} manually. * * @param project current project * @param virtualFile to handle * @return {@link PsiFile} instance */ @Nullable public static PsiFile getPsiFile(@NotNull Project project, @NotNull VirtualFile virtualFile) { PsiFile psiFile = PsiManager.getInstance(project).findFile(virtualFile); if (psiFile == null) { FileViewProvider viewProvider = PsiManager.getInstance(project).findViewProvider(virtualFile); if (viewProvider != null) { IgnoreLanguage language = IgnoreBundle.obtainLanguage(virtualFile); if (language != null) { psiFile = language.createFile(viewProvider); } } } return psiFile; }
/** * Searches for directory or file using {@link PsiManager}. * * @param manager {@link PsiManager} instance * @param file working file * @return Psi item */ @Nullable private PsiFileSystemItem getPsiFileSystemItem(@NotNull PsiManager manager, @NotNull VirtualFile file) { if (!file.isValid()) { return null; } return file.isDirectory() ? manager.findDirectory(file) : manager.findFile(file); } }
@Nullable @Override public PsiElement[] getGotoDeclarationTargets(PsiElement psiElement, int i, Editor editor) { if(!Symfony2ProjectComponent.isEnabled(psiElement)) { return null; } String[] fileExtensionFilterIfValidTag = findValidAssetFilter(psiElement); if (fileExtensionFilterIfValidTag == null) { return null; } Collection<PsiElement> psiElements = new HashSet<>(); for (VirtualFile virtualFile : TwigUtil.resolveAssetsFiles(psiElement.getProject(), psiElement.getText(), fileExtensionFilterIfValidTag)) { PsiElement target; if(virtualFile.isDirectory()) { target = PsiManager.getInstance(psiElement.getProject()).findDirectory(virtualFile); } else { target = PsiManager.getInstance(psiElement.getProject()).findFile(virtualFile); } if(target != null) { psiElements.add(target); } } return psiElements.toArray(new PsiElement[psiElements.size()]); }
private void doDirectoryTest(@NotNull VirtualFile file) { VfsUtilCore.processFilesRecursively(file, new FilteringProcessor<>( virtualFile -> !virtualFile.isDirectory() && virtualFile.getName().endsWith(".go"), virtualFile -> { PsiFile goFile = myFixture.getPsiManager().findFile(virtualFile); assert goFile instanceof GoFile; processPsiFile((GoFile)goFile); return true; } )); doResolveTest(); } }
private List<PsiFile> findAllFilesFor(@NotNull final List<VirtualFile> virtualFiles) { final List<PsiFile> childFiles = new ArrayList<>(); final PsiManager psiManager = PsiManager.getInstance(this.plugin.getProject()); for (final VirtualFile virtualFile : virtualFiles) { childFiles.addAll(buildFilesList(psiManager, virtualFile)); } return childFiles; }
public boolean isReferenceTo(PsiElement element) { return PsiManager.getInstance(element.getProject()).areElementsEquivalent(element, resolve()); }
/** * Returns the directory containing the file. * * @return the containing directory, or null if the file exists only in memory. */ @Override public PsiDirectory getContainingDirectory() { VirtualFile parentFile = getVirtualFile().getParent(); PsiDirectory containingDirectory = null; if (parentFile != null) { containingDirectory = getManager().findDirectory(parentFile); } return containingDirectory; }
@Override public PsiElement getDocumentationElementForLink(PsiManager psiManager, String link, PsiElement context) { if (context != null && !DumbService.isDumb(psiManager.getProject())) { // it's important to ask module on file, otherwise module won't be found for elements in libraries files [zolotov] Module module = ModuleUtilCore.findModuleForPsiElement(context.getContainingFile()); int hash = link.indexOf('#'); String importPath = hash >= 0 ? link.substring(0, hash) : link; Project project = psiManager.getProject(); VirtualFile directory = GoPackageUtil.findByImportPath(importPath, project, module); PsiDirectory psiDirectory = directory != null ? psiManager.findDirectory(directory) : null; String anchor = hash >= 0 ? link.substring(Math.min(hash + 1, link.length())) : null; if (StringUtil.isNotEmpty(anchor)) { GlobalSearchScope scope = psiDirectory != null ? GoPackageUtil.packageScope(psiDirectory, null) : GlobalSearchScope.projectScope(project); IdFilter idFilter = GoIdFilter.getFilesFilter(scope); GoNamedElement element = ContainerUtil.getFirstItem(StubIndex.getElements(GoAllPublicNamesIndex.ALL_PUBLIC_NAMES, anchor, project, scope, idFilter, GoNamedElement.class)); if (element != null) { return element; } return ContainerUtil.getFirstItem(StubIndex.getElements(GoAllPrivateNamesIndex.ALL_PRIVATE_NAMES, anchor, project, scope, idFilter, GoNamedElement.class)); } else { return psiDirectory; } } return super.getDocumentationElementForLink(psiManager, link, context); }
@Override public boolean isReferenceTo(PsiElement element) { return GoUtil.couldBeReferenceTo(element, getElement()) && getElement().getManager().areElementsEquivalent(resolve(), element); } };
List<File> sources, List<File> targets) throws IOException { final PsiManager instance = PsiManager.getInstance(project); final List<PsiFile> files = new ArrayList<PsiFile>(); final List<PsiDirectory> dirs = new ArrayList<PsiDirectory>(); final VirtualFile vFile = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(source); if (vFile != null) { PsiFile item = instance.findFile(vFile); if (item != null) { files.add(item); final PsiDirectory dir = instance.findDirectory(targetDir); if (dir != null) { dirs.add(dir);
@Nullable public static GoFile findBuiltinFile(@NotNull PsiElement context) { Project project = context.getProject(); // it's important to ask module on file, otherwise module won't be found for elements in libraries files [zolotov] Module moduleFromContext = ModuleUtilCore.findModuleForPsiElement(context.getContainingFile()); if (moduleFromContext == null) { for (Module module : ModuleManager.getInstance(project).getModules()) { if (GoSdkService.getInstance(project).isGoModule(module)) { moduleFromContext = module; break; } } } Module module = moduleFromContext; UserDataHolder holder = ObjectUtils.notNull(module, project); VirtualFile file = CachedValuesManager.getManager(context.getProject()).getCachedValue(holder, () -> { VirtualFile sdkSrcDir = getSdkSrcDir(project, module); VirtualFile result = sdkSrcDir != null ? sdkSrcDir.findFileByRelativePath(GoConstants.BUILTIN_FILE_PATH) : null; return CachedValueProvider.Result.create(result, getSdkAndLibrariesCacheDependencies(project, module, result)); }); if (file == null) return null; PsiFile psiBuiltin = context.getManager().findFile(file); return psiBuiltin instanceof GoFile ? (GoFile)psiBuiltin : null; }
private Optional<PsiFile> getReferencedFile(final String relativePath) { final Optional<VirtualFile> baseDir = Optional.ofNullable(getElement()) .map(PsiElement::getContainingFile) .map(PsiFile::getVirtualFile) .map(VirtualFile::getParent); final PsiManager psiManager = PsiManager.getInstance(getElement().getProject()); return baseDir.map(dir -> dir.findFileByRelativePath(relativePath)).map(psiManager::findFile); }
private void doTestInEmptyDirectory(@NotNull String directoryName, @NotNull String newFileName, @NotNull String expectedPackage, @NotNull String expectedPackageWithTestSuffix) { try { PsiDirectory dir = myFixture.getPsiManager().findDirectory(myFixture.getTempDirFixture().findOrCreateDir(directoryName)); assertNotNull(dir); doTest(dir, newFileName, expectedPackage, expectedPackageWithTestSuffix); } catch (IOException e) { throw new RuntimeException(e); } }
/** * @param aClass a class to check. * @param baseClass supposed base class. * @param checkDeep true to check deeper than aClass.super (see {@linkplain PsiClass#isInheritor(com.intellij.psi.PsiClass, boolean)}). * @return true if aClass is the baseClass or baseClass inheritor */ public static boolean isInheritorOrSelf(@Nullable PsiClass aClass, @Nullable PsiClass baseClass, boolean checkDeep) { if (aClass == null || baseClass == null) return false; PsiManager manager = aClass.getManager(); return manager.areElementsEquivalent(baseClass, aClass) || aClass.isInheritor(baseClass, checkDeep); }
@Nullable public static PsiFile getFile(@NotNull Editor editor) { VirtualFile vf = EditorData.getVirtualFile(editor); if (vf != null) { Project proj = editor.getProject(); if (proj != null) { PsiManager mgr = PsiManager.getInstance(proj); return mgr.findFile(vf); } } return null; } }
/** * Gets Ignore file for given {@link Project} and root {@link PsiDirectory}. * If file is missing - creates new one. * * @param project current project * @param fileType current ignore file type * @param directory root directory * @param createIfMissing create new file if missing * @return Ignore file */ @Nullable public static PsiFile getIgnoreFile(@NotNull Project project, @NotNull IgnoreFileType fileType, @Nullable PsiDirectory directory, boolean createIfMissing) { if (directory == null) { directory = PsiManager.getInstance(project).findDirectory(project.getBaseDir()); } assert directory != null; String filename = fileType.getIgnoreLanguage().getFilename(); PsiFile file = directory.findFile(filename); VirtualFile virtualFile = file == null ? directory.getVirtualFile().findChild(filename) : file.getVirtualFile(); if (file == null && virtualFile == null && createIfMissing) { try { file = new CreateFileCommandAction(project, directory, fileType).execute(); } catch (Throwable throwable) { throwable.printStackTrace(); } } return file; }
private void showSVGChooser() { FileChooserDescriptor descriptor = FileChooserDescriptorFactory.createSingleFolderDescriptor(); if (!batch.isSelected()) { descriptor = FileChooserDescriptorFactory.createSingleFileDescriptor("svg"); } VirtualFile virtualFile = FileChooser.chooseFile(descriptor, project, null); if (virtualFile != null) { if (!virtualFile.isDirectory() && virtualFile.getName().toLowerCase().endsWith("svg")) { svg = (XmlFile) PsiManager.getInstance(project).findFile(virtualFile); //got *.svg file as xml svgPath.setText(virtualFile.getPath()); xmlName.setEditable(true); xmlName.setEnabled(true); xmlName.setText(CommonUtil.getValidName(svg.getName().split("\\.")[0]) + ".xml"); } else if (virtualFile.isDirectory()) { svgDir = PsiManager.getInstance(project).findDirectory(virtualFile); svgPath.setText(virtualFile.getPath()); xmlName.setEditable(false); xmlName.setEnabled(false); xmlName.setText("keep origin name"); } } frame.setAlwaysOnTop(true); }