private void process(BasicBlock bb, TIntArrayList locks) {
int n = bb.size();
int k = locks.size();
for (int i = 0; i < n; i++) {
Quad q = bb.getQuad(i);
Operator op = q.getOperator();
if (op instanceof Monitor) {
if (op instanceof MONITORENTER) {
TIntArrayList locks2 = new TIntArrayList(k + 1);
for (int j = 0; j < k; j++) locks2.add(locks.get(j));
int lIdx = domL.indexOf(q);
assert (lIdx >= 0);
locks2.add(lIdx);
locks = locks2;
k++;
} else {
k--;
TIntArrayList locks2 = new TIntArrayList(k);
for (int j = 0; j < k; j++) locks2.add(locks.get(j));
locks = locks2;
}
} else if (op.isHeapInst() && k > 0) {
int eIdx = domE.indexOf(q);
assert (eIdx >= 0);
add(locks.get(k - 1), eIdx);
}
}
for (Object o : bb.getSuccessors()) {
BasicBlock bb2 = (BasicBlock) o;
if (!visited.contains(bb2)) {
visited.add(bb2);
process(bb2, locks);
}
}
}
private void applyChildrenChangeEvents(VirtualFile parent, List<VFileEvent> events) {
final NewVirtualFileSystem delegate = getDelegate(parent);
TIntArrayList childrenIdsUpdated = new TIntArrayList();
List<VirtualFile> childrenToBeUpdated = new SmartList<VirtualFile>();
assert parent != null && parent != mySuperRoot;
final int parentId = getFileId(parent);
assert parentId != 0;
TIntHashSet parentChildrenIds = new TIntHashSet(FSRecords.list(parentId));
boolean hasRemovedChildren = false;
for (VFileEvent event : events) {
if (event instanceof VFileCreateEvent) {
String name = ((VFileCreateEvent) event).getChildName();
final VirtualFile fake = new FakeVirtualFile(parent, name);
final FileAttributes attributes = delegate.getAttributes(fake);
if (attributes != null) {
final int childId = createAndFillRecord(delegate, fake, parentId, attributes);
assert parent instanceof VirtualDirectoryImpl : parent;
final VirtualDirectoryImpl dir = (VirtualDirectoryImpl) parent;
VirtualFileSystemEntry child = dir.createChild(name, childId, dir.getFileSystem());
childrenToBeUpdated.add(child);
childrenIdsUpdated.add(childId);
parentChildrenIds.add(childId);
}
} else if (event instanceof VFileDeleteEvent) {
VirtualFile file = ((VFileDeleteEvent) event).getFile();
if (!file.exists()) {
LOG.error("Deleting a file, which does not exist: " + file.getPath());
continue;
}
hasRemovedChildren = true;
int id = getFileId(file);
childrenToBeUpdated.add(file);
childrenIdsUpdated.add(-id);
parentChildrenIds.remove(id);
}
}
FSRecords.updateList(parentId, parentChildrenIds.toArray());
if (hasRemovedChildren) clearIdCache();
VirtualDirectoryImpl parentImpl = (VirtualDirectoryImpl) parent;
for (int i = 0, len = childrenIdsUpdated.size(); i < len; ++i) {
final int childId = childrenIdsUpdated.get(i);
final VirtualFile childFile = childrenToBeUpdated.get(i);
if (childId > 0) {
parentImpl.addChild((VirtualFileSystemEntry) childFile);
} else {
FSRecords.deleteRecordRecursively(-childId);
parentImpl.removeChild(childFile);
invalidateSubtree(childFile);
}
}
}
@NotNull
@Override
protected List<HighlightInfo> doHighlighting() {
PsiDocumentManager.getInstance(myProject).commitAllDocuments();
TIntArrayList toIgnore = new TIntArrayList();
toIgnore.add(Pass.EXTERNAL_TOOLS);
toIgnore.add(Pass.LOCAL_INSPECTIONS);
toIgnore.add(Pass.WHOLE_FILE_LOCAL_INSPECTIONS);
toIgnore.add(Pass.POPUP_HINTS);
return CodeInsightTestFixtureImpl.instantiateAndRun(
getFile(), getEditor(), toIgnore.toNativeArray(), false);
}
public static TIntArrayList getPath(GRIBTNode node) {
if (node != null) {
TIntArrayList path = new TIntArrayList();
path.add(node.AS);
GRIBTNode parent = node.parent;
while (parent != root) {
path.add(parent.AS);
parent = parent.parent;
}
return path;
} else {
return new TIntArrayList();
}
}
@Override
public void add(int hash, int cost, @Nullable PsiFragment frag) {
if (!isIndexedFragment(frag, cost, myProfile, myDuplocatorState)) {
return;
}
if (myTracingData != null) myTracingData.record(hash, cost, frag);
TIntArrayList list = myMap.get(hash);
if (list == null) {
myMap.put(hash, list = new TIntArrayList());
}
list.add(frag.getStartOffset());
list.add(0);
}
/** Get/allocate spaceNeeded entries for the designated float-based attribute */
private int getFloatSpace(int attrId, int spaceNeeded) {
int sequence =
AttrDefinitionMgr.getAttrIndex(attrId); // this should be unique across all attributes
if (sequence < indicesPlusOne.size()) {
int indexPlusOne = indicesPlusOne.getQuick(sequence);
if (indexPlusOne > 0) {
Assert.state(
getLength(attrId) == spaceNeeded,
"getLength = "
+ getLength(attrId)
+ ", requested = "
+ spaceNeeded); // dumbo check to ensure not asking for diff size
return indexPlusOne - 1;
}
} else {
padSpace(indicesPlusOne, sequence);
}
// okay, it's not been allocated so ...
int index = nextFloatsIndex;
nextFloatsIndex += spaceNeeded;
indicesPlusOne.set(sequence, index + 1);
// Add to list of attrIds for iterator
Assert.state(attrIds.contains(attrId) == false);
attrIds.add(attrId);
setLength(sequence, spaceNeeded);
syncToStore(); // we sync here as we've modified
return index;
}
private void refreshTable() {
IDevice[] devices = myDetectedDevicesRef.get();
myDisplayedDevices = devices;
final IDevice[] selectedDevices = getSelectedDevices();
final TIntArrayList selectedRows = new TIntArrayList();
for (int i = 0; i < devices.length; i++) {
if (ArrayUtil.indexOf(selectedDevices, devices[i]) >= 0) {
selectedRows.add(i);
}
}
myProcessSelectionFlag = false;
myDeviceTable.setModel(new MyDeviceTableModel(devices));
if (selectedRows.size() == 0 && devices.length > 0) {
myDeviceTable.getSelectionModel().setSelectionInterval(0, 0);
}
for (int selectedRow : selectedRows.toNativeArray()) {
if (selectedRow < devices.length) {
myDeviceTable.getSelectionModel().addSelectionInterval(selectedRow, selectedRow);
}
}
fireSelectedDevicesChanged();
myProcessSelectionFlag = true;
updatePreviouslySelectedSerials();
}
public SelectionData selectTests(String methodName, Edge[] dangerousEdges)
throws MethodNotFoundException {
TestHistory th = thHandler.getTestHistory(methodName);
int maxTestID = th.getHighestTestID();
TIntArrayList testList = new TIntArrayList();
for (int i = 0; i < dangerousEdges.length; i++) {
// int predBlockID = dangerousEdges[i].getPredNodeID();
int succBlockID = dangerousEdges[i].getSuccNodeID();
for (int j = 0; j < maxTestID; j++) {
if (
/*th.query(predBlockID, j) &&*/ th.query(succBlockID, j)) {
testList.add(j + 1);
}
}
}
SelectionData sd = new SelectionData();
if (testList.size() > 0) {
sd.tests = testList.toNativeArray();
} else {
sd.tests = new int[0];
}
return sd;
}
public static boolean checkParametersNumber(
@NotNull List<CandidateInfo> conflicts,
final int argumentsCount,
boolean ignoreIfStaticsProblem) {
boolean atLeastOneMatch = false;
TIntArrayList unmatchedIndices = null;
for (int i = 0; i < conflicts.size(); i++) {
ProgressManager.checkCanceled();
CandidateInfo info = conflicts.get(i);
if (ignoreIfStaticsProblem && !info.isStaticsScopeCorrect()) return true;
if (!(info instanceof MethodCandidateInfo)) continue;
PsiMethod method = ((MethodCandidateInfo) info).getElement();
if (method.isVarArgs()) return true;
if (method.getParameterList().getParametersCount() == argumentsCount) {
// remove all unmatched before
if (unmatchedIndices != null) {
for (int u = unmatchedIndices.size() - 1; u >= 0; u--) {
int index = unmatchedIndices.get(u);
conflicts.remove(index);
i--;
}
unmatchedIndices = null;
}
atLeastOneMatch = true;
} else if (atLeastOneMatch) {
conflicts.remove(i);
i--;
} else {
if (unmatchedIndices == null) unmatchedIndices = new TIntArrayList(conflicts.size() - i);
unmatchedIndices.add(i);
}
}
return atLeastOneMatch;
}
@Override
public boolean setInputFormat(Instances instanceInfo) throws Exception {
TIntArrayList matchingIndices = new TIntArrayList();
for (int i = 0; i < instanceInfo.numAttributes(); i++) {
if (matchClass && i == instanceInfo.classIndex()) {
matchingIndices.add(i);
continue;
}
if (prefix != null && instanceInfo.attribute(i).name().startsWith(prefix)) {
matchingIndices.add(i);
continue;
}
}
super.setAttributeIndicesArray(matchingIndices.toNativeArray());
return super.setInputFormat(instanceInfo);
}
@Override
public TIntArrayList read(final DataInput in) throws IOException {
int size = DataInputOutputUtil.readSINT(in);
if (size == Integer.MAX_VALUE) {
return new TIntArrayList();
} else if (size <= 0) {
TIntArrayList result = new TIntArrayList(1);
result.add(-size);
return result;
} else {
TIntArrayList result = new TIntArrayList(size);
for (int i = 0; i < size; i++) {
result.add(DataInputOutputUtil.readINT(in));
}
return result;
}
}
protected TIntArrayList getParametersToRemove() {
TIntArrayList parameters = new TIntArrayList();
for (int i = 0; i < myParametersToRemoveChecked.length; i++) {
if (myParametersToRemoveChecked[i]) {
parameters.add(i);
}
}
return parameters;
}
private TIntArrayList getParametersToRemove() {
TIntArrayList list = new TIntArrayList();
for (Object o : toRemoveCBs.keys()) {
if (((JCheckBox) o).isSelected()) {
list.add(toRemoveCBs.get((JCheckBox) o));
}
}
return list;
}
@Nullable
private VirtualFileSystemEntry findFileById(
int id, boolean cachedOnly, TIntArrayList visited, int mask) {
VirtualFileSystemEntry cached = myIdToDirCache.get(id);
if (cached != null) return cached;
if (visited != null
&& (visited.size() >= DEPTH_LIMIT || (mask & id) == id && visited.contains(id))) {
@NonNls
String sb =
"Dead loop detected in persistent FS (id=" + id + " cached-only=" + cachedOnly + "):";
for (int i = 0; i < visited.size(); i++) {
int _id = visited.get(i);
sb +=
"\n "
+ _id
+ " '"
+ getName(_id)
+ "' "
+ String.format("%02x", getFileAttributes(_id))
+ ' '
+ myIdToDirCache.containsKey(_id);
}
LOG.error(sb);
return null;
}
int parentId = getParent(id);
if (parentId >= id) {
if (visited == null) visited = new TIntArrayList(DEPTH_LIMIT);
}
if (visited != null) visited.add(id);
VirtualFileSystemEntry result;
if (parentId == 0) {
myRootsLock.readLock().lock();
try {
result = myRootsById.get(id);
} finally {
myRootsLock.readLock().unlock();
}
} else {
VirtualFileSystemEntry parentFile = findFileById(parentId, cachedOnly, visited, mask | id);
if (parentFile instanceof VirtualDirectoryImpl) {
result = ((VirtualDirectoryImpl) parentFile).findChildById(id, cachedOnly);
} else {
result = null;
}
}
if (result != null && result.isDirectory()) {
VirtualFileSystemEntry old = myIdToDirCache.put(id, result);
if (old != null) result = old;
}
return result;
}
/** Helper method to represent an Attribute as a single-element vector. */
private int[] toValueIndexArray(Attribute attribute) {
TIntArrayList out = new TIntArrayList();
for (String value : values) {
int valueIndex = attribute.indexOfValue(value);
if (valueIndex < 0)
throw new NoSuchElementException(
"no such value: '" + value + "' in attribute '" + attribute.toString() + "'");
out.add(valueIndex);
}
return out.toNativeArray();
}
@Override
public TIntArrayList read(@NotNull DataInput in) throws IOException {
int capacityOrValue = DataInputOutputUtil.readINT(in);
if (capacityOrValue >= 0) {
TIntArrayList list = new TIntArrayList(2);
list.add(capacityOrValue);
list.add(DataInputOutputUtil.readINT(in));
return list;
}
capacityOrValue = -capacityOrValue;
TIntArrayList list = new TIntArrayList(capacityOrValue);
int prev = 0;
while (capacityOrValue > 0) {
int value = DataInputOutputUtil.readINT(in) + prev;
list.add(value);
prev = value;
list.add(DataInputOutputUtil.readINT(in));
capacityOrValue -= 2;
}
return list;
}
public void visit(jq_Method m) {
if (m.isAbstract()) return;
ControlFlowGraph cfg = m.getCFG();
BasicBlock entry = cfg.entry();
TIntArrayList locks = new TIntArrayList();
if (m.isSynchronized()) {
int lIdx = domL.indexOf(entry);
assert (lIdx >= 0);
locks.add(lIdx);
}
process(entry, locks);
visited.clear();
}
public void removePaths(VirtualFile... paths) {
final Set<VirtualFile> pathsSet = new java.util.HashSet<VirtualFile>(Arrays.asList(paths));
int size = getRowCount();
final TIntArrayList indicesToRemove = new TIntArrayList(paths.length);
for (int idx = 0; idx < size; idx++) {
VirtualFile path = getValueAt(idx);
if (pathsSet.contains(path)) {
indicesToRemove.add(idx);
}
}
final List list = ListUtil.removeIndices(myList, indicesToRemove.toNativeArray());
itemsRemoved(list);
}
@NotNull
private FSRecords.NameId[] persistAllChildren(
@NotNull final VirtualFile file, final int id, @NotNull FSRecords.NameId[] current) {
assert file != mySuperRoot;
final NewVirtualFileSystem fs = replaceWithNativeFS(getDelegate(file));
String[] delegateNames = VfsUtil.filterNames(fs.list(file));
if (delegateNames.length == 0 && current.length > 0) {
return current;
}
Set<String> toAdd = ContainerUtil.newHashSet(delegateNames);
for (FSRecords.NameId nameId : current) {
toAdd.remove(nameId.name);
}
final TIntArrayList childrenIds = new TIntArrayList(current.length + toAdd.size());
final List<FSRecords.NameId> nameIds =
ContainerUtil.newArrayListWithExpectedSize(current.length + toAdd.size());
for (FSRecords.NameId nameId : current) {
childrenIds.add(nameId.id);
nameIds.add(nameId);
}
for (String newName : toAdd) {
FakeVirtualFile child = new FakeVirtualFile(file, newName);
FileAttributes attributes = fs.getAttributes(child);
if (attributes != null) {
int childId = createAndFillRecord(fs, child, id, attributes);
childrenIds.add(childId);
nameIds.add(new FSRecords.NameId(childId, FileNameCache.storeName(newName), newName));
}
}
FSRecords.updateList(id, childrenIds.toNativeArray());
setChildrenCached(id);
return nameIds.toArray(new FSRecords.NameId[nameIds.size()]);
}
@NotNull
private static LineSet createLineSet(@NotNull CharSequence text, boolean markModified) {
TIntArrayList starts = new TIntArrayList();
TByteArrayList flags = new TByteArrayList();
LineTokenizer lineTokenizer = new LineTokenizer(text);
while (!lineTokenizer.atEnd()) {
starts.add(lineTokenizer.getOffset());
flags.add(
(byte) (lineTokenizer.getLineSeparatorLength() | (markModified ? MODIFIED_MASK : 0)));
lineTokenizer.advance();
}
return new LineSet(starts.toNativeArray(), flags.toNativeArray(), text.length());
}
public void forceInitFromModel() {
Set<ClasspathTableItem<?>> oldSelection = new HashSet<ClasspathTableItem<?>>();
for (int i : myEntryTable.getSelectedRows()) {
ContainerUtil.addIfNotNull(getItemAt(i), oldSelection);
}
myModel.clear();
myModel.init();
myModel.fireTableDataChanged();
TIntArrayList newSelection = new TIntArrayList();
for (int i = 0; i < myModel.getRowCount(); i++) {
if (oldSelection.contains(getItemAt(i))) {
newSelection.add(i);
}
}
TableUtil.selectRows(myEntryTable, newSelection.toNativeArray());
}
private boolean checkDirty() {
if (myEditor.getSoftWrapModel().isDirty()) {
myDirty = true;
return true;
}
if (myDirty) {
int visibleLineCount = myEditor.getVisibleLineCount();
int lineDiff = visibleLineCount - myLineWidths.size();
if (lineDiff > 0) myLineWidths.add(new int[lineDiff]);
else if (lineDiff < 0) myLineWidths.remove(visibleLineCount, -lineDiff);
for (int i = 0; i < visibleLineCount; i++) {
myLineWidths.set(i, UNKNOWN_WIDTH);
}
myDirty = false;
}
return false;
}
@Override
public String getInstalledPluginNameByPath(Project project, @NotNull VirtualFile pluginPath) {
String nameFromPluginXml = super.getInstalledPluginNameByPath(project, pluginPath);
if (nameFromPluginXml != null) {
return nameFromPluginXml;
}
VirtualFile pluginJson = pluginPath.findChild("plugin.json");
if (pluginJson != null) {
String pluginAndVersion = pluginPath.getName(); // pluginName-version
TIntArrayList separatorIndexes = new TIntArrayList();
int start = -1;
while (true) {
start = pluginAndVersion.indexOf('-', start + 1);
if (start == -1) break;
separatorIndexes.add(start);
}
if (separatorIndexes.size() == 1) {
return pluginAndVersion.substring(0, separatorIndexes.get(0));
}
if (separatorIndexes.size() > 0) {
String json;
try {
json = VfsUtil.loadText(pluginJson);
} catch (IOException e) {
return null;
}
for (int i = 0; i < separatorIndexes.size(); i++) {
int idx = separatorIndexes.get(i);
String name = pluginAndVersion.substring(0, idx);
String version = pluginAndVersion.substring(idx + 1);
if (hasValue(PLUGIN_NAME_JSON_PATTERN, json, name)
&& hasValue(PLUGIN_VERSION_JSON_PATTERN, json, version)) {
return name;
}
}
}
}
return null;
}
@Override
public void addItems(List<ClasspathTableItem<?>> toAdd) {
for (ClasspathTableItem<?> item : toAdd) {
myModel.addRow(item);
}
TIntArrayList toSelect = new TIntArrayList();
for (int i = myModel.getRowCount() - toAdd.size(); i < myModel.getRowCount(); i++) {
toSelect.add(myEntryTable.convertRowIndexToView(i));
}
TableUtil.selectRows(myEntryTable, toSelect.toNativeArray());
TableUtil.scrollSelectionToVisible(myEntryTable);
final StructureConfigurableContext context =
ModuleStructureConfigurable.getInstance(myState.getProject()).getContext();
context
.getDaemonAnalyzer()
.queueUpdate(new ModuleProjectStructureElement(context, getRootModel().getModule()));
}
private List index(int numEvents, EventStream es, TObjectIntHashMap predicateIndex) {
TObjectIntHashMap omap = new TObjectIntHashMap();
int outcomeCount = 0;
List eventsToCompare = new ArrayList(numEvents);
TIntArrayList indexedContext = new TIntArrayList();
while (es.hasNext()) {
Event ev = es.nextEvent();
String[] econtext = ev.getContext();
ComparableEvent ce;
int ocID;
String oc = ev.getOutcome();
if (omap.containsKey(oc)) {
ocID = omap.get(oc);
} else {
ocID = outcomeCount++;
omap.put(oc, ocID);
}
for (int i = 0; i < econtext.length; i++) {
String pred = econtext[i];
if (predicateIndex.containsKey(pred)) {
indexedContext.add(predicateIndex.get(pred));
}
}
// drop events with no active features
if (indexedContext.size() > 0) {
ce = new ComparableEvent(ocID, indexedContext.toNativeArray());
eventsToCompare.add(ce);
} else {
System.err.println(
"Dropped event " + ev.getOutcome() + ":" + Arrays.asList(ev.getContext()));
}
// recycle the TIntArrayList
indexedContext.resetQuick();
}
outcomeLabels = toIndexedStringArray(omap);
predLabels = toIndexedStringArray(predicateIndex);
return eventsToCompare;
}
/**
* It's possible that we need to expand quick doc control's width in order to provide better
* visual representation (see http://youtrack.jetbrains.com/issue/IDEA-101425). This method
* calculates that width expand.
*
* @param buttonWidth icon button's width
* @param updatedText text which will be should at the quick doc control
* @return width increase to apply to the target quick doc control (zero if no additional width
* increase is required)
*/
private static int calculateWidthIncrease(int buttonWidth, String updatedText) {
int maxLineWidth = 0;
TIntArrayList lineWidths = new TIntArrayList();
for (String lineText : StringUtil.split(updatedText, "<br/>")) {
String html = HintUtil.prepareHintText(lineText, HintUtil.getInformationHint());
int width = new JLabel(html).getPreferredSize().width;
maxLineWidth = Math.max(maxLineWidth, width);
lineWidths.add(width);
}
if (!lineWidths.isEmpty()) {
int firstLineAvailableTrailingWidth = maxLineWidth - lineWidths.get(0);
if (firstLineAvailableTrailingWidth >= buttonWidth) {
return 0;
} else {
return buttonWidth - firstLineAvailableTrailingWidth;
}
}
return 0;
}
private void queueUnresolvedFilesSinceLastRestart() {
PersistentFS fs = PersistentFS.getInstance();
int maxId = FSRecords.getMaxId();
TIntArrayList list = new TIntArrayList();
for (int id = fileIsResolved.nextClearBit(1);
id >= 0 && id < maxId;
id = fileIsResolved.nextClearBit(id + 1)) {
int nextSetBit = fileIsResolved.nextSetBit(id);
int endOfRun = Math.min(maxId, nextSetBit == -1 ? maxId : nextSetBit);
do {
VirtualFile virtualFile = fs.findFileById(id);
if (queueIfNeeded(virtualFile, myProject)) {
list.add(id);
} else {
fileIsResolved.set(id);
}
} while (++id < endOfRun);
}
log("Initially added to resolve " + toVfString(list.toNativeArray()));
}
/**
* Recursively searches the tree for the nearest entry. Other queries call execute() on an
* IntProcedure when a matching entry is found; however nearest() must store the entry Ids as it
* searches the tree, in case a nearer entry is found. Uses the member variable nearestIds to
* store the nearest entry IDs.
*
* <p>[x] TODO rewrite this to be non-recursive?
*/
private float nearest(Point p, Node n, float nearestDistance) {
for (int i = 0; i < n.entryCount; i++) {
float tempDistance = n.entries[i].distance(p);
if (n.isLeaf()) { // for leaves, the distance is an actual nearest distance
if (tempDistance < nearestDistance) {
nearestDistance = tempDistance;
nearestIds.clear();
}
if (tempDistance <= nearestDistance) {
nearestIds.add(n.ids[i]);
}
} else { // for index nodes, only go into them if they potentially could have
// a rectangle nearer than actualNearest
if (tempDistance <= nearestDistance) {
// search the child node
nearestDistance = nearest(p, getNode(n.ids[i]), nearestDistance);
}
}
}
return nearestDistance;
}
private void storeIds(@NotNull ConcurrentIntObjectMap<int[]> fileToForwardIds) {
int forwardSize = 0;
int backwardSize = 0;
final TIntObjectHashMap<TIntArrayList> fileToBackwardIds =
new TIntObjectHashMap<TIntArrayList>(fileToForwardIds.size());
for (ConcurrentIntObjectMap.IntEntry<int[]> entry : fileToForwardIds.entries()) {
int fileId = entry.getKey();
int[] forwardIds = entry.getValue();
forwardSize += forwardIds.length;
for (int forwardId : forwardIds) {
TIntArrayList backIds = fileToBackwardIds.get(forwardId);
if (backIds == null) {
backIds = new TIntArrayList();
fileToBackwardIds.put(forwardId, backIds);
}
backIds.add(fileId);
backwardSize++;
}
}
log("backwardSize = " + backwardSize);
log("forwardSize = " + forwardSize);
log("fileToForwardIds.size() = " + fileToForwardIds.size());
log("fileToBackwardIds.size() = " + fileToBackwardIds.size());
assert forwardSize == backwardSize;
// wrap in read action so that sudden quit (in write action) would not interrupt us
myApplication.runReadAction(
() -> {
if (!myApplication.isDisposed()) {
fileToBackwardIds.forEachEntry(
new TIntObjectProcedure<TIntArrayList>() {
@Override
public boolean execute(int fileId, TIntArrayList backIds) {
storage.addAll(fileId, backIds.toNativeArray());
return true;
}
});
}
});
}
@NotNull
protected List<HighlightInfo> doHighlighting() {
PsiDocumentManager.getInstance(myProject).commitAllDocuments();
TIntArrayList toIgnore = new TIntArrayList();
if (!doTestLineMarkers()) {
toIgnore.add(Pass.UPDATE_OVERRIDEN_MARKERS);
toIgnore.add(Pass.VISIBLE_LINE_MARKERS);
toIgnore.add(Pass.LINE_MARKERS);
}
if (!doExternalValidation()) {
toIgnore.add(Pass.EXTERNAL_TOOLS);
}
if (forceExternalValidation()) {
toIgnore.add(Pass.LINE_MARKERS);
toIgnore.add(Pass.LOCAL_INSPECTIONS);
toIgnore.add(Pass.WHOLE_FILE_LOCAL_INSPECTIONS);
toIgnore.add(Pass.POPUP_HINTS);
toIgnore.add(Pass.UPDATE_ALL);
toIgnore.add(Pass.UPDATE_OVERRIDEN_MARKERS);
toIgnore.add(Pass.VISIBLE_LINE_MARKERS);
}
boolean canChange = canChangeDocumentDuringHighlighting();
List<HighlightInfo> infos =
CodeInsightTestFixtureImpl.instantiateAndRun(
getFile(), getEditor(), toIgnore.toNativeArray(), canChange);
if (!canChange) {
Document document = getDocument(getFile());
DaemonCodeAnalyzerEx daemonCodeAnalyzer = DaemonCodeAnalyzerEx.getInstanceEx(myProject);
daemonCodeAnalyzer.getFileStatusMap().assertAllDirtyScopesAreNull(document);
}
return infos;
}
