@Bombed(user = "******", year = 2014, month = Calendar.JANUARY, day = 21)
public void testAsyncRefresh() throws Throwable {
final File tempDir = createTempDirectory();
final Throwable[] ex = {null};
boolean success =
JobLauncher.getInstance()
.invokeConcurrentlyUnderProgress(
Arrays.asList(new Object[8]),
ProgressManager.getInstance().getProgressIndicator(),
true,
new Processor<Object>() {
@Override
public boolean process(Object o) {
try {
doAsyncRefreshTest(tempDir);
} catch (Throwable t) {
ex[0] = t;
}
return true;
}
});
if (ex[0] != null) throw ex[0];
if (!success) fail("!success");
}
private void submit(@NotNull ScheduledPass pass) {
if (!pass.myUpdateProgress.isCanceled()) {
Job<Void> job =
JobLauncher.getInstance()
.submitToJobThread(
pass,
future -> {
try {
if (!future.isCancelled()) { // for canceled task .get() generates
// CancellationException which is expensive
future.get();
}
} catch (CancellationException | InterruptedException ignored) {
} catch (ExecutionException e) {
LOG.error(e.getCause());
}
});
mySubmittedPasses.put(pass, job);
}
}
public void testAsyncRefresh() throws Throwable {
final Throwable[] ex = {null};
boolean success =
JobLauncher.getInstance()
.invokeConcurrentlyUnderProgress(
Arrays.asList(new Object[8]),
ProgressManager.getInstance().getProgressIndicator(),
true,
new Processor<Object>() {
@Override
public boolean process(Object o) {
try {
doAsyncRefreshTest();
} catch (Throwable t) {
ex[0] = t;
}
return true;
}
});
if (ex[0] != null) throw ex[0];
if (!success) System.out.println("!success");
}
// returns false if canceled
private boolean addInjectedPsiHighlights(
@NotNull final Set<PsiFile> injectedFiles,
@NotNull final ProgressIndicator progress,
@NotNull final Collection<HighlightInfo> outInfos) {
if (injectedFiles.isEmpty()) return true;
final InjectedLanguageManager injectedLanguageManager =
InjectedLanguageManager.getInstance(myProject);
final TextAttributes injectedAttributes =
myGlobalScheme.getAttributes(EditorColors.INJECTED_LANGUAGE_FRAGMENT);
return JobLauncher.getInstance()
.invokeConcurrentlyUnderProgress(
new ArrayList<PsiFile>(injectedFiles),
progress,
isFailFastOnAcquireReadAction(),
new Processor<PsiFile>() {
@Override
public boolean process(final PsiFile injectedPsi) {
return addInjectedPsiHighlights(
injectedPsi, injectedAttributes, outInfos, progress, injectedLanguageManager);
}
});
}
@NotNull
private Set<PsiFile> getInjectedPsiFiles(
@NotNull final List<PsiElement> elements1,
@NotNull final List<PsiElement> elements2,
@NotNull final ProgressIndicator progress) {
ApplicationManager.getApplication().assertReadAccessAllowed();
final Set<PsiFile> outInjected = new THashSet<PsiFile>();
List<DocumentWindow> injected = InjectedLanguageUtil.getCachedInjectedDocuments(myFile);
final Collection<PsiElement> hosts =
new THashSet<PsiElement>(elements1.size() + elements2.size() + injected.size());
// rehighlight all injected PSI regardless the range,
// since change in one place can lead to invalidation of injected PSI in (completely) other
// place.
for (DocumentWindow documentRange : injected) {
progress.checkCanceled();
if (!documentRange.isValid()) continue;
PsiFile file = PsiDocumentManager.getInstance(myProject).getPsiFile(documentRange);
if (file == null) continue;
PsiElement context =
InjectedLanguageManager.getInstance(file.getProject()).getInjectionHost(file);
if (context != null
&& context.isValid()
&& !file.getProject().isDisposed()
&& (myUpdateAll || myRestrictRange.intersects(context.getTextRange()))) {
hosts.add(context);
}
}
InjectedLanguageManagerImpl injectedLanguageManager =
InjectedLanguageManagerImpl.getInstanceImpl(myProject);
Processor<PsiElement> collectInjectableProcessor =
new CommonProcessors.CollectProcessor<PsiElement>(hosts);
injectedLanguageManager.processInjectableElements(elements1, collectInjectableProcessor);
injectedLanguageManager.processInjectableElements(elements2, collectInjectableProcessor);
final PsiLanguageInjectionHost.InjectedPsiVisitor visitor =
new PsiLanguageInjectionHost.InjectedPsiVisitor() {
@Override
public void visit(
@NotNull PsiFile injectedPsi, @NotNull List<PsiLanguageInjectionHost.Shred> places) {
synchronized (outInjected) {
outInjected.add(injectedPsi);
}
}
};
if (!JobLauncher.getInstance()
.invokeConcurrentlyUnderProgress(
new ArrayList<PsiElement>(hosts),
progress,
true,
new Processor<PsiElement>() {
@Override
public boolean process(PsiElement element) {
ApplicationManager.getApplication().assertReadAccessAllowed();
progress.checkCanceled();
InjectedLanguageUtil.enumerate(element, myFile, false, visitor);
return true;
}
})) {
throw new ProcessCanceledException();
}
synchronized (outInjected) {
return outInjected;
}
}
public void startRunInjectors(@NotNull final Document hostDocument, final boolean synchronously) {
if (myProject.isDisposed()) return;
if (!synchronously && ApplicationManager.getApplication().isWriteAccessAllowed()) return;
// use cached to avoid recreate PSI in alien project
final PsiDocumentManager documentManager = PsiDocumentManager.getInstance(myProject);
final PsiFile hostPsiFile = documentManager.getCachedPsiFile(hostDocument);
if (hostPsiFile == null) return;
final CopyOnWriteArrayList<DocumentWindow> injected =
(CopyOnWriteArrayList<DocumentWindow>)
InjectedLanguageUtil.getCachedInjectedDocuments(hostPsiFile);
if (injected.isEmpty()) return;
if (myProgress.isCanceled()) {
myProgress = new DaemonProgressIndicator();
}
final Processor<DocumentWindow> commitProcessor =
new Processor<DocumentWindow>() {
@Override
public boolean process(DocumentWindow documentWindow) {
if (myProject.isDisposed()) return false;
ProgressIndicator indicator = ProgressManager.getInstance().getProgressIndicator();
if (indicator != null && indicator.isCanceled()) return false;
if (documentManager.isUncommited(hostDocument) || !hostPsiFile.isValid())
return false; // will be committed later
Segment[] ranges = documentWindow.getHostRanges();
Segment rangeMarker = ranges.length > 0 ? ranges[0] : null;
PsiElement element =
rangeMarker == null
? null
: hostPsiFile.findElementAt(rangeMarker.getStartOffset());
if (element == null) {
synchronized (PsiLock.LOCK) {
injected.remove(documentWindow);
}
return true;
}
final DocumentWindow[] stillInjectedDocument = {null};
// it is here where the reparse happens and old file contents replaced
InjectedLanguageUtil.enumerate(
element,
hostPsiFile,
true,
new PsiLanguageInjectionHost.InjectedPsiVisitor() {
@Override
public void visit(
@NotNull PsiFile injectedPsi,
@NotNull List<PsiLanguageInjectionHost.Shred> places) {
stillInjectedDocument[0] =
(DocumentWindow) injectedPsi.getViewProvider().getDocument();
PsiDocumentManagerImpl.checkConsistency(injectedPsi, stillInjectedDocument[0]);
}
});
synchronized (PsiLock.LOCK) {
if (stillInjectedDocument[0] == null) {
injected.remove(documentWindow);
} else if (stillInjectedDocument[0] != documentWindow) {
injected.remove(documentWindow);
injected.addIfAbsent(stillInjectedDocument[0]);
}
}
return true;
}
};
final Runnable commitInjectionsRunnable =
new Runnable() {
@Override
public void run() {
if (myProgress.isCanceled()) return;
JobLauncher.getInstance()
.invokeConcurrentlyUnderProgress(
new ArrayList<DocumentWindow>(injected),
myProgress,
!synchronously,
commitProcessor);
}
};
if (synchronously) {
if (Thread.holdsLock(PsiLock.LOCK)) {
// hack for the case when docCommit was called from within PSI modification, e.g. in
// formatter.
// we can't spawn threads to do injections there, otherwise a deadlock is imminent
ContainerUtil.process(new ArrayList<DocumentWindow>(injected), commitProcessor);
} else {
commitInjectionsRunnable.run();
}
} else {
JobLauncher.getInstance()
.submitToJobThread(
Job.DEFAULT_PRIORITY,
new Runnable() {
@Override
public void run() {
ApplicationManagerEx.getApplicationEx()
.tryRunReadAction(commitInjectionsRunnable);
}
});
}
}
@Override
public void startRunInjectors(@NotNull final Document hostDocument, final boolean synchronously) {
if (myProject.isDisposed()) return;
if (!synchronously && ApplicationManager.getApplication().isWriteAccessAllowed()) return;
// use cached to avoid recreate PSI in alien project
final PsiDocumentManager documentManager = PsiDocumentManager.getInstance(myProject);
final PsiFile hostPsiFile = documentManager.getCachedPsiFile(hostDocument);
if (hostPsiFile == null) return;
final ConcurrentList<DocumentWindow> injected =
InjectedLanguageUtil.getCachedInjectedDocuments(hostPsiFile);
if (injected.isEmpty()) return;
if (myProgress.isCanceled()) {
myProgress = new DaemonProgressIndicator();
}
final Set<DocumentWindow> newDocuments = Collections.synchronizedSet(new THashSet<>());
final Processor<DocumentWindow> commitProcessor =
documentWindow -> {
if (myProject.isDisposed()) return false;
ProgressIndicator indicator = ProgressManager.getInstance().getProgressIndicator();
if (indicator != null && indicator.isCanceled()) return false;
if (documentManager.isUncommited(hostDocument) || !hostPsiFile.isValid())
return false; // will be committed later
// it is here where the reparse happens and old file contents replaced
InjectedLanguageUtil.enumerate(
documentWindow,
hostPsiFile,
(injectedPsi, places) -> {
DocumentWindow newDocument =
(DocumentWindow) injectedPsi.getViewProvider().getDocument();
if (newDocument != null) {
PsiDocumentManagerBase.checkConsistency(injectedPsi, newDocument);
newDocuments.add(newDocument);
}
});
return true;
};
final Runnable commitInjectionsRunnable =
() -> {
if (myProgress.isCanceled()) return;
JobLauncher.getInstance()
.invokeConcurrentlyUnderProgress(
new ArrayList<>(injected), myProgress, true, commitProcessor);
synchronized (ourInjectionPsiLock) {
injected.clear();
injected.addAll(newDocuments);
}
};
if (synchronously) {
if (Thread.holdsLock(PsiLock.LOCK)) {
// hack for the case when docCommit was called from within PSI modification, e.g. in
// formatter.
// we can't spawn threads to do injections there, otherwise a deadlock is imminent
ContainerUtil.process(new ArrayList<>(injected), commitProcessor);
} else {
commitInjectionsRunnable.run();
}
} else {
JobLauncher.getInstance()
.submitToJobThread(
() ->
ApplicationManagerEx.getApplicationEx()
.tryRunReadAction(commitInjectionsRunnable),
null);
}
}