@Override
public void beforeDocumentChange(@NotNull DocumentEvent event) {
if (myStopTrackingDocuments) return;
final Document document = event.getDocument();
if (!(document instanceof DocumentWindow) && !myLastCommittedTexts.containsKey(document)) {
myLastCommittedTexts.put(
document,
Pair.create(document.getImmutableCharSequence(), document.getModificationStamp()));
}
VirtualFile virtualFile = FileDocumentManager.getInstance().getFile(document);
boolean isRelevant = virtualFile != null && isRelevant(virtualFile);
final FileViewProvider viewProvider = getCachedViewProvider(document);
boolean inMyProject = viewProvider != null && viewProvider.getManager() == myPsiManager;
if (!isRelevant || !inMyProject) {
return;
}
final List<PsiFile> files = viewProvider.getAllFiles();
PsiFile psiCause = null;
for (PsiFile file : files) {
if (file == null) {
throw new AssertionError(
"View provider "
+ viewProvider
+ " ("
+ viewProvider.getClass()
+ ") returned null in its files array: "
+ files
+ " for file "
+ viewProvider.getVirtualFile());
}
if (mySynchronizer.isInsideAtomicChange(file)) {
psiCause = file;
}
}
if (psiCause == null) {
beforeDocumentChangeOnUnlockedDocument(viewProvider);
}
((SingleRootFileViewProvider) viewProvider).beforeDocumentChanged(psiCause);
}
@Nullable
@Override
public Document getDocument(@NotNull PsiFile file) {
if (file instanceof PsiBinaryFile) return null;
Document document = getCachedDocument(file);
if (document != null) {
if (!file.getViewProvider().isPhysical() && document.getUserData(HARD_REF_TO_PSI) == null) {
PsiUtilCore.ensureValid(file);
cachePsi(document, file);
}
return document;
}
FileViewProvider viewProvider = file.getViewProvider();
if (!viewProvider.isEventSystemEnabled()) return null;
document = FileDocumentManager.getInstance().getDocument(viewProvider.getVirtualFile());
if (document != null) {
if (document.getTextLength() != file.getTextLength()) {
String message =
"Document/PSI mismatch: "
+ file
+ " ("
+ file.getClass()
+ "); physical="
+ viewProvider.isPhysical();
if (document.getTextLength() + file.getTextLength() < 8096) {
message +=
"\n=== document ===\n" + document.getText() + "\n=== PSI ===\n" + file.getText();
}
throw new AssertionError(message);
}
if (!viewProvider.isPhysical()) {
PsiUtilCore.ensureValid(file);
cachePsi(document, file);
file.putUserData(HARD_REF_TO_DOCUMENT, document);
}
}
return document;
}
protected boolean finishCommitInWriteAction(
@NotNull final Document document,
@NotNull final List<Processor<Document>> finishProcessors,
final boolean synchronously) {
if (myProject.isDisposed()) return false;
assert !(document instanceof DocumentWindow);
myIsCommitInProgress = true;
boolean success = true;
try {
final FileViewProvider viewProvider = getCachedViewProvider(document);
if (viewProvider != null) {
for (Processor<Document> finishRunnable : finishProcessors) {
success = finishRunnable.process(document);
if (synchronously) {
assert success : finishRunnable + " in " + finishProcessors;
}
if (!success) {
break;
}
}
if (success) {
myLastCommittedTexts.remove(document);
viewProvider.contentsSynchronized();
}
} else {
handleCommitWithoutPsi(document);
}
} finally {
myDocumentCommitProcessor.log(
"in PDI.finishDoc: ", null, synchronously, success, myUncommittedDocuments);
if (success) {
myUncommittedDocuments.remove(document);
myDocumentCommitProcessor.log(
"in PDI.finishDoc: removed doc", null, synchronously, success, myUncommittedDocuments);
}
myIsCommitInProgress = false;
myDocumentCommitProcessor.log(
"in PDI.finishDoc: exit", null, synchronously, success, myUncommittedDocuments);
}
return success;
}
@Override
public void documentChanged(DocumentEvent event) {
if (myStopTrackingDocuments) return;
final Document document = event.getDocument();
VirtualFile virtualFile = FileDocumentManager.getInstance().getFile(document);
boolean isRelevant = virtualFile != null && isRelevant(virtualFile);
final FileViewProvider viewProvider = getCachedViewProvider(document);
if (viewProvider == null) {
handleCommitWithoutPsi(document);
return;
}
boolean inMyProject = viewProvider.getManager() == myPsiManager;
if (!isRelevant || !inMyProject) {
myLastCommittedTexts.remove(document);
return;
}
ApplicationManager.getApplication().assertWriteAccessAllowed();
final List<PsiFile> files = viewProvider.getAllFiles();
boolean commitNecessary = true;
for (PsiFile file : files) {
if (mySynchronizer.isInsideAtomicChange(file)) {
commitNecessary = false;
continue;
}
assert file instanceof PsiFileImpl
|| "mock.file".equals(file.getName())
&& ApplicationManager.getApplication().isUnitTestMode()
: event + "; file=" + file + "; allFiles=" + files + "; viewProvider=" + viewProvider;
}
boolean forceCommit =
ApplicationManager.getApplication().hasWriteAction(ExternalChangeAction.class)
&& (SystemProperties.getBooleanProperty("idea.force.commit.on.external.change", false)
|| ApplicationManager.getApplication().isHeadlessEnvironment()
&& !ApplicationManager.getApplication().isUnitTestMode());
// Consider that it's worth to perform complete re-parse instead of merge if the whole document
// text is replaced and
// current document lines number is roughly above 5000. This makes sense in situations when
// external change is performed
// for the huge file (that causes the whole document to be reloaded and 'merge' way takes a
// while to complete).
if (event.isWholeTextReplaced() && document.getTextLength() > 100000) {
document.putUserData(BlockSupport.DO_NOT_REPARSE_INCREMENTALLY, Boolean.TRUE);
}
if (commitNecessary) {
assert !(document instanceof DocumentWindow);
myUncommittedDocuments.add(document);
myDocumentCommitProcessor.log(
"added uncommitted doc",
null,
false,
myProject,
document,
((DocumentEx) document).isInBulkUpdate());
if (forceCommit) {
commitDocument(document);
} else if (!((DocumentEx) document).isInBulkUpdate() && myPerformBackgroundCommit) {
myDocumentCommitProcessor.commitAsynchronously(myProject, document, event);
}
} else {
myLastCommittedTexts.remove(document);
}
}