public void replace(
final List<BaseInjection> originalInjections, final List<BaseInjection> newInjections) {
for (Iterator<InjInfo> it = injectionInfos.iterator(); it.hasNext(); ) {
final InjInfo info = it.next();
if (originalInjections.contains(info.injection)) it.remove();
}
for (BaseInjection newInjection : newInjections) {
injectionInfos.add(new InjInfo(newInjection, this));
}
}
public static ClassFilter[] readFilters(List children) throws InvalidDataException {
if (children == null || children.size() == 0) {
return ClassFilter.EMPTY_ARRAY;
}
List<ClassFilter> classFiltersList = new ArrayList<ClassFilter>(children.size());
for (Iterator i = children.iterator(); i.hasNext(); ) {
final ClassFilter classFilter = new ClassFilter();
classFilter.readExternal((Element) i.next());
classFiltersList.add(classFilter);
}
return classFiltersList.toArray(new ClassFilter[classFiltersList.size()]);
}
@Nullable
public static List<UnresolvableCollisionUsageInfo> removeConflictUsages(Set<UsageInfo> usages) {
final List<UnresolvableCollisionUsageInfo> result =
new ArrayList<UnresolvableCollisionUsageInfo>();
for (Iterator<UsageInfo> iterator = usages.iterator(); iterator.hasNext(); ) {
UsageInfo usageInfo = iterator.next();
if (usageInfo instanceof UnresolvableCollisionUsageInfo) {
result.add((UnresolvableCollisionUsageInfo) usageInfo);
iterator.remove();
}
}
return result.isEmpty() ? null : result;
}
private static boolean elementListsEqual(List<Element> l1, List<Element> l2) {
if (l1 == null) return l2 == null;
if (l2 == null) return false;
if (l1.size() != l2.size()) return false;
Iterator<Element> i1 = l1.iterator();
for (Element aL2 : l2) {
Element elem1 = i1.next();
if (!elementsEqual(elem1, aL2)) return false;
}
return true;
}
private static boolean elementListsEqual(List<Element> l1, List<Element> l2) {
if (l1 == null) return l2 == null;
if (l2 == null) return false;
if (l1.size() != l2.size()) return false;
Iterator<Element> i1 = l1.iterator();
Iterator<Element> i2 = l2.iterator();
while (i2.hasNext()) {
Element elem1 = i1.next();
Element elem2 = i2.next();
if (!elementsEqual(elem1, elem2)) return false;
}
return true;
}
private static void filterOutBindings(@NotNull List<GroovyResolveResult> candidates) {
boolean hasNonBinding = false;
for (GroovyResolveResult candidate : candidates) {
if (!(candidate.getElement() instanceof GrBindingVariable)) {
hasNonBinding = true;
}
}
if (hasNonBinding) {
for (Iterator<GroovyResolveResult> iterator = candidates.iterator(); iterator.hasNext(); ) {
GroovyResolveResult candidate = iterator.next();
if (candidate.getElement() instanceof GrBindingVariable) {
iterator.remove();
}
}
}
}
public EditorWindow getOrCreateCurrentWindow(final VirtualFile file) {
final List<EditorWindow> windows = findWindows(file);
if (getCurrentWindow() == null) {
final Iterator<EditorWindow> iterator = myWindows.iterator();
if (!windows.isEmpty()) {
setCurrentWindow(windows.get(0), false);
} else if (iterator.hasNext()) {
setCurrentWindow(iterator.next(), false);
} else {
createCurrentWindow();
}
} else if (!windows.isEmpty()) {
if (!windows.contains(getCurrentWindow())) {
setCurrentWindow(windows.get(0), false);
}
}
return getCurrentWindow();
}
private static boolean attributeListsEqual(List<Attribute> l1, List<Attribute> l2) {
if (l1 == null) return l2 == null;
if (l2 == null) return false;
if (l1.size() != l2.size()) return false;
Iterator<Attribute> i1 = l1.iterator();
for (Attribute aL2 : l2) {
Attribute attr1 = i1.next();
if (!Comparing.equal(attr1.getName(), aL2.getName())
|| !Comparing.equal(attr1.getValue(), aL2.getValue())) {
return false;
}
}
return true;
}
private static List<TextFilePatch> loadTextPatches(
final Project project,
final ShelvedChangeList changeList,
final List<ShelvedChange> changes,
final List<FilePatch> remainingPatches,
final CommitContext commitContext)
throws IOException, PatchSyntaxException {
final List<TextFilePatch> textFilePatches;
textFilePatches = loadPatches(project, changeList.PATH, commitContext);
if (changes != null) {
final Iterator<TextFilePatch> iterator = textFilePatches.iterator();
while (iterator.hasNext()) {
TextFilePatch patch = iterator.next();
if (!needUnshelve(patch, changes)) {
remainingPatches.add(patch);
iterator.remove();
}
}
}
return textFilePatches;
}
private void recycleChangeList(
final ShelvedChangeList listCopy, final ShelvedChangeList newList) {
if (newList != null) {
for (Iterator<ShelvedBinaryFile> shelvedChangeListIterator =
listCopy.getBinaryFiles().iterator();
shelvedChangeListIterator.hasNext(); ) {
final ShelvedBinaryFile binaryFile = shelvedChangeListIterator.next();
for (ShelvedBinaryFile newBinary : newList.getBinaryFiles()) {
if (Comparing.equal(newBinary.BEFORE_PATH, binaryFile.BEFORE_PATH)
&& Comparing.equal(newBinary.AFTER_PATH, binaryFile.AFTER_PATH)) {
shelvedChangeListIterator.remove();
}
}
}
for (Iterator<ShelvedChange> iterator = listCopy.getChanges(myProject).iterator();
iterator.hasNext(); ) {
final ShelvedChange change = iterator.next();
for (ShelvedChange newChange : newList.getChanges(myProject)) {
if (Comparing.equal(change.getBeforePath(), newChange.getBeforePath())
&& Comparing.equal(change.getAfterPath(), newChange.getAfterPath())) {
iterator.remove();
}
}
}
// needed only if partial unshelve
try {
final CommitContext commitContext = new CommitContext();
final List<FilePatch> patches = new ArrayList<FilePatch>();
for (ShelvedChange change : listCopy.getChanges(myProject)) {
patches.add(change.loadFilePatch(myProject, commitContext));
}
writePatchesToFile(myProject, listCopy.PATH, patches, commitContext);
} catch (IOException e) {
LOG.info(e);
// left file as is
} catch (PatchSyntaxException e) {
LOG.info(e);
// left file as is
}
}
if ((!listCopy.getBinaryFiles().isEmpty()) || (!listCopy.getChanges(myProject).isEmpty())) {
listCopy.setRecycled(true);
myRecycledShelvedChangeLists.add(listCopy);
notifyStateChanged();
}
}
private void validateEntryPoints() {
long count = PsiManager.getInstance(myProject).getModificationTracker().getModificationCount();
if (count != myLastModificationCount) {
myLastModificationCount = count;
Collection<SmartRefElementPointer> collection = myPersistentEntryPoints.values();
SmartRefElementPointer[] entries =
collection.toArray(new SmartRefElementPointer[collection.size()]);
for (SmartRefElementPointer entry : entries) {
RefElement refElement = (RefElement) entry.getRefElement();
if (refElement != null && !refElement.isValid()) {
myPersistentEntryPoints.remove(entry.getFQName());
}
}
final Iterator<RefElement> it = myTemporaryEntryPoints.iterator();
while (it.hasNext()) {
RefElement refElement = it.next();
if (!refElement.isValid()) {
it.remove();
}
}
}
}
public static ReferenceType getSuperClass(
final String baseQualifiedName, ReferenceType checkedType) {
if (baseQualifiedName.equals(checkedType.name())) {
return checkedType;
}
if (checkedType instanceof ClassType) {
ClassType classType = (ClassType) checkedType;
ClassType superClassType = classType.superclass();
if (superClassType != null) {
ReferenceType superClass = getSuperClass(baseQualifiedName, superClassType);
if (superClass != null) {
return superClass;
}
}
List<InterfaceType> ifaces = classType.allInterfaces();
for (Iterator<InterfaceType> it = ifaces.iterator(); it.hasNext(); ) {
InterfaceType iface = it.next();
ReferenceType superClass = getSuperClass(baseQualifiedName, iface);
if (superClass != null) {
return superClass;
}
}
}
if (checkedType instanceof InterfaceType) {
List<InterfaceType> list = ((InterfaceType) checkedType).superinterfaces();
for (Iterator<InterfaceType> it = list.iterator(); it.hasNext(); ) {
InterfaceType superInterface = it.next();
ReferenceType superClass = getSuperClass(baseQualifiedName, superInterface);
if (superClass != null) {
return superClass;
}
}
}
return null;
}
@Nullable
static String filterBadPlugins(
List<? extends IdeaPluginDescriptor> result, final Map<String, String> disabledPluginNames) {
final Map<PluginId, IdeaPluginDescriptor> idToDescriptorMap =
new HashMap<PluginId, IdeaPluginDescriptor>();
final StringBuffer message = new StringBuffer();
boolean pluginsWithoutIdFound = false;
for (Iterator<? extends IdeaPluginDescriptor> it = result.iterator(); it.hasNext(); ) {
final IdeaPluginDescriptor descriptor = it.next();
final PluginId id = descriptor.getPluginId();
if (id == null) {
pluginsWithoutIdFound = true;
}
if (idToDescriptorMap.containsKey(id)) {
message.append("<br>");
message.append(IdeBundle.message("message.duplicate.plugin.id"));
message.append(id);
it.remove();
} else if (descriptor.isEnabled()) {
idToDescriptorMap.put(id, descriptor);
}
}
addModulesAsDependents(idToDescriptorMap);
final List<String> disabledPluginIds = new ArrayList<String>();
final LinkedHashSet<String> faultyDescriptors = new LinkedHashSet<String>();
for (final Iterator<? extends IdeaPluginDescriptor> it = result.iterator(); it.hasNext(); ) {
final IdeaPluginDescriptor pluginDescriptor = it.next();
checkDependants(
pluginDescriptor,
new Function<PluginId, IdeaPluginDescriptor>() {
@Override
public IdeaPluginDescriptor fun(final PluginId pluginId) {
return idToDescriptorMap.get(pluginId);
}
},
new Condition<PluginId>() {
@Override
public boolean value(final PluginId pluginId) {
if (!idToDescriptorMap.containsKey(pluginId)) {
pluginDescriptor.setEnabled(false);
if (!pluginId.getIdString().startsWith(MODULE_DEPENDENCY_PREFIX)) {
faultyDescriptors.add(pluginId.getIdString());
disabledPluginIds.add(pluginDescriptor.getPluginId().getIdString());
message.append("<br>");
final String name = pluginDescriptor.getName();
final IdeaPluginDescriptor descriptor = idToDescriptorMap.get(pluginId);
String pluginName;
if (descriptor == null) {
pluginName = pluginId.getIdString();
if (disabledPluginNames.containsKey(pluginName)) {
pluginName = disabledPluginNames.get(pluginName);
}
} else {
pluginName = descriptor.getName();
}
message.append(
getDisabledPlugins().contains(pluginId.getIdString())
? IdeBundle.message("error.required.plugin.disabled", name, pluginName)
: IdeBundle.message(
"error.required.plugin.not.installed", name, pluginName));
}
it.remove();
return false;
}
return true;
}
});
}
if (!disabledPluginIds.isEmpty()) {
myPlugins2Disable = disabledPluginIds;
myPlugins2Enable = faultyDescriptors;
message.append("<br>");
message.append("<br>").append("<a href=\"" + DISABLE + "\">Disable ");
if (disabledPluginIds.size() == 1) {
final PluginId pluginId2Disable = PluginId.getId(disabledPluginIds.iterator().next());
message.append(
idToDescriptorMap.containsKey(pluginId2Disable)
? idToDescriptorMap.get(pluginId2Disable).getName()
: pluginId2Disable.getIdString());
} else {
message.append("not loaded plugins");
}
message.append("</a>");
boolean possibleToEnable = true;
for (String descriptor : faultyDescriptors) {
if (disabledPluginNames.get(descriptor) == null) {
possibleToEnable = false;
break;
}
}
if (possibleToEnable) {
message
.append("<br>")
.append("<a href=\"" + ENABLE + "\">Enable ")
.append(
faultyDescriptors.size() == 1
? disabledPluginNames.get(faultyDescriptors.iterator().next())
: " all necessary plugins")
.append("</a>");
}
message.append("<br>").append("<a href=\"" + EDIT + "\">Open plugin manager</a>");
}
if (pluginsWithoutIdFound) {
message.append("<br>");
message.append(IdeBundle.message("error.plugins.without.id.found"));
}
if (message.length() > 0) {
message.insert(0, IdeBundle.message("error.problems.found.loading.plugins"));
return message.toString();
}
return null;
}
private List<PostponedAction> normalizeAndReorderPostponedActions(
final TreeSet<PostprocessFormattingTask> rangesToProcess, Document document) {
final List<PostprocessFormattingTask> freeFormatingActions =
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 {
freeFormatingActions.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());
freeFormatingActions.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 {
freeFormatingActions.add(accumulatedTask);
}
}
final List<PostponedAction> result = new ArrayList<PostponedAction>();
Collections.reverse(freeFormatingActions);
Collections.reverse(indentActions);
if (!freeFormatingActions.isEmpty()) {
FormatTextRanges ranges = new FormatTextRanges();
for (PostprocessFormattingTask action : freeFormatingActions) {
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;
}
@Nullable
@SuppressWarnings({"HardCodedStringLiteral"})
private JPanel readExternalPanel(
final Element element, @Nullable JPanel panel, Ref<EditorWindow> currentWindow) {
final Element splitterElement = element.getChild("splitter");
if (splitterElement != null) {
return readSplitter(panel, splitterElement, currentWindow);
}
final Element leaf = element.getChild("leaf");
if (leaf == null) {
return null;
}
final EditorWindow window = panel == null ? new EditorWindow(this) : findWindowWith(panel);
LOG.assertTrue(window != null);
@SuppressWarnings("unchecked")
final List<Element> children = ContainerUtil.newArrayList(leaf.getChildren("file"));
if (UISettings.getInstance().ACTIVATE_RIGHT_EDITOR_ON_CLOSE) {
Collections.reverse(children);
}
// trim to EDITOR_TAB_LIMIT, ignoring CLOSE_NON_MODIFIED_FILES_FIRST policy
for (Iterator<Element> iterator = children.iterator();
iterator.hasNext() && UISettings.getInstance().EDITOR_TAB_LIMIT < children.size(); ) {
Element child = iterator.next();
if (!Boolean.valueOf(child.getAttributeValue(PINNED)).booleanValue()) {
iterator.remove();
}
}
VirtualFile currentFile = null;
for (int i = 0; i < children.size(); i++) {
final Element file = children.get(i);
try {
final FileEditorManagerImpl fileEditorManager = getManager();
final HistoryEntry entry =
new HistoryEntry(fileEditorManager.getProject(), file.getChild(HistoryEntry.TAG), true);
final boolean isCurrent = Boolean.valueOf(file.getAttributeValue("current")).booleanValue();
fileEditorManager.openFileImpl4(window, entry.myFile, false, entry, isCurrent, i);
if (fileEditorManager.isFileOpen(entry.myFile)) {
window.setFilePinned(
entry.myFile, Boolean.valueOf(file.getAttributeValue(PINNED)).booleanValue());
if (Boolean.valueOf(file.getAttributeValue("current-in-tab")).booleanValue()) {
currentFile = entry.myFile;
}
}
} catch (InvalidDataException e) {
if (ApplicationManager.getApplication().isUnitTestMode()) {
LOG.error(e);
}
}
}
if (currentFile != null) {
final EditorComposite editor = window.findFileComposite(currentFile);
if (editor != null) {
window.setSelectedEditor(editor, true);
}
}
return window.myPanel;
}