@Override
public void annotateExternally(
@NotNull final PsiModifierListOwner listOwner,
@NotNull final String annotationFQName,
@NotNull final PsiFile fromFile,
final PsiNameValuePair[] value) {
final Project project = myPsiManager.getProject();
final PsiFile containingFile = listOwner.getContainingFile();
if (!(containingFile instanceof PsiJavaFile)) {
return;
}
final String packageName = ((PsiJavaFile) containingFile).getPackageName();
final VirtualFile virtualFile = containingFile.getVirtualFile();
LOG.assertTrue(virtualFile != null);
final List<OrderEntry> entries =
ProjectRootManager.getInstance(project).getFileIndex().getOrderEntriesForFile(virtualFile);
if (entries.isEmpty()) {
return;
}
for (final OrderEntry entry : entries) {
if (entry instanceof ModuleOrderEntry) continue;
VirtualFile[] virtualFiles = AnnotationOrderRootType.getFiles(entry);
virtualFiles = filterByReadOnliness(virtualFiles);
if (virtualFiles.length > 0) {
chooseRootAndAnnotateExternally(
listOwner,
annotationFQName,
fromFile,
project,
packageName,
virtualFile,
virtualFiles,
value);
} else {
if (ApplicationManager.getApplication().isUnitTestMode()
|| ApplicationManager.getApplication().isHeadlessEnvironment()) {
return;
}
SwingUtilities.invokeLater(
new Runnable() {
@Override
public void run() {
setupRootAndAnnotateExternally(
entry,
project,
listOwner,
annotationFQName,
fromFile,
packageName,
virtualFile,
value);
}
});
}
break;
}
}
@Nullable
public VirtualFile findAppDirectory(@Nullable PsiElement element) {
if (element == null) return null;
PsiFile containingFile = element.getContainingFile().getOriginalFile();
VirtualFile file = containingFile.getVirtualFile();
if (file == null) return null;
ProjectFileIndex index =
ProjectRootManager.getInstance(containingFile.getProject()).getFileIndex();
VirtualFile root = index.getContentRootForFile(file);
if (root == null) return null;
return root.findChild(getApplicationDirectoryName());
}
protected static IntentionAction findIntentionAction(
@NotNull Collection<HighlightInfo> infos,
@NotNull String intentionActionName,
@NotNull Editor editor,
@NotNull PsiFile file) {
List<IntentionAction> actions = LightQuickFixTestCase.getAvailableActions(editor, file);
IntentionAction intentionAction =
LightQuickFixTestCase.findActionWithText(actions, intentionActionName);
if (intentionAction == null) {
final List<IntentionAction> availableActions = new ArrayList<IntentionAction>();
for (HighlightInfo info : infos) {
if (info.quickFixActionRanges != null) {
for (Pair<HighlightInfo.IntentionActionDescriptor, TextRange> pair :
info.quickFixActionRanges) {
IntentionAction action = pair.first.getAction();
if (action.isAvailable(file.getProject(), editor, file)) availableActions.add(action);
}
}
}
intentionAction =
LightQuickFixTestCase.findActionWithText(availableActions, intentionActionName);
}
return intentionAction;
}
private void processFileChange(final PsiFile file) {
if (file != null && StdFileTypes.XML.equals(file.getFileType()) && file instanceof XmlFile) {
for (final DomEvent event : recomputeFileElement((XmlFile) file)) {
fireEvent(event);
}
}
}
private static int addToUsages(
@NotNull Document document,
@NotNull Processor<UsageInfo> consumer,
@NotNull FindModel findModel,
@NotNull final PsiFile psiFile,
@NotNull int[] offsetRef,
int maxUsages) {
int count = 0;
CharSequence text = document.getCharsSequence();
int textLength = document.getTextLength();
int offset = offsetRef[0];
Project project = psiFile.getProject();
FindManager findManager = FindManager.getInstance(project);
while (offset < textLength) {
FindResult result = findManager.findString(text, offset, findModel, psiFile.getVirtualFile());
if (!result.isStringFound()) break;
final SearchScope customScope = findModel.getCustomScope();
if (customScope instanceof LocalSearchScope) {
final TextRange range = new TextRange(result.getStartOffset(), result.getEndOffset());
if (!((LocalSearchScope) customScope).containsRange(psiFile, range)) break;
}
UsageInfo info = new FindResultUsageInfo(findManager, psiFile, offset, findModel, result);
if (!consumer.process(info)) {
throw new ProcessCanceledException();
}
count++;
final int prevOffset = offset;
offset = result.getEndOffset();
if (prevOffset == offset) {
// for regular expr the size of the match could be zero -> could be infinite loop in finding
// usages!
++offset;
}
if (maxUsages > 0 && count >= maxUsages) {
break;
}
}
offsetRef[0] = offset;
return count;
}
// returns number of hits
static int processUsagesInFile(
@NotNull final PsiFile psiFile,
@NotNull final FindModel findModel,
@NotNull final Processor<UsageInfo> consumer) {
if (findModel.getStringToFind().isEmpty()) {
if (!ApplicationManager.getApplication()
.runReadAction((Computable<Boolean>) () -> consumer.process(new UsageInfo(psiFile)))) {
throw new ProcessCanceledException();
}
return 1;
}
final VirtualFile virtualFile = psiFile.getVirtualFile();
if (virtualFile == null) return 0;
if (virtualFile.getFileType().isBinary()) return 0; // do not decompile .class files
final Document document =
ApplicationManager.getApplication()
.runReadAction(
(Computable<Document>)
() ->
virtualFile.isValid()
? FileDocumentManager.getInstance().getDocument(virtualFile)
: null);
if (document == null) return 0;
final int[] offset = {0};
int count = 0;
int found;
ProgressIndicator indicator =
ProgressWrapper.unwrap(ProgressManager.getInstance().getProgressIndicator());
TooManyUsagesStatus tooManyUsagesStatus = TooManyUsagesStatus.getFrom(indicator);
do {
tooManyUsagesStatus.pauseProcessingIfTooManyUsages(); // wait for user out of read action
found =
ApplicationManager.getApplication()
.runReadAction(
(Computable<Integer>)
() -> {
if (!psiFile.isValid()) return 0;
return addToUsages(
document, consumer, findModel, psiFile, offset, USAGES_PER_READ_ACTION);
});
count += found;
} while (found != 0);
return count;
}
private static List<PsiElement> getTopLevelRegExpChars(String regExpText, Project project) {
@SuppressWarnings("deprecation")
PsiFile file = PsiFileFactory.getInstance(project).createFileFromText("A.regexp", regExpText);
List<PsiElement> result = null;
final PsiElement[] children = file.getChildren();
for (PsiElement child : children) {
PsiElement[] grandChildren = child.getChildren();
if (grandChildren.length != 1)
return Collections
.emptyList(); // a | b, more than one branch, can not predict in current way
for (PsiElement grandGrandChild : grandChildren[0].getChildren()) {
if (result == null) result = new ArrayList<>();
result.add(grandGrandChild);
}
}
return result != null ? result : Collections.<PsiElement>emptyList();
}
public static void addAvailableSystemScripts(
final Collection<String> result, @NotNull Module module) {
VirtualFile scriptRoot = null;
GlobalSearchScope searchScope =
GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(module, false);
for (PsiClass aClass :
JavaPsiFacade.getInstance(module.getProject()).findClasses("CreateApp_", searchScope)) {
PsiClass superClass = aClass.getSuperClass();
if (superClass != null
&& GroovyCommonClassNames.GROOVY_LANG_SCRIPT.equals(superClass.getQualifiedName())) {
PsiFile psiFile = aClass.getContainingFile();
if (psiFile != null) {
VirtualFile file = psiFile.getVirtualFile();
if (file != null && file.getFileSystem() instanceof ArchiveFileSystem) {
VirtualFile parent = file.getParent();
if (parent != null && parent.findChild("Console.class") != null) {
scriptRoot = parent;
break;
}
}
}
}
}
if (scriptRoot == null) return;
Pattern scriptPattern = Pattern.compile("([A-Za-z0-9]+)_?\\.class");
for (VirtualFile file : scriptRoot.getChildren()) {
Matcher matcher = scriptPattern.matcher(file.getName());
if (matcher.matches()) {
result.add(GroovyNamesUtil.camelToSnake(matcher.group(1)));
}
}
}
private static void addIdAndSuperClasses(PsiFile file, @NotNull TIntHashSet forward) {
if (file instanceof PsiJavaFile
&& file.getName().equals("Object.class")
&& ((PsiJavaFile) file).getPackageName().equals("java.lang")) {
return;
}
VirtualFile virtualFile = PsiUtilCore.getVirtualFile(file);
if (virtualFile instanceof VirtualFileWithId
&& forward.add(getAbsId(virtualFile))
&& file instanceof PsiClassOwner) {
for (PsiClass aClass : ((PsiClassOwner) file).getClasses()) {
for (PsiClass superClass : aClass.getSupers()) {
addIdAndSuperClasses(superClass.getContainingFile(), forward);
}
}
}
}
private void annotateExternally(
@NotNull PsiModifierListOwner listOwner,
@NotNull String annotationFQName,
@Nullable final XmlFile xmlFile,
@NotNull PsiFile codeUsageFile,
PsiNameValuePair[] values) {
if (xmlFile == null) return;
try {
final XmlDocument document = xmlFile.getDocument();
if (document != null) {
final XmlTag rootTag = document.getRootTag();
final String externalName = getExternalName(listOwner, false);
if (rootTag != null) {
for (XmlTag tag : rootTag.getSubTags()) {
if (Comparing.strEqual(
StringUtil.unescapeXml(tag.getAttributeValue("name")), externalName)) {
for (XmlTag annTag : tag.getSubTags()) {
if (Comparing.strEqual(annTag.getAttributeValue("name"), annotationFQName)) {
annTag.delete();
break;
}
}
tag.add(
XmlElementFactory.getInstance(myPsiManager.getProject())
.createTagFromText(createAnnotationTag(annotationFQName, values)));
return;
}
}
@NonNls String text = "<item name=\'" + StringUtil.escapeXml(externalName) + "\'>\n";
text += createAnnotationTag(annotationFQName, values);
text += "</item>";
rootTag.add(
XmlElementFactory.getInstance(myPsiManager.getProject()).createTagFromText(text));
}
}
} catch (IncorrectOperationException e) {
LOG.error(e);
} finally {
dropCache();
if (codeUsageFile.getVirtualFile().isInLocalFileSystem()) {
UndoUtil.markPsiFileForUndo(codeUsageFile);
}
}
}
@Override
@NotNull
public AnnotationPlace chooseAnnotationsPlace(@NotNull final PsiElement element) {
if (!element.isPhysical()) return AnnotationPlace.IN_CODE; // element just created
if (!element.getManager().isInProject(element)) return AnnotationPlace.EXTERNAL;
final Project project = myPsiManager.getProject();
final PsiFile containingFile = element.getContainingFile();
final VirtualFile virtualFile = containingFile.getVirtualFile();
LOG.assertTrue(virtualFile != null);
final List<OrderEntry> entries =
ProjectRootManager.getInstance(project).getFileIndex().getOrderEntriesForFile(virtualFile);
if (!entries.isEmpty()) {
for (OrderEntry entry : entries) {
if (!(entry instanceof ModuleOrderEntry)) {
if (AnnotationOrderRootType.getUrls(entry).length > 0) {
return AnnotationPlace.EXTERNAL;
}
break;
}
}
}
final MyExternalPromptDialog dialog =
ApplicationManager.getApplication().isUnitTestMode()
|| ApplicationManager.getApplication().isHeadlessEnvironment()
? null
: new MyExternalPromptDialog(project);
if (dialog != null && dialog.isToBeShown()) {
final PsiElement highlightElement =
element instanceof PsiNameIdentifierOwner
? ((PsiNameIdentifierOwner) element).getNameIdentifier()
: element.getNavigationElement();
LOG.assertTrue(highlightElement != null);
final Editor editor = FileEditorManager.getInstance(project).getSelectedTextEditor();
final List<RangeHighlighter> highlighters = new ArrayList<RangeHighlighter>();
final boolean highlight =
editor != null
&& editor.getDocument()
== PsiDocumentManager.getInstance(project).getDocument(containingFile);
try {
if (highlight) { // do not highlight for batch inspections
final EditorColorsManager colorsManager = EditorColorsManager.getInstance();
final TextAttributes attributes =
colorsManager.getGlobalScheme().getAttributes(EditorColors.SEARCH_RESULT_ATTRIBUTES);
final TextRange textRange = highlightElement.getTextRange();
HighlightManager.getInstance(project)
.addRangeHighlight(
editor,
textRange.getStartOffset(),
textRange.getEndOffset(),
attributes,
true,
highlighters);
final LogicalPosition logicalPosition =
editor.offsetToLogicalPosition(textRange.getStartOffset());
editor.getScrollingModel().scrollTo(logicalPosition, ScrollType.CENTER);
}
dialog.show();
if (dialog.getExitCode() == 2) {
return AnnotationPlace.EXTERNAL;
} else if (dialog.getExitCode() == 1) {
return AnnotationPlace.NOWHERE;
}
} finally {
if (highlight) {
HighlightManager.getInstance(project)
.removeSegmentHighlighter(editor, highlighters.get(0));
}
}
} else if (dialog != null) {
dialog.close(DialogWrapper.OK_EXIT_CODE);
}
return AnnotationPlace.IN_CODE;
}
// When file is renamed so that extension changes then language dialect might change and thus
// psiFile should be invalidated
private static boolean languageDialectChanged(final PsiFile newPsiFile, String oldFileName) {
return newPsiFile != null
&& !FileUtilRt.extensionEquals(oldFileName, FileUtilRt.getExtension(newPsiFile.getName()));
}