private static int getNewIndent(final PsiFile psiFile, final int firstWhitespace) {
final Document document = psiFile.getViewProvider().getDocument();
final int startOffset = document.getLineStartOffset(document.getLineNumber(firstWhitespace));
int endOffset = startOffset;
final CharSequence charsSequence = document.getCharsSequence();
while (Character.isWhitespace(charsSequence.charAt(endOffset++))) ;
final String newIndentStr = charsSequence.subSequence(startOffset, endOffset - 1).toString();
return IndentHelperImpl.getIndent(
psiFile.getProject(), psiFile.getFileType(), newIndentStr, true);
}
private static void highlightTodos(
@NotNull PsiFile file,
@NotNull CharSequence text,
int startOffset,
int endOffset,
@NotNull ProgressIndicator progress,
@NotNull ProperTextRange priorityRange,
@NotNull Collection<HighlightInfo> result,
@NotNull Collection<HighlightInfo> outsideResult) {
PsiSearchHelper helper = PsiSearchHelper.SERVICE.getInstance(file.getProject());
TodoItem[] todoItems = helper.findTodoItems(file, startOffset, endOffset);
if (todoItems.length == 0) return;
for (TodoItem todoItem : todoItems) {
progress.checkCanceled();
TextRange range = todoItem.getTextRange();
String description =
text.subSequence(range.getStartOffset(), range.getEndOffset()).toString();
TextAttributes attributes = todoItem.getPattern().getAttributes().getTextAttributes();
HighlightInfo info =
HighlightInfo.createHighlightInfo(
HighlightInfoType.TODO, range, description, description, attributes);
assert info != null;
if (priorityRange.containsRange(info.getStartOffset(), info.getEndOffset())) {
result.add(info);
} else {
outsideResult.add(info);
}
}
}
private static void adjustIndentationInRange(
final PsiFile file,
final Document document,
final TextRange[] indents,
final int indentAdjustment) {
final CharSequence charsSequence = document.getCharsSequence();
for (final TextRange indent : indents) {
final String oldIndentStr =
charsSequence.subSequence(indent.getStartOffset() + 1, indent.getEndOffset()).toString();
final int oldIndent =
IndentHelperImpl.getIndent(file.getProject(), file.getFileType(), oldIndentStr, true);
final String newIndentStr =
IndentHelperImpl.fillIndent(
file.getProject(), file.getFileType(), Math.max(oldIndent + indentAdjustment, 0));
document.replaceString(indent.getStartOffset() + 1, indent.getEndOffset(), newIndentStr);
}
}
public static RangeMarker insertTemporary(
final int endOffset, final Document document, final String temporary) {
final CharSequence chars = document.getCharsSequence();
final int length = chars.length();
final RangeMarker toDelete;
if (endOffset < length && Character.isJavaIdentifierPart(chars.charAt(endOffset))) {
document.insertString(endOffset, temporary);
toDelete = document.createRangeMarker(endOffset, endOffset + 1);
} else if (endOffset >= length) {
toDelete = document.createRangeMarker(length, length);
} else {
toDelete = document.createRangeMarker(endOffset, endOffset);
}
toDelete.setGreedyToLeft(true);
toDelete.setGreedyToRight(true);
return toDelete;
}
@Override
public void setText(@NotNull CharSequence text) {
String s = StringUtil.convertLineSeparators(text.toString());
myChars = new char[s.length()];
s.getChars(0, s.length(), myChars, 0);
myString = new String(myChars);
myLineSet = LineSet.createLineSet(myString);
}
@Override
public void setText(@NotNull CharSequence text) {
synchronized (myLock) {
LOG.assertTrue(text.toString().startsWith(myShreds.get(0).getPrefix()));
LOG.assertTrue(text.toString().endsWith(myShreds.get(myShreds.size() - 1).getSuffix()));
if (isOneLine()) {
text = StringUtil.replace(text.toString(), "\n", "");
}
String[] changes = calculateMinEditSequence(text.toString());
assert changes.length == myShreds.size();
for (int i = 0; i < changes.length; i++) {
String change = changes[i];
if (change != null) {
Segment hostRange = myShreds.get(i).getHostRangeMarker();
if (hostRange == null) continue;
myDelegate.replaceString(hostRange.getStartOffset(), hostRange.getEndOffset(), change);
}
}
}
}
@Override
public void replaceString(int startOffset, int endOffset, @NotNull CharSequence s) {
if (isOneLine()) {
s = StringUtil.replace(s.toString(), "\n", "");
}
final CharSequence chars = getCharsSequence();
CharSequence toDelete = chars.subSequence(startOffset, endOffset);
int perfixLength = StringUtil.commonPrefixLength(s, toDelete);
int suffixLength =
StringUtil.commonSuffixLength(
toDelete.subSequence(perfixLength, toDelete.length()),
s.subSequence(perfixLength, s.length()));
startOffset += perfixLength;
endOffset -= suffixLength;
s = s.subSequence(perfixLength, s.length() - suffixLength);
doReplaceString(startOffset, endOffset, s);
}
@Override
public int getLineNumber(int offset) {
int lineNumber = 0;
String hostText = myDelegate.getText();
synchronized (myLock) {
for (PsiLanguageInjectionHost.Shred shred : myShreds) {
String prefix = shred.getPrefix();
String suffix = shred.getSuffix();
lineNumber +=
StringUtil.getLineBreakCount(prefix.substring(0, Math.min(offset, prefix.length())));
if (offset < prefix.length()) {
return lineNumber;
}
offset -= prefix.length();
Segment currentRange = shred.getHostRangeMarker();
if (currentRange == null) continue;
int rangeLength = currentRange.getEndOffset() - currentRange.getStartOffset();
CharSequence rangeText =
hostText.subSequence(currentRange.getStartOffset(), currentRange.getEndOffset());
lineNumber +=
StringUtil.getLineBreakCount(rangeText.subSequence(0, Math.min(offset, rangeLength)));
if (offset < rangeLength) {
return lineNumber;
}
offset -= rangeLength;
lineNumber +=
StringUtil.getLineBreakCount(suffix.substring(0, Math.min(offset, suffix.length())));
if (offset < suffix.length()) {
return lineNumber;
}
offset -= suffix.length();
}
}
lineNumber = getLineCount() - 1;
return lineNumber < 0 ? 0 : lineNumber;
}
private void doReplaceString(int startOffset, int endOffset, CharSequence s) {
assert intersectWithEditable(new TextRange(startOffset, startOffset)) != null;
assert intersectWithEditable(new TextRange(endOffset, endOffset)) != null;
List<Pair<TextRange, CharSequence>> hostRangesToModify;
synchronized (myLock) {
hostRangesToModify = new ArrayList<Pair<TextRange, CharSequence>>(myShreds.size());
int offset = startOffset;
int curRangeStart = 0;
for (int i = 0; i < myShreds.size(); i++) {
PsiLanguageInjectionHost.Shred shred = myShreds.get(i);
curRangeStart += shred.getPrefix().length();
if (offset < curRangeStart) offset = curRangeStart;
Segment hostRange = shred.getHostRangeMarker();
if (hostRange == null) continue;
int hostRangeLength = hostRange.getEndOffset() - hostRange.getStartOffset();
TextRange range = TextRange.from(curRangeStart, hostRangeLength);
if (range.contains(offset)
|| range.getEndOffset() == offset /* in case of inserting at the end*/) {
TextRange rangeToModify =
new TextRange(offset, Math.min(range.getEndOffset(), endOffset));
TextRange hostRangeToModify =
rangeToModify.shiftRight(hostRange.getStartOffset() - curRangeStart);
CharSequence toReplace =
i == myShreds.size() - 1
|| range.getEndOffset() + shred.getSuffix().length() >= endOffset
? s
: s.subSequence(0, Math.min(hostRangeToModify.getLength(), s.length()));
s = toReplace == s ? "" : s.subSequence(toReplace.length(), s.length());
hostRangesToModify.add(Pair.create(hostRangeToModify, toReplace));
offset = rangeToModify.getEndOffset();
}
curRangeStart += hostRangeLength;
curRangeStart += shred.getSuffix().length();
if (curRangeStart > endOffset) break;
}
}
int delta = 0;
for (Pair<TextRange, CharSequence> pair : hostRangesToModify) {
TextRange hostRange = pair.getFirst();
CharSequence replace = pair.getSecond();
myDelegate.replaceString(
hostRange.getStartOffset() + delta, hostRange.getEndOffset() + delta, replace);
delta -= hostRange.getLength() - replace.length();
}
}
@Override
public void insertString(final int offset, @NotNull CharSequence s) {
synchronized (myLock) {
LOG.assertTrue(offset >= myShreds.get(0).getPrefix().length(), myShreds.get(0).getPrefix());
LOG.assertTrue(
offset <= getTextLength() - myShreds.get(myShreds.size() - 1).getSuffix().length(),
myShreds.get(myShreds.size() - 1).getSuffix());
}
if (isOneLine()) {
s = StringUtil.replace(s.toString(), "\n", "");
}
myDelegate.insertString(injectedToHost(offset), s);
}
// returns startOffset found, or -1 if need to continue searching
private static int countNewLinesIn(CharSequence text, int[] pos, int line) {
int offsetInside = 0;
for (int i = StringUtil.indexOf(text, '\n');
i != -1;
i = StringUtil.indexOf(text, '\n', offsetInside)) {
int curLine = ++pos[0];
int lineLength = i + 1 - offsetInside;
int offset = pos[1] += lineLength;
offsetInside += lineLength;
if (curLine == line) return offset;
}
pos[1] += text.length() - offsetInside;
return -1;
}
public static boolean checkConsistency(@NotNull PsiFile psiFile, @NotNull Document document) {
// todo hack
if (psiFile.getVirtualFile() == null) return true;
CharSequence editorText = document.getCharsSequence();
int documentLength = document.getTextLength();
if (psiFile.textMatches(editorText)) {
LOG.assertTrue(psiFile.getTextLength() == documentLength);
return true;
}
char[] fileText = psiFile.textToCharArray();
@SuppressWarnings("NonConstantStringShouldBeStringBuffer")
@NonNls
String error =
"File '"
+ psiFile.getName()
+ "' text mismatch after reparse. "
+ "File length="
+ fileText.length
+ "; Doc length="
+ documentLength
+ "\n";
int i = 0;
for (; i < documentLength; i++) {
if (i >= fileText.length) {
error += "editorText.length > psiText.length i=" + i + "\n";
break;
}
if (i >= editorText.length()) {
error += "editorText.length > psiText.length i=" + i + "\n";
break;
}
if (editorText.charAt(i) != fileText[i]) {
error += "first unequal char i=" + i + "\n";
break;
}
}
// error += "*********************************************" + "\n";
// if (i <= 500){
// error += "Equal part:" + editorText.subSequence(0, i) + "\n";
// }
// else{
// error += "Equal part start:\n" + editorText.subSequence(0, 200) + "\n";
// error += "................................................" + "\n";
// error += "................................................" + "\n";
// error += "................................................" + "\n";
// error += "Equal part end:\n" + editorText.subSequence(i - 200, i) + "\n";
// }
error += "*********************************************" + "\n";
error +=
"Editor Text tail:("
+ (documentLength - i)
+ ")\n"; // + editorText.subSequence(i, Math.min(i + 300, documentLength)) + "\n";
error += "*********************************************" + "\n";
error += "Psi Text tail:(" + (fileText.length - i) + ")\n";
error += "*********************************************" + "\n";
if (document instanceof DocumentWindow) {
error += "doc: '" + document.getText() + "'\n";
error += "psi: '" + psiFile.getText() + "'\n";
error += "ast: '" + psiFile.getNode().getText() + "'\n";
error += psiFile.getLanguage() + "\n";
PsiElement context =
InjectedLanguageManager.getInstance(psiFile.getProject()).getInjectionHost(psiFile);
if (context != null) {
error += "context: " + context + "; text: '" + context.getText() + "'\n";
error += "context file: " + context.getContainingFile() + "\n";
}
error +=
"document window ranges: "
+ Arrays.asList(((DocumentWindow) document).getHostRanges())
+ "\n";
}
LOG.error(error);
// document.replaceString(0, documentLength, psiFile.getText());
return false;
}