@Override
public Map<String, Set<RefEntity>> getOldContent() {
if (myOldProblemElements == null) return null;
final Map<String, Set<RefEntity>> oldContents =
new com.intellij.util.containers.HashMap<String, Set<RefEntity>>();
final Set<RefEntity> elements = myOldProblemElements.keySet();
for (RefEntity element : elements) {
String groupName =
element instanceof RefElement
? element.getRefManager().getGroupName((RefElement) element)
: element.getName();
final Set<RefEntity> collection = myContents.get(groupName);
if (collection != null) {
final Set<RefEntity> currentElements = new HashSet<RefEntity>(collection);
if (RefUtil.contains(element, currentElements)) continue;
}
Set<RefEntity> oldContent = oldContents.get(groupName);
if (oldContent == null) {
oldContent = new HashSet<RefEntity>();
oldContents.put(groupName, oldContent);
}
oldContent.add(element);
}
return oldContents;
}
@Override
public String getQualifiedName(RefEntity refEntity) {
if (refEntity == null || refEntity instanceof RefElementImpl && !refEntity.isValid()) {
return InspectionsBundle.message("inspection.reference.invalid");
}
return refEntity.getQualifiedName();
}
@Override
@Nullable
public String getGroupName(final RefElement entity) {
for (RefManagerExtension extension : myExtensions.values()) {
final String groupName = extension.getGroupName(entity);
if (groupName != null) return groupName;
}
final LinkedList<String> containingDirs = new LinkedList<>();
RefEntity parent = entity.getOwner();
while (parent != null && !(parent instanceof RefDirectory)) {
parent = parent.getOwner();
}
while (parent instanceof RefDirectory) {
containingDirs.addFirst(parent.getName());
parent = parent.getOwner();
}
return containingDirs.isEmpty() ? null : StringUtil.join(containingDirs, File.separator);
}
@Override
public Element export(
@NotNull RefEntity refEntity, @NotNull final Element element, final int actualLine) {
refEntity = getRefinedElement(refEntity);
Element problem = new Element("problem");
if (refEntity instanceof RefElement) {
final RefElement refElement = (RefElement) refEntity;
final SmartPsiElementPointer pointer = refElement.getPointer();
PsiFile psiFile = pointer.getContainingFile();
if (psiFile == null) return null;
Element fileElement = new Element("file");
Element lineElement = new Element("line");
final VirtualFile virtualFile = psiFile.getVirtualFile();
LOG.assertTrue(virtualFile != null);
fileElement.addContent(virtualFile.getUrl());
if (actualLine == -1) {
final Document document =
PsiDocumentManager.getInstance(pointer.getProject()).getDocument(psiFile);
LOG.assertTrue(document != null);
final Segment range = pointer.getRange();
lineElement.addContent(
String.valueOf(
range != null ? document.getLineNumber(range.getStartOffset()) + 1 : -1));
} else {
lineElement.addContent(String.valueOf(actualLine));
}
problem.addContent(fileElement);
problem.addContent(lineElement);
appendModule(problem, refElement.getModule());
} else if (refEntity instanceof RefModule) {
final RefModule refModule = (RefModule) refEntity;
final VirtualFile moduleFile = refModule.getModule().getModuleFile();
final Element fileElement = new Element("file");
fileElement.addContent(moduleFile != null ? moduleFile.getUrl() : refEntity.getName());
problem.addContent(fileElement);
appendModule(problem, refModule);
}
for (RefManagerExtension extension : myExtensions.values()) {
extension.export(refEntity, problem);
}
new SmartRefElementPointerImpl(refEntity, true).writeExternal(problem);
element.addContent(problem);
return problem;
}
@Override
@Nullable
public CommonProblemDescriptor[] getDescriptions(@NotNull RefEntity refEntity) {
final CommonProblemDescriptor[] problems = getProblemElements().get(refEntity);
if (problems == null) return null;
if (!refEntity.isValid()) {
ignoreElement(refEntity);
return null;
}
return problems;
}
@Override
public void updateContent() {
myContents.clear();
myModulesProblems.clear();
final Set<RefEntity> elements = getProblemElements().keySet();
for (RefEntity element : elements) {
if (getContext().getUIOptions().FILTER_RESOLVED_ITEMS
&& getIgnoredElements().containsKey(element)) continue;
if (element instanceof RefModule) {
myModulesProblems.add((RefModule) element);
} else {
String groupName =
element instanceof RefElement
? element.getRefManager().getGroupName((RefElement) element)
: null;
Set<RefEntity> content = myContents.get(groupName);
if (content == null) {
content = new HashSet<RefEntity>();
myContents.put(groupName, content);
}
content.add(element);
}
}
}
private void exportResults(
@NotNull final CommonProblemDescriptor[] descriptors,
@NotNull RefEntity refEntity,
@NotNull Element parentNode) {
for (CommonProblemDescriptor descriptor : descriptors) {
@NonNls final String template = descriptor.getDescriptionTemplate();
int line =
descriptor instanceof ProblemDescriptor
? ((ProblemDescriptor) descriptor).getLineNumber()
: -1;
final PsiElement psiElement =
descriptor instanceof ProblemDescriptor
? ((ProblemDescriptor) descriptor).getPsiElement()
: null;
@NonNls
String problemText =
StringUtil.replace(
StringUtil.replace(
template,
"#ref",
psiElement != null
? ProblemDescriptorUtil.extractHighlightedText(descriptor, psiElement)
: ""),
" #loc ",
" ");
Element element = refEntity.getRefManager().export(refEntity, parentNode, line);
if (element == null) return;
@NonNls
Element problemClassElement =
new Element(InspectionsBundle.message("inspection.export.results.problem.element.tag"));
problemClassElement.addContent(myToolWrapper.getDisplayName());
final HighlightSeverity severity;
if (refEntity instanceof RefElement) {
final RefElement refElement = (RefElement) refEntity;
severity = getSeverity(refElement);
} else {
final InspectionProfile profile =
InspectionProjectProfileManager.getInstance(getContext().getProject())
.getInspectionProfile();
final HighlightDisplayLevel level =
profile.getErrorLevel(
HighlightDisplayKey.find(myToolWrapper.getShortName()), psiElement);
severity = level.getSeverity();
}
if (severity != null) {
ProblemHighlightType problemHighlightType =
descriptor instanceof ProblemDescriptor
? ((ProblemDescriptor) descriptor).getHighlightType()
: ProblemHighlightType.GENERIC_ERROR_OR_WARNING;
final String attributeKey =
getTextAttributeKey(getRefManager().getProject(), severity, problemHighlightType);
problemClassElement.setAttribute("severity", severity.myName);
problemClassElement.setAttribute("attribute_key", attributeKey);
}
element.addContent(problemClassElement);
if (myToolWrapper instanceof GlobalInspectionToolWrapper) {
final GlobalInspectionTool globalInspectionTool =
((GlobalInspectionToolWrapper) myToolWrapper).getTool();
final QuickFix[] fixes = descriptor.getFixes();
if (fixes != null) {
@NonNls Element hintsElement = new Element("hints");
for (QuickFix fix : fixes) {
final String hint = globalInspectionTool.getHint(fix);
if (hint != null) {
@NonNls Element hintElement = new Element("hint");
hintElement.setAttribute("value", hint);
hintsElement.addContent(hintElement);
}
}
element.addContent(hintsElement);
}
}
try {
Element descriptionElement =
new Element(InspectionsBundle.message("inspection.export.results.description.tag"));
descriptionElement.addContent(problemText);
element.addContent(descriptionElement);
} catch (IllegalDataException e) {
//noinspection HardCodedStringLiteral,UseOfSystemOutOrSystemErr
System.out.println(
"Cannot save results for "
+ refEntity.getName()
+ ", inspection which caused problem: "
+ myToolWrapper.getShortName());
}
}
}