public boolean isVersionAtLeast(PsiElement psiElement, String version, boolean unknownResult) {
Module module = ModuleUtilCore.findModuleForPsiElement(psiElement);
if (module == null) return unknownResult;
final String sdkVersion = getSDKVersion(module);
if (sdkVersion == null) return unknownResult;
return sdkVersion.compareTo(version) >= 0;
}
@Nullable
static HighlightInfo checkFileDuplicates(@NotNull PsiJavaModule element, @NotNull PsiFile file) {
Module module = ModuleUtilCore.findModuleForPsiElement(element);
if (module != null) {
Project project = file.getProject();
Collection<VirtualFile> others =
FilenameIndex.getVirtualFilesByName(project, MODULE_INFO_FILE, new ModulesScope(module));
if (others.size() > 1) {
String message = JavaErrorMessages.message("module.file.duplicate");
HighlightInfo info =
HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
.range(range(element))
.description(message)
.create();
others
.stream()
.map(f -> PsiManager.getInstance(project).findFile(f))
.filter(f -> f != file)
.findFirst()
.ifPresent(
duplicate ->
QuickFixAction.registerQuickFixAction(
info,
new GoToSymbolFix(
duplicate, JavaErrorMessages.message("module.open.duplicate.text"))));
return info;
}
}
return null;
}
@NotNull
private GlobalSearchScope getSearchScope() {
Project project = myElement.getProject();
Module module = ModuleUtilCore.findModuleForPsiElement(myElement);
return module != null
? module.getModuleWithDependenciesAndLibrariesScope(true)
: new ProjectAndLibrariesScope(project);
}
@Nullable
protected Module getNodeModule(@Nullable final Object element) {
if (element instanceof PsiElement) {
PsiElement psiElement = (PsiElement) element;
return ModuleUtilCore.findModuleForPsiElement(psiElement);
}
return null;
}
@NotNull
public String getSDKVersion(PsiElement psiElement) {
final Module module = ModuleUtilCore.findModuleForPsiElement(psiElement);
if (module == null) {
return NO_VERSION;
}
final String s = getSDKVersion(module);
return s != null ? s : NO_VERSION;
}
@Override
public Module getModule() {
final DomFileElement<DomElement> fileElement = DomUtil.getFileElement(getInvocationElement());
if (fileElement == null) {
final XmlElement xmlElement = getInvocationElement().getXmlElement();
return xmlElement == null ? null : ModuleUtilCore.findModuleForPsiElement(xmlElement);
}
return fileElement.isValid() ? fileElement.getRootElement().getModule() : null;
}
@Override
public String getElementModuleName(final Object element) {
if (element instanceof PsiClass) {
PsiClass aClass = (PsiClass) element;
Module module = ModuleUtilCore.findModuleForPsiElement(aClass);
return module != null ? module.getName() : null;
}
return null;
}
@Override
protected void buildDialog(
final Project project, PsiDirectory directory, CreateFileFromTemplateDialog.Builder builder) {
builder
.setTitle(JavaCoreBundle.message("action.create.new.class"))
.addKind("Class", PlatformIcons.CLASS_ICON, JavaTemplateUtil.INTERNAL_CLASS_TEMPLATE_NAME)
.addKind(
"Interface",
PlatformIcons.INTERFACE_ICON,
JavaTemplateUtil.INTERNAL_INTERFACE_TEMPLATE_NAME);
Module module = ModuleUtilCore.findModuleForPsiElement(directory);
assert module != null;
JavaModuleExtensionImpl moduleExtension =
ModuleRootManager.getInstance(module).getExtension(JavaModuleExtensionImpl.class);
assert moduleExtension != null;
if (moduleExtension.getLanguageLevel().isAtLeast(LanguageLevel.JDK_1_5)) {
builder.addKind(
"Enum", PlatformIcons.ENUM_ICON, JavaTemplateUtil.INTERNAL_ENUM_TEMPLATE_NAME);
builder.addKind(
"Annotation",
PlatformIcons.ANNOTATION_TYPE_ICON,
JavaTemplateUtil.INTERNAL_ANNOTATION_TYPE_TEMPLATE_NAME);
}
for (FileTemplate template : FileTemplateManager.getInstance().getAllTemplates()) {
final JavaCreateFromTemplateHandler handler = new JavaCreateFromTemplateHandler();
if (handler.handlesTemplate(template) && JavaCreateFromTemplateHandler.canCreate(directory)) {
builder.addKind(template.getName(), JavaFileType.INSTANCE.getIcon(), template.getName());
}
}
builder.setValidator(
new InputValidatorEx() {
@Override
public String getErrorText(String inputString) {
if (inputString.length() > 0
&& !JavaPsiFacade.getInstance(project)
.getNameHelper()
.isQualifiedName(inputString)) {
return "This is not a valid Java qualified name";
}
return null;
}
@Override
public boolean checkInput(String inputString) {
return true;
}
@Override
public boolean canClose(String inputString) {
return !StringUtil.isEmptyOrSpaces(inputString) && getErrorText(inputString) == null;
}
});
}
public static boolean isAtLeast(PsiElement element, JavaSdkVersion minVersion) {
final Module module = ModuleUtilCore.findModuleForPsiElement(element);
if (module != null) {
final Sdk sdk = ModuleRootManager.getInstance(module).getSdk();
if (sdk != null && sdk.getSdkType() instanceof JavaSdk) {
final JavaSdkVersion version = JavaSdk.getInstance().getVersion(sdk);
return version != null && version.isAtLeast(minVersion);
}
}
return true;
}
@Nullable
static String getID(PsiElement place, String alternativeID) {
if (alternativeID != null) {
final Module module = ModuleUtilCore.findModuleForPsiElement(place);
if (module != null) {
if (!ClasspathStorage.getStorageType(module).equals(ClasspathStorage.DEFAULT_STORAGE)) {
return alternativeID;
}
}
}
return null;
}
@Nullable
static PythonPathCache getPathCache(PsiElement foothold) {
PythonPathCache cache = null;
final Module module = ModuleUtilCore.findModuleForPsiElement(foothold);
if (module != null) {
cache = PythonModulePathCache.getInstance(module);
} else {
final Sdk sdk = PyBuiltinCache.findSdkForFile(foothold.getContainingFile());
if (sdk != null) {
cache = PythonSdkPathCache.getInstance(foothold.getProject(), sdk);
}
}
return cache;
}
@Override
public ProblemDescriptor[] checkClass(
@NotNull PsiClass aClass, @NotNull InspectionManager manager, boolean isOnTheFly) {
final Project project = aClass.getProject();
final PsiIdentifier nameIdentifier = aClass.getNameIdentifier();
final Module module = ModuleUtilCore.findModuleForPsiElement(aClass);
if (nameIdentifier == null || module == null || !PsiUtil.isInstantiable(aClass)) return null;
final PsiClass base =
JavaPsiFacade.getInstance(project).findClass(getClassName(), aClass.getResolveScope());
if (base == null || !aClass.isInheritor(base, true)) return null;
String descriptionDir = DescriptionCheckerUtil.getDescriptionDirName(aClass);
if (StringUtil.isEmptyOrSpaces(descriptionDir)) {
return null;
}
for (PsiDirectory description : getDescriptionsDirs(module)) {
PsiDirectory dir = description.findSubdirectory(descriptionDir);
if (dir == null) continue;
final PsiFile descr = dir.findFile("description.html");
if (descr != null) {
if (!hasBeforeAndAfterTemplate(dir.getVirtualFile())) {
PsiElement problem = aClass.getNameIdentifier();
ProblemDescriptor problemDescriptor =
manager.createProblemDescriptor(
problem == null ? nameIdentifier : problem,
getHasNotBeforeAfterError(),
isOnTheFly,
ProblemHighlightType.GENERIC_ERROR_OR_WARNING,
false);
return new ProblemDescriptor[] {problemDescriptor};
}
return null;
}
}
final PsiElement problem = aClass.getNameIdentifier();
final ProblemDescriptor problemDescriptor =
manager.createProblemDescriptor(
problem == null ? nameIdentifier : problem,
getHasNotDescriptionError(),
isOnTheFly,
new LocalQuickFix[] {getFix(module, descriptionDir)},
ProblemHighlightType.GENERIC_ERROR_OR_WARNING);
return new ProblemDescriptor[] {problemDescriptor};
}
public void search() {
myFiles.clear();
myJars.clear();
PsiManager psiManager = PsiManager.getInstance(myProject);
for (PsiFile file : search(myModule, myProject)) {
VirtualFile jar = JarFileSystem.getInstance().getVirtualFileForJar(file.getVirtualFile());
if (jar != null) {
myJars.putValue(jar, file);
} else {
Module module = ModuleUtilCore.findModuleForPsiElement(file);
if (module != null) {
myFiles.putValue(module, file);
} else {
VirtualFile virtualFile = file.getVirtualFile();
myVirtualFiles.putValue(virtualFile.getParent(), psiManager.findFile(virtualFile));
}
}
}
}
@Override
public void invoke(
@NotNull final Project project, final Editor editor, PsiFile file, DataContext dataContext) {
final int offset = editor.getCaretModel().getOffset();
final PsiElement element = file.findElementAt(offset);
final PsiMember member = PsiTreeUtil.getParentOfType(element, PsiMember.class);
final String cannotRefactorMessage = getCannotRefactorMessage(member);
if (cannotRefactorMessage != null) {
String message = RefactoringBundle.getCannotRefactorMessage(cannotRefactorMessage);
showErrorMessage(message, project, editor);
return;
}
final AnalysisScope scope = new AnalysisScope(file);
final Module module = ModuleUtilCore.findModuleForPsiElement(file);
final BaseAnalysisActionDialog dlg =
new BaseAnalysisActionDialog(
RefactoringBundle.message(
"replace.method.duplicates.scope.chooser.title", REFACTORING_NAME),
RefactoringBundle.message("replace.method.duplicates.scope.chooser.message"),
project,
scope,
module != null ? module.getName() : null,
false,
AnalysisUIOptions.getInstance(project),
element);
if (dlg.showAndGet()) {
ProgressManager.getInstance()
.run(
new Task.Backgroundable(project, "Locate duplicates", true) {
@Override
public void run(@NotNull ProgressIndicator indicator) {
indicator.setIndeterminate(true);
invokeOnScope(
project,
member,
dlg.getScope(AnalysisUIOptions.getInstance(project), scope, project, module));
}
});
}
}
private static boolean isValidInContext(@NotNull PsiElement element) {
if (!(element instanceof PsiMethod)) {
return false;
}
final Module module = ModuleUtilCore.findModuleForPsiElement(element);
if (module == null) {
return false;
}
final MinecraftModule minecraftModule = MinecraftModule.getInstance(module);
if (minecraftModule == null) {
return false;
}
if (!minecraftModule.isOfType(MixinModuleType.getInstance())) {
return false;
}
final PsiMethod method = (PsiMethod) element;
return AuthorInspection.shouldHaveAuthorTag(method);
}
@Override
public Collection<? extends PsiFile> getStepDefinitionContainers(
@NotNull GherkinFile featureFile) {
final Module module = ModuleUtilCore.findModuleForPsiElement(featureFile);
if (module == null) {
return Collections.emptySet();
}
List<AbstractStepDefinition> stepDefs = loadStepsFor(featureFile, module);
Set<PsiFile> result = new HashSet<PsiFile>();
for (AbstractStepDefinition stepDef : stepDefs) {
PsiElement stepDefElement = stepDef.getElement();
if (stepDefElement != null) {
final PsiFile psiFile = stepDefElement.getContainingFile();
if (isWritableStepLikeFile(psiFile, psiFile.getParent())) {
result.add(psiFile);
}
}
}
return result;
}
@Override
public String toString() {
if (myText == null) {
Module module = ModuleUtilCore.findModuleForPsiElement(myClass);
if (module != null) {
myText = module.getName();
} else {
VirtualFile virtualFile = myClass.getContainingFile().getVirtualFile();
final ProjectFileIndex index =
ProjectRootManager.getInstance(myClass.getProject()).getFileIndex();
VirtualFile root = index.getSourceRootForFile(virtualFile);
if (root == null) {
root = index.getClassRootForFile(virtualFile);
}
if (root != null) {
myText = root.getName();
} else {
myText = virtualFile.getPath();
}
}
}
return myText;
}
@Override
public GlobalSearchScope patchResolveScope(
@NotNull GroovyFile file, @NotNull GlobalSearchScope baseScope) {
final Module module = ModuleUtilCore.findModuleForPsiElement(file);
final GradleInstallationManager libraryManager =
ServiceManager.getService(GradleInstallationManager.class);
if (module != null) {
if (libraryManager.getGradleHome(module) != null) {
return baseScope;
}
}
final Collection<VirtualFile> files = libraryManager.getClassRoots(file.getProject());
if (files == null || files.isEmpty()) {
return baseScope;
}
GlobalSearchScope result = baseScope;
for (final VirtualFile root : files) {
result = result.uniteWith(new NonClasspathDirectoryScope(root));
}
return result;
}
@Override
public void rootsChanged(ModuleRootEvent event) {
if (myToolWindowForm == null || !myToolWindowReady || myToolWindowDisposed) {
return;
}
final PsiFile file = myToolWindowForm.getFile();
if (file != null) {
final Module module = ModuleUtilCore.findModuleForPsiElement(file);
if (module != null) {
final Sdk prevSdk = myModule2Sdk.get(module);
final Sdk newSdk = ModuleRootManager.getInstance(module).getSdk();
if (newSdk != null
&& (newSdk.getSdkType() instanceof AndroidSdkType
|| (prevSdk != null && prevSdk.getSdkType() instanceof AndroidSdkType))
&& !newSdk.equals(prevSdk)) {
render();
}
}
}
updateMap();
}
public static boolean checkTestNGInClasspath(PsiElement psiElement) {
final Project project = psiElement.getProject();
final PsiManager manager = PsiManager.getInstance(project);
if (JavaPsiFacade.getInstance(manager.getProject())
.findClass(TestNG.class.getName(), psiElement.getResolveScope())
== null) {
if (!ApplicationManager.getApplication().isUnitTestMode()) {
if (Messages.showOkCancelDialog(
psiElement.getProject(),
"TestNG will be added to module classpath",
"Unable to convert.",
Messages.getWarningIcon())
!= Messages.OK) {
return false;
}
}
final Module module = ModuleUtilCore.findModuleForPsiElement(psiElement);
if (module == null) return false;
String url =
VfsUtil.getUrlForLibraryRoot(new File(PathUtil.getJarPathForClass(Assert.class)));
ModuleRootModificationUtil.addModuleLibrary(module, url);
}
return true;
}
@NotNull
@Override
public List<SearchScope> getPredefinedScopes(
@NotNull final Project project,
@Nullable final DataContext dataContext,
boolean suggestSearchInLibs,
boolean prevSearchFiles,
boolean currentSelection,
boolean usageView,
boolean showEmptyScopes) {
Collection<SearchScope> result = ContainerUtil.newLinkedHashSet();
result.add(GlobalSearchScope.projectScope(project));
if (suggestSearchInLibs) {
result.add(GlobalSearchScope.allScope(project));
}
if (ModuleUtil.isSupportedRootType(project, JavaSourceRootType.TEST_SOURCE)) {
result.add(GlobalSearchScopesCore.projectProductionScope(project));
result.add(GlobalSearchScopesCore.projectTestScope(project));
}
final GlobalSearchScope openFilesScope = GlobalSearchScopes.openFilesScope(project);
if (openFilesScope != GlobalSearchScope.EMPTY_SCOPE) {
result.add(openFilesScope);
} else if (showEmptyScopes) {
result.add(
new LocalSearchScope(PsiElement.EMPTY_ARRAY, IdeBundle.message("scope.open.files")));
}
final Editor selectedTextEditor =
ApplicationManager.getApplication().isDispatchThread()
? FileEditorManager.getInstance(project).getSelectedTextEditor()
: null;
final PsiFile psiFile =
(selectedTextEditor != null)
? PsiDocumentManager.getInstance(project).getPsiFile(selectedTextEditor.getDocument())
: null;
PsiFile currentFile = psiFile;
if (dataContext != null) {
PsiElement dataContextElement = CommonDataKeys.PSI_FILE.getData(dataContext);
if (dataContextElement == null) {
dataContextElement = CommonDataKeys.PSI_ELEMENT.getData(dataContext);
}
if (dataContextElement == null && psiFile != null) {
dataContextElement = psiFile;
}
if (dataContextElement != null) {
if (!PlatformUtils.isCidr()) { // TODO: have an API to disable module scopes.
Module module = ModuleUtilCore.findModuleForPsiElement(dataContextElement);
if (module == null) {
module = LangDataKeys.MODULE.getData(dataContext);
}
if (module != null && !(ModuleType.get(module) instanceof InternalModuleType)) {
result.add(module.getModuleScope());
}
}
if (currentFile == null) {
currentFile = dataContextElement.getContainingFile();
}
}
}
if (currentFile != null || showEmptyScopes) {
PsiElement[] scope =
currentFile != null ? new PsiElement[] {currentFile} : PsiElement.EMPTY_ARRAY;
result.add(new LocalSearchScope(scope, IdeBundle.message("scope.current.file")));
}
if (currentSelection && selectedTextEditor != null && psiFile != null) {
SelectionModel selectionModel = selectedTextEditor.getSelectionModel();
if (selectionModel.hasSelection()) {
int start = selectionModel.getSelectionStart();
final PsiElement startElement = psiFile.findElementAt(start);
if (startElement != null) {
int end = selectionModel.getSelectionEnd();
final PsiElement endElement = psiFile.findElementAt(end);
if (endElement != null) {
final PsiElement parent = PsiTreeUtil.findCommonParent(startElement, endElement);
if (parent != null) {
final List<PsiElement> elements = new ArrayList<PsiElement>();
final PsiElement[] children = parent.getChildren();
TextRange selection = new TextRange(start, end);
for (PsiElement child : children) {
if (!(child instanceof PsiWhiteSpace)
&& child.getContainingFile() != null
&& selection.contains(child.getTextOffset())) {
elements.add(child);
}
}
if (!elements.isEmpty()) {
SearchScope local =
new LocalSearchScope(
PsiUtilCore.toPsiElementArray(elements),
IdeBundle.message("scope.selection"));
result.add(local);
}
}
}
}
}
}
if (usageView) {
addHierarchyScope(project, result);
UsageView selectedUsageView = UsageViewManager.getInstance(project).getSelectedUsageView();
if (selectedUsageView != null && !selectedUsageView.isSearchInProgress()) {
final Set<Usage> usages = ContainerUtil.newTroveSet(selectedUsageView.getUsages());
usages.removeAll(selectedUsageView.getExcludedUsages());
final List<PsiElement> results = new ArrayList<PsiElement>(usages.size());
if (prevSearchFiles) {
final Set<VirtualFile> files = collectFiles(usages, true);
if (!files.isEmpty()) {
GlobalSearchScope prev =
new GlobalSearchScope(project) {
private Set<VirtualFile> myFiles = null;
@NotNull
@Override
public String getDisplayName() {
return IdeBundle.message("scope.files.in.previous.search.result");
}
@Override
public synchronized boolean contains(@NotNull VirtualFile file) {
if (myFiles == null) {
myFiles = collectFiles(usages, false);
}
return myFiles.contains(file);
}
@Override
public int compare(@NotNull VirtualFile file1, @NotNull VirtualFile file2) {
return 0;
}
@Override
public boolean isSearchInModuleContent(@NotNull Module aModule) {
return true;
}
@Override
public boolean isSearchInLibraries() {
return true;
}
};
result.add(prev);
}
} else {
for (Usage usage : usages) {
if (usage instanceof PsiElementUsage) {
final PsiElement element = ((PsiElementUsage) usage).getElement();
if (element != null && element.isValid() && element.getContainingFile() != null) {
results.add(element);
}
}
}
if (!results.isEmpty()) {
result.add(
new LocalSearchScope(
PsiUtilCore.toPsiElementArray(results),
IdeBundle.message("scope.previous.search.results")));
}
}
}
}
final FavoritesManager favoritesManager = FavoritesManager.getInstance(project);
if (favoritesManager != null) {
for (final String favorite : favoritesManager.getAvailableFavoritesListNames()) {
final Collection<TreeItem<Pair<AbstractUrl, String>>> rootUrls =
favoritesManager.getFavoritesListRootUrls(favorite);
if (rootUrls.isEmpty()) continue; // ignore unused root
result.add(
new GlobalSearchScope(project) {
@NotNull
@Override
public String getDisplayName() {
return "Favorite \'" + favorite + "\'";
}
@Override
public boolean contains(@NotNull final VirtualFile file) {
return ApplicationManager.getApplication()
.runReadAction(
(Computable<Boolean>) () -> favoritesManager.contains(favorite, file));
}
@Override
public int compare(
@NotNull final VirtualFile file1, @NotNull final VirtualFile file2) {
return 0;
}
@Override
public boolean isSearchInModuleContent(@NotNull final Module aModule) {
return true;
}
@Override
public boolean isSearchInLibraries() {
return true;
}
});
}
}
ContainerUtil.addIfNotNull(result, getSelectedFilesScope(project, dataContext));
return ContainerUtil.newArrayList(result);
}
public static List<SearchScope> getPredefinedScopes(
@NotNull final Project project,
@Nullable final DataContext dataContext,
boolean suggestSearchInLibs,
boolean prevSearchFiles,
boolean currentSelection,
boolean usageView) {
ArrayList<SearchScope> result = new ArrayList<SearchScope>();
result.add(GlobalSearchScope.projectScope(project));
if (suggestSearchInLibs) {
result.add(GlobalSearchScope.allScope(project));
}
if (!PlatformUtils.isCidr()
&& ModuleUtil.isSupportedRootType(
project, JavaSourceRootType.TEST_SOURCE)) { // TODO: fix these scopes in AppCode
result.add(GlobalSearchScopes.projectProductionScope(project));
result.add(GlobalSearchScopes.projectTestScope(project));
}
result.add(GlobalSearchScopes.openFilesScope(project));
if (dataContext != null) {
PsiElement dataContextElement = CommonDataKeys.PSI_FILE.getData(dataContext);
if (dataContextElement == null) {
dataContextElement = CommonDataKeys.PSI_ELEMENT.getData(dataContext);
}
if (dataContextElement != null) {
if (!PlatformUtils.isCidr()) { // TODO: have an API to disable module scopes.
Module module = ModuleUtilCore.findModuleForPsiElement(dataContextElement);
if (module == null) {
module = LangDataKeys.MODULE.getData(dataContext);
}
if (module != null) {
result.add(module.getModuleScope());
}
}
if (dataContextElement.getContainingFile() != null) {
result.add(
new LocalSearchScope(dataContextElement, IdeBundle.message("scope.current.file")));
}
}
}
if (currentSelection) {
FileEditorManager fileEditorManager = FileEditorManager.getInstance(project);
final Editor selectedTextEditor = fileEditorManager.getSelectedTextEditor();
if (selectedTextEditor != null) {
final PsiFile psiFile =
PsiDocumentManager.getInstance(project).getPsiFile(selectedTextEditor.getDocument());
if (psiFile != null) {
if (selectedTextEditor.getSelectionModel().hasSelection()) {
final PsiElement startElement =
psiFile.findElementAt(selectedTextEditor.getSelectionModel().getSelectionStart());
if (startElement != null) {
final PsiElement endElement =
psiFile.findElementAt(selectedTextEditor.getSelectionModel().getSelectionEnd());
if (endElement != null) {
final PsiElement parent = PsiTreeUtil.findCommonParent(startElement, endElement);
if (parent != null) {
final List<PsiElement> elements = new ArrayList<PsiElement>();
final PsiElement[] children = parent.getChildren();
for (PsiElement child : children) {
if (!(child instanceof PsiWhiteSpace) && child.getContainingFile() != null) {
elements.add(child);
}
}
if (!elements.isEmpty()) {
SearchScope local =
new LocalSearchScope(
PsiUtilCore.toPsiElementArray(elements),
IdeBundle.message("scope.selection"));
result.add(local);
}
}
}
}
}
}
}
}
if (usageView) {
UsageView selectedUsageView = UsageViewManager.getInstance(project).getSelectedUsageView();
if (selectedUsageView != null && !selectedUsageView.isSearchInProgress()) {
final Set<Usage> usages = selectedUsageView.getUsages();
final List<PsiElement> results = new ArrayList<PsiElement>(usages.size());
if (prevSearchFiles) {
final Set<VirtualFile> files = new HashSet<VirtualFile>();
for (Usage usage : usages) {
if (usage instanceof PsiElementUsage) {
PsiElement psiElement = ((PsiElementUsage) usage).getElement();
if (psiElement != null && psiElement.isValid()) {
PsiFile psiFile = psiElement.getContainingFile();
if (psiFile != null) {
VirtualFile file = psiFile.getVirtualFile();
if (file != null) files.add(file);
}
}
}
}
if (!files.isEmpty()) {
GlobalSearchScope prev =
new GlobalSearchScope(project) {
@Override
public String getDisplayName() {
return IdeBundle.message("scope.files.in.previous.search.result");
}
@Override
public boolean contains(@NotNull VirtualFile file) {
return files.contains(file);
}
@Override
public int compare(@NotNull VirtualFile file1, @NotNull VirtualFile file2) {
return 0;
}
@Override
public boolean isSearchInModuleContent(@NotNull Module aModule) {
return true;
}
@Override
public boolean isSearchInLibraries() {
return true;
}
};
result.add(prev);
}
} else {
for (Usage usage : usages) {
if (usage instanceof PsiElementUsage) {
final PsiElement element = ((PsiElementUsage) usage).getElement();
if (element != null && element.isValid() && element.getContainingFile() != null) {
results.add(element);
}
}
}
if (!results.isEmpty()) {
result.add(
new LocalSearchScope(
PsiUtilCore.toPsiElementArray(results),
IdeBundle.message("scope.previous.search.results")));
}
}
}
}
final FavoritesManager favoritesManager = FavoritesManager.getInstance(project);
if (favoritesManager != null) {
for (final String favorite : favoritesManager.getAvailableFavoritesListNames()) {
final Collection<TreeItem<Pair<AbstractUrl, String>>> rootUrls =
favoritesManager.getFavoritesListRootUrls(favorite);
if (rootUrls.isEmpty()) continue; // ignore unused root
result.add(
new GlobalSearchScope(project) {
@Override
public String getDisplayName() {
return "Favorite \'" + favorite + "\'";
}
@Override
public boolean contains(@NotNull final VirtualFile file) {
return favoritesManager.contains(favorite, file);
}
@Override
public int compare(
@NotNull final VirtualFile file1, @NotNull final VirtualFile file2) {
return 0;
}
@Override
public boolean isSearchInModuleContent(@NotNull final Module aModule) {
return true;
}
@Override
public boolean isSearchInLibraries() {
return true;
}
});
}
}
if (dataContext != null) {
final VirtualFile[] files = CommonDataKeys.VIRTUAL_FILE_ARRAY.getData(dataContext);
if (files != null) {
final List<VirtualFile> openFiles = Arrays.asList(files);
result.add(
new DelegatingGlobalSearchScope(GlobalSearchScope.filesScope(project, openFiles)) {
@Override
public String getDisplayName() {
return "Selected Files";
}
});
}
}
return result;
}
public ConfigurationContext(PsiElement element) {
myModule = ModuleUtilCore.findModuleForPsiElement(element);
myLocation = new PsiLocation<>(element.getProject(), myModule, element);
myRuntimeConfiguration = null;
myContextComponent = null;
}
private static void doExtractStyle(@NotNull XmlTag viewTag, @Nullable MyTestConfig testConfig) {
final Module module = ModuleUtilCore.findModuleForPsiElement(viewTag);
assert module != null;
doExtractStyle(module, viewTag, true, testConfig);
}
private static boolean isSpecialDirectory(@NotNull PsiDirectory directory) {
final Module module = ModuleUtilCore.findModuleForPsiElement(directory);
final VirtualFile vFile = directory.getVirtualFile();
// If module is null, directory is probably excluded
return module == null || PyUtil.getSourceRoots(module).contains(vFile);
}
@Nullable
private static Sdk getPythonSdk(@NotNull final PsiElement element) {
final Module module = ModuleUtilCore.findModuleForPsiElement(element);
return (module == null) ? null : PythonSdkType.findPythonSdk(module);
}
@Override
public void annotate(@NotNull PsiElement element, @NotNull AnnotationHolder holder) {
if (!MinecraftSettings.Companion.getInstance().isShowEventListenerGutterIcons()) {
return;
}
// Since we want to line up with the method declaration, not the annotation
// declaration, we need to target identifiers, not just PsiMethods.
if (!(element instanceof PsiIdentifier && (element.getParent() instanceof PsiMethod))) {
return;
}
// The PsiIdentifier is going to be a method of course!
PsiMethod method = (PsiMethod) element.getParent();
if (method.hasModifierProperty(PsiModifier.ABSTRACT)) {
// I don't think any implementation allows for abstract
return;
}
PsiModifierList modifierList = method.getModifierList();
Module module = ModuleUtilCore.findModuleForPsiElement(element);
if (module == null) {
return;
}
MinecraftModule instance = MinecraftModule.getInstance(module);
if (instance == null) {
return;
}
// Since each platform has their own valid listener annotations,
// some platforms may have multiple allowed annotations for various cases
final Collection<AbstractModuleType<?>> moduleTypes = instance.getTypes();
boolean contains = false;
for (AbstractModuleType<?> moduleType : moduleTypes) {
final List<String> listenerAnnotations = moduleType.getListenerAnnotations();
for (String listenerAnnotation : listenerAnnotations) {
if (modifierList.findAnnotation(listenerAnnotation) != null) {
contains = true;
break;
}
}
}
if (!contains) {
return;
}
final PsiParameter[] parameters = method.getParameterList().getParameters();
if (parameters.length < 1) {
return;
}
final PsiParameter eventParameter = parameters[0];
if (eventParameter == null) {
// Listeners must have at least a single parameter
return;
}
// Get the type of the parameter so we can start resolving it
PsiTypeElement psiEventElement = eventParameter.getTypeElement();
if (psiEventElement == null) {
return;
}
final PsiType type = psiEventElement.getType();
// Validate that it is a class reference type, I don't know if this will work with
// other JVM languages such as Kotlin or Scala, but it might!
if (!(type instanceof PsiClassReferenceType)) {
return;
}
// And again, make sure that we can at least resolve the type, otherwise it's not a valid
// class reference.
final PsiClass eventClass = ((PsiClassReferenceType) type).resolve();
if (eventClass == null) {
return;
}
if (instance.isEventClassValid(eventClass, method)) {
return;
}
if (!instance.isStaticListenerSupported(eventClass, method)
&& method.hasModifierProperty(PsiModifier.STATIC)) {
if (method.getNameIdentifier() != null) {
holder.createErrorAnnotation(
method.getNameIdentifier(), "Event listener method must not be static");
}
}
if (!isSuperEventListenerAllowed(eventClass, method, instance)) {
holder.createErrorAnnotation(
eventParameter, instance.writeErrorMessageForEvent(eventClass, method));
}
}
