public String[] knownNamespaces() {
final PsiElement parentElement = getParent();
BidirectionalMap<String, String> map = initNamespaceMaps(parentElement);
Set<String> known = Collections.emptySet();
if (map != null) {
known = new HashSet<String>(map.values());
}
if (parentElement instanceof XmlTag) {
if (known.isEmpty()) return ((XmlTag) parentElement).knownNamespaces();
ContainerUtil.addAll(known, ((XmlTag) parentElement).knownNamespaces());
} else {
XmlExtension xmlExtension = XmlExtension.getExtensionByElement(this);
if (xmlExtension != null) {
final XmlFile xmlFile = xmlExtension.getContainingFile(this);
if (xmlFile != null) {
final XmlTag rootTag = xmlFile.getRootTag();
if (rootTag != null && rootTag != this) {
if (known.isEmpty()) return rootTag.knownNamespaces();
ContainerUtil.addAll(known, rootTag.knownNamespaces());
}
}
}
}
return ArrayUtil.toStringArray(known);
}
@Override
@NotNull
public PsiFile[] getPsiRoots() {
final FileViewProvider viewProvider = getViewProvider();
final Set<Language> languages = viewProvider.getLanguages();
final PsiFile[] roots = new PsiFile[languages.size()];
int i = 0;
for (Language language : languages) {
PsiFile psi = viewProvider.getPsi(language);
if (psi == null) {
LOG.error("PSI is null for " + language + "; in file: " + this);
}
roots[i++] = psi;
}
if (roots.length > 1) {
Arrays.sort(roots, FILE_BY_LANGUAGE_ID);
}
return roots;
}
private static void createActionsMap(
final List<ASTNode> astNodes,
final FileViewProvider provider,
final TreeSet<PostprocessFormattingTask> rangesToProcess) {
final Set<ASTNode> nodesToProcess = new HashSet<ASTNode>(astNodes);
final Document document = provider.getDocument();
for (final ASTNode node : astNodes) {
nodesToProcess.remove(node);
final FileElement fileElement = TreeUtil.getFileElement((TreeElement) node);
if (fileElement == null || ((PsiFile) fileElement.getPsi()).getViewProvider() != provider)
continue;
final boolean isGenerated = CodeEditUtil.isNodeGenerated(node);
((TreeElement) node)
.acceptTree(
new RecursiveTreeElementVisitor() {
boolean inGeneratedContext = !isGenerated;
protected boolean visitNode(TreeElement element) {
if (nodesToProcess.contains(element)) return false;
if (CodeEditUtil.isPostponedFormattingDisabled(element)) return false;
final boolean currentNodeGenerated = CodeEditUtil.isNodeGenerated(element);
CodeEditUtil.setNodeGenerated(element, false);
if (currentNodeGenerated && !inGeneratedContext) {
rangesToProcess.add(
new ReformatTask(document.createRangeMarker(element.getTextRange())));
inGeneratedContext = true;
}
if (!currentNodeGenerated && inGeneratedContext) {
if (element.getElementType() == TokenType.WHITE_SPACE) return false;
final int oldIndent = CodeEditUtil.getOldIndentation(element);
LOG.assertTrue(
oldIndent >= 0,
"for not generated items old indentation must be defined: element "
+ element);
rangesToProcess.add(
new ReindentTask(
document.createRangeMarker(element.getTextRange()), oldIndent));
inGeneratedContext = false;
}
return true;
}
@Override
public void visitComposite(CompositeElement composite) {
boolean oldGeneratedContext = inGeneratedContext;
super.visitComposite(composite);
inGeneratedContext = oldGeneratedContext;
}
@Override
public void visitLeaf(LeafElement leaf) {
boolean oldGeneratedContext = inGeneratedContext;
super.visitLeaf(leaf);
inGeneratedContext = oldGeneratedContext;
}
});
CodeEditUtil.enablePostponedFormattingInTree(node);
}
}
private static void createActionsMap(
@NotNull List<ASTNode> astNodes,
@NotNull FileViewProvider provider,
@NotNull final TreeSet<PostprocessFormattingTask> rangesToProcess) {
final Set<ASTNode> nodesToProcess = new HashSet<ASTNode>(astNodes);
final Document document = provider.getDocument();
if (document == null) {
return;
}
for (final ASTNode node : astNodes) {
nodesToProcess.remove(node);
final FileElement fileElement = TreeUtil.getFileElement((TreeElement) node);
if (fileElement == null || ((PsiFile) fileElement.getPsi()).getViewProvider() != provider)
continue;
final boolean isGenerated = CodeEditUtil.isNodeGenerated(node);
((TreeElement) node)
.acceptTree(
new RecursiveTreeElementVisitor() {
boolean inGeneratedContext = !isGenerated;
@Override
protected boolean visitNode(TreeElement element) {
if (nodesToProcess.contains(element)) return false;
final boolean currentNodeGenerated = CodeEditUtil.isNodeGenerated(element);
CodeEditUtil.setNodeGenerated(element, false);
if (currentNodeGenerated && !inGeneratedContext) {
rangesToProcess.add(
new ReformatTask(document.createRangeMarker(element.getTextRange())));
inGeneratedContext = true;
}
if (!currentNodeGenerated && inGeneratedContext) {
if (element.getElementType() == TokenType.WHITE_SPACE) return false;
final int oldIndent = CodeEditUtil.getOldIndentation(element);
CodeEditUtil.setOldIndentation(element, -1);
LOG.assertTrue(
oldIndent >= 0,
"for not generated items old indentation must be defined: element "
+ element);
for (TextRange indentRange : getEnabledRanges(element.getPsi())) {
rangesToProcess.add(
new ReindentTask(document.createRangeMarker(indentRange), oldIndent));
}
inGeneratedContext = false;
}
return true;
}
private Iterable<TextRange> getEnabledRanges(@NotNull PsiElement element) {
List<TextRange> disabledRanges = new ArrayList<TextRange>();
for (DisabledIndentRangesProvider rangesProvider :
DisabledIndentRangesProvider.EP_NAME.getExtensions()) {
Collection<TextRange> providedDisabledRanges =
rangesProvider.getDisabledIndentRanges(element);
if (providedDisabledRanges != null) {
disabledRanges.addAll(providedDisabledRanges);
}
}
return TextRangeUtil.excludeRanges(element.getTextRange(), disabledRanges);
}
@Override
public void visitComposite(CompositeElement composite) {
boolean oldGeneratedContext = inGeneratedContext;
super.visitComposite(composite);
inGeneratedContext = oldGeneratedContext;
}
@Override
public void visitLeaf(LeafElement leaf) {
boolean oldGeneratedContext = inGeneratedContext;
super.visitLeaf(leaf);
inGeneratedContext = oldGeneratedContext;
}
});
}
}
@NotNull
private List<PostponedAction> normalizeAndReorderPostponedActions(
@NotNull Set<PostprocessFormattingTask> rangesToProcess, @NotNull Document document) {
final List<PostprocessFormattingTask> freeFormattingActions =
new ArrayList<PostprocessFormattingTask>();
final List<ReindentTask> indentActions = new ArrayList<ReindentTask>();
PostprocessFormattingTask accumulatedTask = null;
Iterator<PostprocessFormattingTask> iterator = rangesToProcess.iterator();
while (iterator.hasNext()) {
final PostprocessFormattingTask currentTask = iterator.next();
if (accumulatedTask == null) {
accumulatedTask = currentTask;
iterator.remove();
} else if (accumulatedTask.getStartOffset() > currentTask.getEndOffset()
|| accumulatedTask.getStartOffset() == currentTask.getEndOffset()
&& !canStickActionsTogether(accumulatedTask, currentTask)) {
// action can be pushed
if (accumulatedTask instanceof ReindentTask) {
indentActions.add((ReindentTask) accumulatedTask);
} else {
freeFormattingActions.add(accumulatedTask);
}
accumulatedTask = currentTask;
iterator.remove();
} else if (accumulatedTask instanceof ReformatTask && currentTask instanceof ReindentTask) {
// split accumulated reformat range into two
if (accumulatedTask.getStartOffset() < currentTask.getStartOffset()) {
final RangeMarker endOfRange =
document.createRangeMarker(
accumulatedTask.getStartOffset(), currentTask.getStartOffset());
// add heading reformat part
rangesToProcess.add(new ReformatTask(endOfRange));
// and manage heading whitespace because formatter does not edit it in previous action
iterator = rangesToProcess.iterator();
//noinspection StatementWithEmptyBody
while (iterator.next().getRange() != currentTask.getRange()) ;
}
final RangeMarker rangeToProcess =
document.createRangeMarker(currentTask.getEndOffset(), accumulatedTask.getEndOffset());
freeFormattingActions.add(new ReformatWithHeadingWhitespaceTask(rangeToProcess));
accumulatedTask = currentTask;
iterator.remove();
} else {
if (!(accumulatedTask instanceof ReindentTask)) {
iterator.remove();
boolean withLeadingWhitespace =
accumulatedTask instanceof ReformatWithHeadingWhitespaceTask;
if (accumulatedTask instanceof ReformatTask
&& currentTask instanceof ReformatWithHeadingWhitespaceTask
&& accumulatedTask.getStartOffset() == currentTask.getStartOffset()) {
withLeadingWhitespace = true;
} else if (accumulatedTask instanceof ReformatWithHeadingWhitespaceTask
&& currentTask instanceof ReformatTask
&& accumulatedTask.getStartOffset() < currentTask.getStartOffset()) {
withLeadingWhitespace = false;
}
int newStart = Math.min(accumulatedTask.getStartOffset(), currentTask.getStartOffset());
int newEnd = Math.max(accumulatedTask.getEndOffset(), currentTask.getEndOffset());
RangeMarker rangeMarker;
if (accumulatedTask.getStartOffset() == newStart
&& accumulatedTask.getEndOffset() == newEnd) {
rangeMarker = accumulatedTask.getRange();
} else if (currentTask.getStartOffset() == newStart
&& currentTask.getEndOffset() == newEnd) {
rangeMarker = currentTask.getRange();
} else {
rangeMarker = document.createRangeMarker(newStart, newEnd);
}
if (withLeadingWhitespace) {
accumulatedTask = new ReformatWithHeadingWhitespaceTask(rangeMarker);
} else {
accumulatedTask = new ReformatTask(rangeMarker);
}
} else if (currentTask instanceof ReindentTask) {
iterator.remove();
} // TODO[ik]: need to be fixed to correctly process indent inside indent
}
}
if (accumulatedTask != null) {
if (accumulatedTask instanceof ReindentTask) {
indentActions.add((ReindentTask) accumulatedTask);
} else {
freeFormattingActions.add(accumulatedTask);
}
}
final List<PostponedAction> result = new ArrayList<PostponedAction>();
Collections.reverse(freeFormattingActions);
Collections.reverse(indentActions);
if (!freeFormattingActions.isEmpty()) {
FormatTextRanges ranges = new FormatTextRanges();
for (PostprocessFormattingTask action : freeFormattingActions) {
TextRange range = TextRange.create(action);
ranges.add(range, action instanceof ReformatWithHeadingWhitespaceTask);
}
result.add(new ReformatRangesAction(ranges));
}
if (!indentActions.isEmpty()) {
ReindentRangesAction reindentRangesAction = new ReindentRangesAction();
for (ReindentTask action : indentActions) {
reindentRangesAction.add(action.getRange(), action.getOldIndent());
}
result.add(reindentRangesAction);
}
return result;
}
