myConstructorTrackedClasses = new ConcurrentHashMap<>();
+ private final XDebugSessionListener myDebugSessionListener;
+
+ @Nullable
+ private volatile SuspendContextImpl myLastSuspendContext;
+
+ /**
+ * Indicates that the debug session had been stopped at least once.
+ *
+ * State: false to true
+ */
+ private volatile boolean myIsTrackersActivated = false;
+
+ /**
+ * Indicates that view is visible in tool window
+ */
+ private boolean myIsActive;
+
+ public ClassesFilteredView(@NotNull XDebugSession debugSession) {
+ super();
+
+ myProject = debugSession.getProject();
+ myDebugSession = debugSession;
+ myDebugProcess = (DebugProcessImpl) DebuggerManager.getInstance(myProject)
+ .getDebugProcess(myDebugSession.getDebugProcess().getProcessHandler());
+
+ if (myDebugProcess == null) {
+ throw new NullPointerException("Failed to receive a java debug process");
+ }
+
+ myInstancesTracker = InstancesTracker.getInstance(myProject);
+ InstancesTrackerListener instancesTrackerListener = new InstancesTrackerListener() {
+ @Override
+ public void classChanged(@NotNull String name, @NotNull TrackingType type) {
+ ReferenceType ref = myTable.getClassByName(name);
+ if (ref != null) {
+ myDebugProcess.getManagerThread()
+ .schedule(new LowestPriorityCommand(getSuspendContext()) {
+ @Override
+ public void contextAction(@NotNull SuspendContextImpl suspendContext) throws Exception {
+ trackClass(ref, type, myIsTrackersActivated);
+ }
+ });
+ }
+ myTable.repaint();
+ }
+
+ @Override
+ public void classRemoved(@NotNull String name) {
+ ReferenceType ref = myTable.getClassByName(name);
+ if (ref != null && myConstructorTrackedClasses.containsKey(ref)) {
+ ConstructorInstancesTracker removed = myConstructorTrackedClasses.remove(ref);
+ Disposer.dispose(removed);
+ myTable.getRowSorter().allRowsChanged();
+ }
+ }
+ };
+
+ myDebugProcess.getManagerThread().schedule(new DebuggerCommandImpl() {
+ @Override
+ public Priority getPriority() {
+ return Priority.LOWEST;
+ }
+
+ @Override
+ protected void action() throws Exception {
+ for (Map.Entry entry : myInstancesTracker.getTrackedClasses().entrySet()) {
+ TrackingType type = entry.getValue();
+ String className = entry.getKey();
+ List classes = myDebugProcess.getVirtualMachineProxy().classesByName(className);
+ if (classes.isEmpty()) {
+ new ClassPreparedListener(className, myDebugSession) {
+ @Override
+ public void onClassPrepared(@NotNull ReferenceType referenceType) {
+ trackClass(referenceType, type, myIsTrackersActivated);
+ }
+ };
+ } else {
+ for (ReferenceType ref : classes) {
+ trackClass(ref, type, myIsTrackersActivated);
+ }
+ }
+ }
+
+ myInstancesTracker.addTrackerListener(instancesTrackerListener, ClassesFilteredView.this);
+ }
+ });
+
+ MemoryViewManagerState memoryViewManagerState = MemoryViewManager.getInstance().getState();
+
+ myTable = new ClassesTable(myDebugSession, memoryViewManagerState.isShowWithDiffOnly,
+ memoryViewManagerState.isShowWithInstancesOnly, memoryViewManagerState.isShowTrackedOnly, this);
+ myTable.getEmptyText().setText(EMPTY_TABLE_CONTENT_WHEN_RUNNING);
+ Disposer.register(this, myTable);
+
+ myTable.addMouseMotionListener(new MyMouseMotionListener());
+ myTable.addMouseListener(new MyOpenNewInstancesListener());
+ new MyDoubleClickListener().installOn(myTable);
+
+ myTable.addKeyListener(new KeyAdapter() {
+ @Override
+ public void keyReleased(KeyEvent e) {
+ int keyCode = e.getKeyCode();
+ if (KeyboardUtils.isEnterKey(keyCode)) {
+ handleClassSelection(myTable.getSelectedClass());
+ } else if (KeyboardUtils.isCharacter(keyCode) || KeyboardUtils.isBackSpace(keyCode)) {
+ String text = myFilterTextField.getText();
+ String newText = KeyboardUtils.isBackSpace(keyCode)
+ ? text.substring(0, text.length() - 1)
+ : text + e.getKeyChar();
+ myFilterTextField.setText(newText);
+ FocusManager.getCurrentManager().focusNextComponent(myFilterTextField);
+ }
+ }
+ });
+
+ myFilterTextField.addKeyboardListener(new KeyAdapter() {
+ @Override
+ public void keyPressed(KeyEvent e) {
+ dispatch(e);
+ }
+
+ @Override
+ public void keyReleased(KeyEvent e) {
+ dispatch(e);
+ }
+
+ private void dispatch(KeyEvent e) {
+ if (KeyboardUtils.isUpDownKey(e.getKeyCode()) || KeyboardUtils.isEnterKey(e.getKeyCode())) {
+ myTable.dispatchEvent(e);
+ }
+ }
+ });
+
+ myFilterTextField.addDocumentListener(new DocumentAdapter() {
+ @Override
+ protected void textChanged(DocumentEvent e) {
+ myTable.setFilterPattern(myFilterTextField.getText());
+ }
+ });
+
+ final MemoryViewManagerListener memoryViewManagerListener = state -> {
+ myTable.setFilteringByDiffNonZero(state.isShowWithDiffOnly);
+ myTable.setFilteringByInstanceExists(state.isShowWithInstancesOnly);
+ myTable.setFilteringByTrackingState(state.isShowTrackedOnly);
+ };
+
+ MemoryViewManager.getInstance().addMemoryViewManagerListener(memoryViewManagerListener, this);
+
+ myDebugSessionListener = new XDebugSessionListener() {
+ @Override
+ public void sessionResumed() {
+ myConstructorTrackedClasses.values().forEach(ConstructorInstancesTracker::obsolete);
+ ApplicationManager.getApplication().invokeLater(() -> {
+ myTable.getEmptyText().setText(EMPTY_TABLE_CONTENT_WHEN_RUNNING);
+ myTable.hideContent();
+ });
+ mySingleAlarm.cancelAllRequests();
+ }
+
+ @Override
+ public void sessionStopped() {
+ debugSession.removeSessionListener(this);
+ }
+
+ @Override
+ public void sessionPaused() {
+ ApplicationManager.getApplication().invokeLater(() -> myTable.getEmptyText().setText(EMPTY_TABLE_CONTENT_WHEN_SUSPENDED));
+ updateClassesAndCounts();
+ }
+ };
+
+ mySingleAlarm = new SingleAlarmWithMutableDelay(() -> {
+ myLastSuspendContext = getSuspendContext();
+ if (myLastSuspendContext != null) {
+ ApplicationManager.getApplication().invokeLater(() -> myTable.setBusy(true));
+ myDebugProcess.getManagerThread()
+ .schedule(new MyUpdateClassesCommand(myLastSuspendContext));
+ }
+ }, this);
+
+ myTable.addMouseListener(new PopupHandler() {
+ @Override
+ public void invokePopup(Component comp, int x, int y) {
+ ActionPopupMenu menu = createContextMenu();
+ if (menu != null) {
+ menu.getComponent().show(comp, x, y);
+ }
+ }
+ });
+
+ JScrollPane scroll = ScrollPaneFactory.createScrollPane(myTable, SideBorder.TOP);
+ addToTop(myFilterTextField);
+ addToCenter(scroll);
+ }
+
+ @Nullable
+ TrackerForNewInstances getStrategy(@NotNull ReferenceType ref) {
+ return myConstructorTrackedClasses.getOrDefault(ref, null);
+ }
+
+ private void trackClass(@NotNull ReferenceType ref,
+ @NotNull TrackingType type,
+ boolean isTrackerEnabled) {
+ LOG.assertTrue(DebuggerManager.getInstance(myProject).isDebuggerManagerThread());
+ if (type == TrackingType.CREATION) {
+ ConstructorInstancesTracker old = myConstructorTrackedClasses.getOrDefault(ref, null);
+ if (old != null) {
+ Disposer.dispose(old);
+ }
+
+ ConstructorInstancesTracker tracker = new ConstructorInstancesTracker(ref, myDebugSession);
+ tracker.setBackgroundMode(!myIsActive);
+ if (isTrackerEnabled) {
+ tracker.enable();
+ } else {
+ tracker.disable();
+ }
+
+ Disposer.register(this, tracker);
+ myConstructorTrackedClasses.put(ref, tracker);
+ }
+ }
+
+ private void handleClassSelection(@Nullable ReferenceType ref) {
+ if (ref != null && myDebugSession.isSuspended()) {
+ new InstancesWindow(myDebugSession, ref::instances, ref.name()).show();
+ }
+ }
+
+ private void commitAllTrackers() {
+ myConstructorTrackedClasses.values().forEach(ConstructorInstancesTracker::commitTracked);
+ }
+
+ private SuspendContextImpl getSuspendContext() {
+ return DebuggerManagerEx.getInstanceEx(myProject).getContext().getSuspendContext();
+ }
+
+ private void updateClassesAndCounts() {
+ if (myDebugProcess.isAttached()) {
+ mySingleAlarm.cancelAndRequest();
+ }
+ }
+
+ private static ActionPopupMenu createContextMenu() {
+ ActionGroup group = (ActionGroup) ActionManager.getInstance().getAction("MemoryView.ClassesPopupActionGroup");
+ return ActionManager.getInstance().createActionPopupMenu("MemoryView.ClassesPopupActionGroup", group);
+ }
+
+ @Override
+ public void dispose() {
+ }
+
+ public void setActive(boolean active) {
+ if (myIsActive == active) {
+ return;
+ }
+
+ myIsActive = active;
+ myDebugProcess.getManagerThread().schedule(new DebuggerCommandImpl() {
+ @Override
+ protected void action() throws Exception {
+ if (active) {
+ doActivate();
+ } else {
+ doPause();
+ }
+ }
+ });
+ }
+
+ private void doActivate() {
+ myDebugSession.addSessionListener(myDebugSessionListener, this);
+ myConstructorTrackedClasses.values().forEach(x -> x.setBackgroundMode(false));
+ final SuspendContextImpl lastContext = myLastSuspendContext;
+ if (lastContext == null || !lastContext.equals(getSuspendContext())) {
+ updateClassesAndCounts();
+ }
+ }
+
+ private void doPause() {
+ myDebugSession.removeSessionListener(myDebugSessionListener);
+ myConstructorTrackedClasses.values().forEach(x -> x.setBackgroundMode(true));
+ }
+
+ private final class MyUpdateClassesCommand extends LowestPriorityCommand {
+
+ MyUpdateClassesCommand(@Nullable SuspendContextImpl suspendContext) {
+ super(suspendContext);
+ }
+
+ @Override
+ public void contextAction(@NotNull SuspendContextImpl suspendContext) throws Exception {
+ if (!myIsTrackersActivated) {
+ myConstructorTrackedClasses.values().forEach(ConstructorInstancesTracker::enable);
+ myIsTrackersActivated = true;
+ } else {
+ commitAllTrackers();
+ }
+ final List classes = myDebugProcess.getVirtualMachineProxy().allClasses();
+
+ if (classes.isEmpty()) {
+ return;
+ }
+
+ VirtualMachine vm = classes.get(0).virtualMachine();
+ int batchSize = AndroidUtil.isAndroidVM(vm)
+ ? AndroidUtil.ANDROID_COUNT_BY_CLASSES_BATCH_SIZE
+ : DEFAULT_BATCH_SIZE;
+
+ List chunks = new SmartList<>();
+ int size = classes.size();
+ for (int begin = 0, end = Math.min(batchSize, size);
+ begin != size && isContextValid();
+ begin = end, end = Math.min(end + batchSize, size)) {
+ List batch = classes.subList(begin, end);
+
+ long start = System.nanoTime();
+ long[] counts = vm.instanceCounts(batch);
+ long delay = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);
+
+ chunks.add(counts);
+
+ int waitTime = (int) Math.min(DELAY_BEFORE_INSTANCES_QUERY_COEFFICIENT * delay, MAX_DELAY_MILLIS);
+ mySingleAlarm.setDelay(waitTime);
+ LOG.info(String.format("Instances query time = %d ms. Count = %d", delay, batch.size()));
+ }
+
+ if (isContextValid()) {
+ final long[] counts = chunks.size() == 1 ? chunks.get(0) : IntStream.range(0, chunks.size()).boxed()
+ .flatMapToLong(integer -> Arrays.stream(chunks.get(integer)))
+ .toArray();
+ ApplicationManager.getApplication().invokeLater(() -> myTable.setClassesAndUpdateCounts(classes, counts));
+ }
+
+ ApplicationManager.getApplication().invokeLater(() -> myTable.setBusy(false));
+ }
+
+ private boolean isContextValid() {
+ return ClassesFilteredView.this.getSuspendContext() == getSuspendContext();
+ }
+ }
+
+ private static class FilterTextField extends SearchTextField {
+ FilterTextField() {
+ super(false);
+ }
+
+ @Override
+ protected void showPopup() {
+ }
+
+ @Override
+ protected boolean hasIconsOutsideOfTextField() {
+ return false;
+ }
+ }
+
+ private class MyOpenNewInstancesListener extends MouseAdapter {
+ @Override
+ public void mouseClicked(MouseEvent e) {
+ if (e.getClickCount() != 1 || e.getButton() != MouseEvent.BUTTON1 || !isShowNewInstancesEvent(e)) {
+ return;
+ }
+
+ final CreationPositionTracker tracker = CreationPositionTracker.getInstance(myDebugSession.getProject());
+ ReferenceType ref = myTable.getSelectedClass();
+ TrackerForNewInstances strategy = ref == null ? null : getStrategy(ref);
+ if (strategy != null && tracker != null) {
+ List newInstances = strategy.getNewInstances();
+ tracker.pinStacks(myDebugSession, ref);
+ InstancesWindow instancesWindow = new InstancesWindow(myDebugSession, limit -> newInstances, ref.name());
+ Disposer.register(instancesWindow.getDisposable(), () -> tracker.unpinStacks(myDebugSession, ref));
+ instancesWindow.show();
+ }
+ }
+ }
+
+ private class MyDoubleClickListener extends DoubleClickListener {
+ @Override
+ protected boolean onDoubleClick(MouseEvent event) {
+ if (!isShowNewInstancesEvent(event)) {
+ handleClassSelection(myTable.getSelectedClass());
+ return true;
+ }
+
+ return false;
+ }
+ }
+
+ private class MyMouseMotionListener implements MouseMotionListener {
+ @Override
+ public void mouseDragged(MouseEvent e) {
+ }
+
+ @Override
+ public void mouseMoved(MouseEvent e) {
+ if (isShowNewInstancesEvent(e)) {
+ myTable.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
+ } else {
+ myTable.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
+ }
+ }
+ }
+
+ private boolean isShowNewInstancesEvent(@NotNull MouseEvent e) {
+ final int col = myTable.columnAtPoint(e.getPoint());
+ final int row = myTable.rowAtPoint(e.getPoint());
+ if (col == -1 || row == -1 || myTable.convertColumnIndexToModel(col) != DIFF_COLUMN_INDEX) {
+ return false;
+ }
+
+ final int modelRow = myTable.convertRowIndexToModel(row);
+
+ final ReferenceType ref = (ReferenceType) myTable.getModel().getValueAt(modelRow, CLASSNAME_COLUMN_INDEX);
+ final ConstructorInstancesTracker tracker = myConstructorTrackedClasses.getOrDefault(ref, null);
+
+ return tracker != null && tracker.isReady() && tracker.getCount() > 0;
+ }
+}
diff --git a/java/debugger/impl/src/com/intellij/debugger/memory/ui/ClassesTable.java b/java/debugger/impl/src/com/intellij/debugger/memory/ui/ClassesTable.java
new file mode 100644
index 000000000000..6c4bcb9cbb15
--- /dev/null
+++ b/java/debugger/impl/src/com/intellij/debugger/memory/ui/ClassesTable.java
@@ -0,0 +1,499 @@
+/*
+ * Copyright 2000-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.debugger.memory.ui;
+
+import com.intellij.debugger.memory.component.InstancesTracker;
+import com.intellij.debugger.memory.utils.AbstractTableColumnDescriptor;
+import com.intellij.debugger.memory.utils.AbstractTableModelWithColumns;
+import com.intellij.icons.AllIcons;
+import com.intellij.openapi.Disposable;
+import com.intellij.openapi.actionSystem.DataKey;
+import com.intellij.openapi.actionSystem.DataProvider;
+import com.intellij.openapi.util.TextRange;
+import com.intellij.psi.codeStyle.MinusculeMatcher;
+import com.intellij.psi.codeStyle.NameUtil;
+import com.intellij.ui.ColoredTableCellRenderer;
+import com.intellij.ui.JBColor;
+import com.intellij.ui.SimpleTextAttributes;
+import com.intellij.ui.speedSearch.SpeedSearchUtil;
+import com.intellij.ui.table.JBTable;
+import com.intellij.util.containers.FList;
+import com.intellij.util.ui.JBDimension;
+import com.intellij.util.ui.JBUI;
+import com.intellij.xdebugger.XDebugSession;
+import com.sun.jdi.ObjectReference;
+import com.sun.jdi.ReferenceType;
+import org.jetbrains.annotations.NonNls;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import com.intellij.debugger.memory.tracking.TrackerForNewInstances;
+import com.intellij.debugger.memory.tracking.TrackingType;
+import com.intellij.debugger.memory.utils.InstancesProvider;
+
+import javax.swing.*;
+import javax.swing.border.Border;
+import javax.swing.table.TableColumn;
+import javax.swing.table.TableRowSorter;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class ClassesTable extends JBTable implements DataProvider, Disposable {
+ public static final DataKey SELECTED_CLASS_KEY = DataKey.create("ClassesTable.SelectedClass");
+ public static final DataKey DEBUG_SESSION_KEY = DataKey.create("ClassesTable.DebugSession");
+ public static final DataKey NEW_INSTANCES_PROVIDER_KEY =
+ DataKey.create("ClassesTable.NewInstances");
+ public static final DataKey REF_COUNT_PROVIDER_KEY =
+ DataKey.create("ClassesTable.ReferenceCountProvider");
+
+ private static final Border EMPTY_BORDER = BorderFactory.createEmptyBorder();
+
+ private static final int CLASSES_COLUMN_PREFERRED_WIDTH = 250;
+ private static final int COUNT_COLUMN_MIN_WIDTH = 80;
+ private static final int DIFF_COLUMN_MIN_WIDTH = 80;
+
+ private final DiffViewTableModel myModel = new DiffViewTableModel();
+ private final UnknownDiffValue myUnknownValue = new UnknownDiffValue();
+ private final XDebugSession myDebugSession;
+ private final Map myCounts = new ConcurrentHashMap<>();
+ private final InstancesTracker myInstancesTracker;
+ private final ClassesFilteredView myParent;
+ private final ReferenceCountProvider myCountProvider;
+
+ private boolean myOnlyWithDiff;
+ private boolean myOnlyTracked;
+ private boolean myOnlyWithInstances;
+ private MinusculeMatcher myMatcher = NameUtil.buildMatcher("*").build();
+ private String myFilteringPattern = "";
+
+ private volatile List myItems = Collections.unmodifiableList(new ArrayList<>());
+
+ ClassesTable(@NotNull XDebugSession session, boolean onlyWithDiff, boolean onlyWithInstances,
+ boolean onlyTracked, @NotNull ClassesFilteredView parent) {
+ setModel(myModel);
+
+ myDebugSession = session;
+ myOnlyWithDiff = onlyWithDiff;
+ myOnlyWithInstances = onlyWithInstances;
+ myOnlyTracked = onlyTracked;
+ myInstancesTracker = InstancesTracker.getInstance(myDebugSession.getProject());
+ myParent = parent;
+
+ TableColumn classesColumn = getColumnModel().getColumn(DiffViewTableModel.CLASSNAME_COLUMN_INDEX);
+ TableColumn countColumn = getColumnModel().getColumn(DiffViewTableModel.COUNT_COLUMN_INDEX);
+ TableColumn diffColumn = getColumnModel().getColumn(DiffViewTableModel.DIFF_COLUMN_INDEX);
+
+ setAutoResizeMode(AUTO_RESIZE_NEXT_COLUMN);
+ classesColumn.setPreferredWidth(JBUI.scale(CLASSES_COLUMN_PREFERRED_WIDTH));
+
+ countColumn.setMinWidth(JBUI.scale(COUNT_COLUMN_MIN_WIDTH));
+
+ diffColumn.setMinWidth(JBUI.scale(DIFF_COLUMN_MIN_WIDTH));
+
+ setShowGrid(false);
+ setIntercellSpacing(new JBDimension(0, 0));
+
+ setDefaultRenderer(ReferenceType.class, new MyClassColumnRenderer());
+ setDefaultRenderer(Long.class, new MyCountColumnRenderer());
+ setDefaultRenderer(DiffValue.class, new MyDiffColumnRenderer());
+
+ TableRowSorter sorter = new TableRowSorter<>(myModel);
+ sorter.setRowFilter(new RowFilter() {
+ @Override
+ public boolean include(Entry entry) {
+ int ix = entry.getIdentifier();
+ ReferenceType ref = myItems.get(ix);
+ DiffValue diff = myCounts.getOrDefault(ref, myUnknownValue);
+
+ boolean isFilteringOptionsRefused = myOnlyWithDiff && diff.diff() == 0
+ || myOnlyWithInstances && !diff.hasInstance()
+ || myOnlyTracked && myParent.getStrategy(ref) == null;
+ return !(isFilteringOptionsRefused) && myMatcher.matches(ref.name());
+ }
+ });
+
+ List myDefaultSortingKeys = Arrays.asList(
+ new RowSorter.SortKey(DiffViewTableModel.DIFF_COLUMN_INDEX, SortOrder.DESCENDING),
+ new RowSorter.SortKey(DiffViewTableModel.COUNT_COLUMN_INDEX, SortOrder.DESCENDING),
+ new RowSorter.SortKey(DiffViewTableModel.CLASSNAME_COLUMN_INDEX, SortOrder.ASCENDING)
+ );
+ sorter.setSortKeys(myDefaultSortingKeys);
+ setRowSorter(sorter);
+ setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+
+ myCountProvider = new ReferenceCountProvider() {
+ @Override
+ public int getTotalCount(@NotNull ReferenceType ref) {
+ return (int)myCounts.get(ref).myCurrentCount;
+ }
+
+ @Override
+ public int getDiffCount(@NotNull ReferenceType ref) {
+ return (int)myCounts.get(ref).diff();
+ }
+
+ @Override
+ public int getNewInstancesCount(@NotNull ReferenceType ref) {
+ TrackerForNewInstances strategy = myParent.getStrategy(ref);
+ return strategy == null || !strategy.isReady() ? -1 : strategy.getCount();
+ }
+ };
+ }
+
+ public interface ReferenceCountProvider {
+ int getTotalCount(@NotNull ReferenceType ref);
+
+ int getDiffCount(@NotNull ReferenceType ref);
+
+ int getNewInstancesCount(@NotNull ReferenceType ref);
+ }
+
+ @Nullable
+ ReferenceType getSelectedClass() {
+ int selectedRow = getSelectedRow();
+ if (selectedRow != -1) {
+ int ix = convertRowIndexToModel(selectedRow);
+ return myItems.get(ix);
+ }
+
+ return null;
+ }
+
+ @Nullable
+ ReferenceType getClassByName(@NotNull String name) {
+ for (ReferenceType ref : myItems) {
+ if (name.equals(ref.name())) {
+ return ref;
+ }
+ }
+
+ return null;
+ }
+
+ void setBusy(boolean value) {
+ setPaintBusy(value);
+ }
+
+ void setFilterPattern(String pattern) {
+ if (!myFilteringPattern.equals(pattern)) {
+ myFilteringPattern = pattern;
+ myMatcher = NameUtil.buildMatcher("*" + pattern).build();
+ getRowSorter().allRowsChanged();
+ if (getSelectedClass() == null && getRowCount() > 0) {
+ getSelectionModel().setSelectionInterval(0, 0);
+ }
+ }
+ }
+
+ void setFilteringByInstanceExists(boolean value) {
+ if (value != myOnlyWithInstances) {
+ myOnlyWithInstances = value;
+ getRowSorter().allRowsChanged();
+ }
+ }
+
+ void setFilteringByDiffNonZero(boolean value) {
+ if (myOnlyWithDiff != value) {
+ myOnlyWithDiff = value;
+ getRowSorter().allRowsChanged();
+ }
+ }
+
+ void setFilteringByTrackingState(boolean value) {
+ if (myOnlyTracked != value) {
+ myOnlyTracked = value;
+ getRowSorter().allRowsChanged();
+ }
+ }
+
+ void setClassesAndUpdateCounts(@NotNull List classes, @NotNull long[] counts) {
+ assert classes.size() == counts.length;
+ ReferenceType selectedClass = myModel.getSelectedClassBeforeHided();
+ int newSelectedIndex = classes.indexOf(selectedClass);
+ boolean isInitialized = !myItems.isEmpty();
+ myItems = Collections.unmodifiableList(new ArrayList<>(classes));
+
+ for (int i = 0, size = classes.size(); i < size; i++) {
+ ReferenceType ref = classes.get(i);
+ DiffValue oldValue = isInitialized && !myCounts.containsKey(ref)
+ ? new DiffValue(0, 0)
+ : myCounts.getOrDefault(ref, myUnknownValue);
+ myCounts.put(ref, oldValue.update(counts[i]));
+ }
+
+ showContent();
+
+ if (newSelectedIndex != -1 && !myModel.isHided()) {
+ int ix = convertRowIndexToView(newSelectedIndex);
+ changeSelection(ix,
+ DiffViewTableModel.CLASSNAME_COLUMN_INDEX, false, false);
+ }
+
+ getRowSorter().allRowsChanged();
+ }
+
+ void hideContent() {
+ myModel.hide();
+ }
+
+ private void showContent() {
+ myModel.show();
+ }
+
+
+ @Nullable
+ @Override
+ public Object getData(@NonNls String dataId) {
+ if (SELECTED_CLASS_KEY.is(dataId)) {
+ return getSelectedClass();
+ }
+ if (DEBUG_SESSION_KEY.is(dataId)) {
+ return myDebugSession;
+ }
+ if (NEW_INSTANCES_PROVIDER_KEY.is(dataId)) {
+ ReferenceType selectedClass = getSelectedClass();
+ if (selectedClass != null) {
+ TrackerForNewInstances strategy = myParent.getStrategy(selectedClass);
+ if (strategy != null && strategy.isReady()) {
+ List newInstances = strategy.getNewInstances();
+ return (InstancesProvider)limit -> newInstances;
+ }
+ }
+ }
+
+ if (REF_COUNT_PROVIDER_KEY.is(dataId)) {
+ return myCountProvider;
+ }
+
+ return null;
+ }
+
+ @Override
+ public void dispose() {
+ }
+
+ @Nullable
+ private TrackingType getTrackingType(int row) {
+ ReferenceType ref = (ReferenceType)getValueAt(row, convertColumnIndexToView(DiffViewTableModel.CLASSNAME_COLUMN_INDEX));
+ return myInstancesTracker.getTrackingType(ref.name());
+ }
+
+ class DiffViewTableModel extends AbstractTableModelWithColumns {
+ final static int CLASSNAME_COLUMN_INDEX = 0;
+ final static int COUNT_COLUMN_INDEX = 1;
+ final static int DIFF_COLUMN_INDEX = 2;
+
+ // Workaround: save selection after content of classes table has been hided
+ private ReferenceType mySelectedClassWhenHided = null;
+ private boolean myIsWithContent = false;
+
+ DiffViewTableModel() {
+ super(new AbstractTableColumnDescriptor[]{
+ new AbstractTableColumnDescriptor("Class", ReferenceType.class) {
+ @Override
+ public Object getValue(int ix) {
+ return myItems.get(ix);
+ }
+ },
+ new AbstractTableColumnDescriptor("Count", Long.class) {
+ @Override
+ public Object getValue(int ix) {
+ return myCounts.getOrDefault(myItems.get(ix), myUnknownValue).myCurrentCount;
+ }
+ },
+ new AbstractTableColumnDescriptor("Diff", DiffValue.class) {
+ @Override
+ public Object getValue(int ix) {
+ return myCounts.getOrDefault(myItems.get(ix), myUnknownValue);
+ }
+ }
+ });
+ }
+
+ ReferenceType getSelectedClassBeforeHided() {
+ return mySelectedClassWhenHided;
+ }
+
+ void hide() {
+ if (myIsWithContent) {
+ mySelectedClassWhenHided = getSelectedClass();
+ myIsWithContent = false;
+ clearSelection();
+ fireTableDataChanged();
+ }
+ }
+
+ void show() {
+ if (!myIsWithContent) {
+ myIsWithContent = true;
+ getRowSorter().allRowsChanged();
+ }
+ }
+
+ boolean isHided() {
+ return !myIsWithContent;
+ }
+
+ @Override
+ public int getRowCount() {
+ return myIsWithContent ? myItems.size() : 0;
+ }
+ }
+
+ /**
+ * State transmissions for DiffValue and UnknownDiffValue
+ * unknown -> diff
+ * diff -> diff
+ *
+ * State descriptions:
+ * Unknown - instances count never executed
+ * Diff - actual value
+ */
+ private static class UnknownDiffValue extends DiffValue {
+ UnknownDiffValue() {
+ super(0);
+ }
+
+ @Override
+ boolean hasInstance() {
+ return true;
+ }
+
+ @Override
+ DiffValue update(long count) {
+ return new DiffValue(count);
+ }
+ }
+
+ private static class DiffValue implements Comparable {
+ private long myOldCount;
+
+ private long myCurrentCount;
+
+ DiffValue(long count) {
+ this(count, count);
+ }
+
+ DiffValue(long old, long current) {
+ myCurrentCount = current;
+ myOldCount = old;
+ }
+
+ DiffValue update(long count) {
+ myOldCount = myCurrentCount;
+ myCurrentCount = count;
+ return this;
+ }
+
+ boolean hasInstance() {
+ return myCurrentCount > 0;
+ }
+
+ long diff() {
+ return myCurrentCount - myOldCount;
+ }
+
+ @Override
+ public int compareTo(@NotNull DiffValue o) {
+ return Long.compare(diff(), o.diff());
+ }
+ }
+
+ private abstract class MyTableCellRenderer extends ColoredTableCellRenderer {
+ @Override
+ protected void customizeCellRenderer(JTable table, @Nullable Object value, boolean isSelected,
+ boolean hasFocus, int row, int column) {
+ column = convertColumnIndexToModel(column);
+ TrackingType trackingType = getTrackingType(row);
+
+ if (hasFocus) {
+ setBorder(EMPTY_BORDER);
+ }
+
+ if (trackingType != null && column == DiffViewTableModel.DIFF_COLUMN_INDEX) {
+ setIcon(AllIcons.Debugger.MemoryView.ClassTracked);
+ setTransparentIconBackground(true);
+ }
+
+ if (value != null) {
+ addText(value, isSelected, row);
+ }
+ }
+
+ protected abstract void addText(@NotNull Object value, boolean isSelected, int row);
+ }
+
+ private class MyClassColumnRenderer extends MyTableCellRenderer {
+ @Override
+ protected void addText(@NotNull Object value, boolean isSelected,
+ int row) {
+ String presentation = ((ReferenceType)value).name();
+ append(" ");
+ if (isSelected) {
+ FList textRanges = myMatcher.matchingFragments(presentation);
+ if (textRanges != null) {
+ SimpleTextAttributes attributes = new SimpleTextAttributes(getBackground(), getForeground(), null,
+ SimpleTextAttributes.STYLE_SEARCH_MATCH);
+ SpeedSearchUtil.appendColoredFragments(this, presentation, textRanges,
+ SimpleTextAttributes.REGULAR_ATTRIBUTES, attributes);
+ }
+ }
+ else {
+ append(String.format("%s", presentation), SimpleTextAttributes.REGULAR_ATTRIBUTES);
+ }
+ }
+ }
+
+ private class MyCountColumnRenderer extends MyTableCellRenderer {
+ @Override
+ protected void addText(@NotNull Object value, boolean isSelected,
+ int row) {
+ setTextAlign(SwingConstants.RIGHT);
+ append(value.toString());
+ }
+ }
+
+ private class MyDiffColumnRenderer extends MyTableCellRenderer {
+ private final SimpleTextAttributes myClickableCellAttributes =
+ new SimpleTextAttributes(SimpleTextAttributes.STYLE_UNDERLINE, JBColor.BLUE);
+
+ @Override
+ protected void addText(@NotNull Object value, boolean isSelected,
+ int row) {
+ setTextAlign(SwingConstants.RIGHT);
+
+ ReferenceType ref = myItems.get(convertRowIndexToModel(row));
+
+ long diff = myCountProvider.getDiffCount(ref);
+ String text = String.format("%s%d", diff > 0 ? "+" : "", diff);
+
+ int newInstancesCount = myCountProvider.getNewInstancesCount(ref);
+ if (newInstancesCount >= 0) {
+ if (newInstancesCount == diff) {
+ append(text, diff == 0 ? SimpleTextAttributes.REGULAR_ATTRIBUTES : myClickableCellAttributes);
+ }
+ else {
+ append(text, SimpleTextAttributes.REGULAR_ATTRIBUTES);
+ if (newInstancesCount != 0) {
+ append(String.format(" (%d)", newInstancesCount), myClickableCellAttributes);
+ }
+ }
+ }
+ else {
+ append(text, SimpleTextAttributes.REGULAR_ATTRIBUTES);
+ }
+ }
+ }
+}
diff --git a/java/debugger/impl/src/com/intellij/debugger/memory/ui/ExpressionEditorWithHistory.java b/java/debugger/impl/src/com/intellij/debugger/memory/ui/ExpressionEditorWithHistory.java
new file mode 100644
index 000000000000..87dbc415d098
--- /dev/null
+++ b/java/debugger/impl/src/com/intellij/debugger/memory/ui/ExpressionEditorWithHistory.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright 2000-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.debugger.memory.ui;
+
+import com.intellij.codeInsight.lookup.LookupManager;
+import com.intellij.debugger.engine.DebuggerUtils;
+import com.intellij.openapi.Disposable;
+import com.intellij.openapi.actionSystem.AnAction;
+import com.intellij.openapi.actionSystem.AnActionEvent;
+import com.intellij.openapi.actionSystem.CustomShortcutSet;
+import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.editor.ex.util.EditorUtil;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.ui.popup.PopupStep;
+import com.intellij.openapi.ui.popup.util.BaseListPopupStep;
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.search.GlobalSearchScope;
+import com.intellij.ui.ColoredListCellRenderer;
+import com.intellij.ui.SimpleTextAttributes;
+import com.intellij.ui.popup.list.ListPopupImpl;
+import com.intellij.xdebugger.XExpression;
+import com.intellij.xdebugger.evaluation.XDebuggerEditorsProvider;
+import com.intellij.xdebugger.impl.breakpoints.XExpressionImpl;
+import com.intellij.xdebugger.impl.ui.XDebuggerExpressionEditor;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import javax.swing.*;
+import java.util.List;
+
+class ExpressionEditorWithHistory extends XDebuggerExpressionEditor {
+ private static final String HISTORY_ID_PREFIX = "filtering";
+
+ ExpressionEditorWithHistory(final @NotNull Project project,
+ final @NotNull String className,
+ final @NotNull XDebuggerEditorsProvider debuggerEditorsProvider,
+ final @Nullable Disposable parentDisposable) {
+ super(project, debuggerEditorsProvider, HISTORY_ID_PREFIX + className, null,
+ XExpressionImpl.EMPTY_EXPRESSION, false, true, true);
+
+ new AnAction("InstancesWindow.ShowHistory") {
+ @Override
+ public void actionPerformed(AnActionEvent e) {
+ showHistory();
+ }
+
+ @Override
+ public void update(AnActionEvent e) {
+ e.getPresentation().setEnabled(LookupManager.getActiveLookup(getEditor()) == null);
+ }
+ }.registerCustomShortcutSet(CustomShortcutSet.fromString("DOWN"), getComponent(), parentDisposable);
+
+ new SwingWorker() {
+ @Override
+ protected Void doInBackground() throws Exception {
+ ApplicationManager.getApplication().runReadAction(() -> {
+ final PsiClass psiClass = DebuggerUtils.findClass(className,
+ project, GlobalSearchScope.allScope(project));
+ ApplicationManager.getApplication().invokeLater(() -> setContext(psiClass));
+ });
+ return null;
+ }
+ }.execute();
+ }
+
+ private void showHistory() {
+ List expressions = getRecentExpressions();
+ if (!expressions.isEmpty()) {
+ ListPopupImpl historyPopup = new ListPopupImpl(new BaseListPopupStep(null, expressions) {
+ @Override
+ public PopupStep onChosen(XExpression selectedValue, boolean finalChoice) {
+ setExpression(selectedValue);
+ requestFocusInEditor();
+ return FINAL_CHOICE;
+ }
+ }) {
+ @Override
+ protected ListCellRenderer getListElementRenderer() {
+ return new ColoredListCellRenderer() {
+ @Override
+ protected void customizeCellRenderer(@NotNull JList list, XExpression value, int index,
+ boolean selected, boolean hasFocus) {
+ append(value.getExpression(), SimpleTextAttributes.REGULAR_ATTRIBUTES);
+ }
+ };
+ }
+ };
+
+ historyPopup.getList().setFont(EditorUtil.getEditorFont());
+ historyPopup.showUnderneathOf(getEditorComponent());
+ }
+ }
+}
diff --git a/java/debugger/impl/src/com/intellij/debugger/memory/ui/FilteringProgressView.java b/java/debugger/impl/src/com/intellij/debugger/memory/ui/FilteringProgressView.java
new file mode 100644
index 000000000000..2372b5ba01ff
--- /dev/null
+++ b/java/debugger/impl/src/com/intellij/debugger/memory/ui/FilteringProgressView.java
@@ -0,0 +1,134 @@
+/*
+ * Copyright 2000-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.debugger.memory.ui;
+
+import com.intellij.debugger.memory.filtering.FilteringResult;
+import com.intellij.icons.AllIcons;
+import com.intellij.ui.JBProgressBar;
+import com.intellij.ui.components.JBLabel;
+import com.intellij.util.ui.UIUtil;
+import com.intellij.util.ui.components.BorderLayoutPanel;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+
+class FilteringProgressView extends BorderLayoutPanel {
+ private final static String LIMIT_REACHED_LABEL = "Limit has been reached";
+ private final static String INTERRUPTED_LABEL = "Filtering has been interrupted";
+
+ private final JBProgressBar myProgressBar = new JBProgressBar();
+ private final BorderLayoutPanel myProgressPanel = new BorderLayoutPanel();
+ private final JBLabel myStopButton = new JBLabel(UIUtil.isUnderDarcula()
+ ? AllIcons.Actions.Clean : AllIcons.Actions.CleanLight);
+ private final JBLabel myProgressText = new JBLabel();
+
+ private int myProceedCount = 0;
+ private int myErrorCount = 0;
+ private int myMatchedCount = 0;
+
+ private boolean myIsInProcess = false;
+
+ @Nullable
+ private FilteringResult myCompletionReason = null;
+
+ FilteringProgressView() {
+ myStopButton.setOpaque(true);
+ myProgressPanel.addToCenter(myProgressBar);
+ myProgressPanel.addToRight(myStopButton);
+ addToTop(myProgressText);
+ addToCenter(myProgressPanel);
+ }
+
+ void addStopActionListener(@NotNull Runnable listener) {
+ myStopButton.addMouseListener(new MouseAdapter() {
+ @Override
+ public void mouseClicked(MouseEvent e) {
+ listener.run();
+ }
+ });
+ }
+
+ void updateProgress(int proceedCount, int matchedCount, int errorCount) {
+ if (myIsInProcess) {
+ myProceedCount = proceedCount;
+ myMatchedCount = matchedCount;
+ myErrorCount = errorCount;
+ myProgressBar.setValue(myProceedCount);
+ myProgressText.setText(getDescription());
+ }
+ }
+
+ void start(int totalCount) {
+ reset();
+ myIsInProcess = true;
+ myProgressBar.setMinimum(0);
+ myProgressBar.setMaximum(totalCount);
+ myProgressBar.setValue(0);
+ myProgressText.setText(getDescription());
+ setProgressBarVisible(true);
+ }
+
+ void complete(@NotNull FilteringResult reason) {
+ if (!myIsInProcess) {
+ throw new IllegalStateException("First you need to start progress");
+ }
+
+ myIsInProcess = false;
+ myCompletionReason = reason;
+ myProgressText.setText(getDescription());
+ setProgressBarVisible(false);
+ }
+
+ private void reset() {
+ myIsInProcess = false;
+ myErrorCount = 0;
+ myProceedCount = 0;
+ myMatchedCount = 0;
+ myCompletionReason = null;
+ }
+
+ private void setProgressBarVisible(boolean value) {
+ myProgressPanel.setVisible(value);
+ }
+
+ private String getDescription() {
+ int total = myProgressBar.getMaximum();
+ String itemsInfo = String.format("Shown: %d / %d", myMatchedCount, total);
+ if (myIsInProcess || myCompletionReason == null) {
+ return itemsInfo;
+ }
+
+ switch (myCompletionReason) {
+ case ALL_CHECKED:
+ break;
+ case INTERRUPTED:
+ itemsInfo = String.format("%s (%s)", itemsInfo, INTERRUPTED_LABEL);
+ break;
+ case LIMIT_REACHED:
+ itemsInfo = String.format("%s (%s)", itemsInfo, LIMIT_REACHED_LABEL);
+ break;
+ }
+
+ if (!myIsInProcess && myErrorCount != 0) {
+ String errors = String.format("Errors: %d", myErrorCount);
+ return String.format("%s
%s", itemsInfo, errors);
+ }
+
+ return itemsInfo;
+ }
+}
diff --git a/java/debugger/impl/src/com/intellij/debugger/memory/ui/InstancesTree.java b/java/debugger/impl/src/com/intellij/debugger/memory/ui/InstancesTree.java
new file mode 100644
index 000000000000..8bd1c851482c
--- /dev/null
+++ b/java/debugger/impl/src/com/intellij/debugger/memory/ui/InstancesTree.java
@@ -0,0 +1,149 @@
+/*
+ * Copyright 2000-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.debugger.memory.ui;
+
+import com.intellij.debugger.ui.impl.watch.NodeDescriptorProvider;
+import com.intellij.debugger.ui.tree.NodeDescriptor;
+import com.intellij.debugger.ui.tree.ValueDescriptor;
+import com.intellij.openapi.actionSystem.DataKey;
+import com.intellij.openapi.project.Project;
+import com.intellij.ui.SimpleTextAttributes;
+import com.intellij.xdebugger.XDebugSession;
+import com.intellij.xdebugger.evaluation.XDebuggerEditorsProvider;
+import com.intellij.xdebugger.frame.*;
+import com.intellij.xdebugger.impl.actions.XDebuggerActions;
+import com.intellij.xdebugger.impl.frame.XValueMarkers;
+import com.intellij.xdebugger.impl.ui.XDebuggerUIConstants;
+import com.intellij.xdebugger.impl.ui.tree.XDebuggerTree;
+import com.intellij.xdebugger.impl.ui.tree.XDebuggerTreeState;
+import com.intellij.xdebugger.impl.ui.tree.nodes.XValueNodeImpl;
+import com.sun.jdi.ObjectReference;
+import com.sun.jdi.Value;
+import org.jetbrains.annotations.NonNls;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import javax.swing.tree.TreePath;
+import java.util.ArrayList;
+import java.util.List;
+
+public class InstancesTree extends XDebuggerTree {
+ public static final DataKey DEBUG_SESSION_DATA_KEY = DataKey.create("InstancesTree.DebugSession");
+ private final XValueNodeImpl myRoot;
+ private final Runnable myOnRootExpandAction;
+ private final XDebugSession myDebugSession;
+ private List myChildren;
+
+ InstancesTree(@NotNull Project project,
+ @NotNull XDebugSession debugSession,
+ @NotNull XDebuggerEditorsProvider editorsProvider,
+ @Nullable XValueMarkers valueMarkers,
+ @NotNull Runnable onRootExpand) {
+ super(project, editorsProvider, null, XDebuggerActions.INSPECT_TREE_POPUP_GROUP, valueMarkers);
+ myOnRootExpandAction = onRootExpand;
+ myRoot = new XValueNodeImpl(this, null, "root", new MyRootValue());
+ myDebugSession = debugSession;
+
+ myRoot.children();
+ setRoot(myRoot, false);
+ myRoot.setLeaf(false);
+ setSelectionRow(0);
+ expandNodesOnLoad(node -> node == myRoot);
+ }
+
+ void addChildren(@NotNull XValueChildrenList children, boolean last) {
+ if (myChildren == null) {
+ myChildren = new ArrayList<>();
+ }
+
+ myChildren.add(children);
+ myRoot.addChildren(children, last);
+ }
+
+ void rebuildTree(@NotNull RebuildPolicy policy, @NotNull XDebuggerTreeState state) {
+ if (policy == RebuildPolicy.RELOAD_INSTANCES) {
+ myChildren = null;
+ }
+
+ rebuildAndRestore(state);
+ }
+
+ void rebuildTree(@NotNull RebuildPolicy policy) {
+ rebuildTree(policy, XDebuggerTreeState.saveState(this));
+ }
+
+ void setInfoMessage(@SuppressWarnings("SameParameterValue") @NotNull String text) {
+ myChildren = null;
+ myRoot.clearChildren();
+ myRoot.setMessage(text, XDebuggerUIConstants.INFORMATION_MESSAGE_ICON, SimpleTextAttributes.REGULAR_ATTRIBUTES, null);
+ }
+
+ @Nullable
+ ObjectReference getSelectedReference() {
+ TreePath selectionPath = getSelectionPath();
+ Object selectedItem = selectionPath != null ? selectionPath.getLastPathComponent() : null;
+ if (selectedItem instanceof XValueNodeImpl) {
+ XValueNodeImpl xValueNode = (XValueNodeImpl) selectedItem;
+ XValue valueContainer = xValueNode.getValueContainer();
+
+ if (valueContainer instanceof NodeDescriptorProvider) {
+ NodeDescriptor descriptor = ((NodeDescriptorProvider) valueContainer).getDescriptor();
+
+ if (descriptor instanceof ValueDescriptor) {
+ Value value = ((ValueDescriptor) descriptor).getValue();
+
+ if (value instanceof ObjectReference) return (ObjectReference) value;
+ }
+ }
+ }
+
+ return null;
+ }
+
+ @Nullable
+ @Override
+ public Object getData(@NonNls String dataId) {
+ if (DEBUG_SESSION_DATA_KEY.is(dataId)) {
+ return myDebugSession;
+ }
+
+ return super.getData(dataId);
+ }
+
+ enum RebuildPolicy {
+ RELOAD_INSTANCES, ONLY_UPDATE_LABELS
+ }
+
+ private class MyRootValue extends XValue {
+ @Override
+ public void computeChildren(@NotNull XCompositeNode node) {
+ if (myChildren == null) {
+ myOnRootExpandAction.run();
+ } else {
+ for (XValueChildrenList children : myChildren) {
+ myRoot.addChildren(children, false);
+ }
+
+ myRoot.addChildren(XValueChildrenList.EMPTY, true);
+ }
+ }
+
+ @Override
+ public void computePresentation(@NotNull XValueNode node, @NotNull XValuePlace place) {
+ node.setPresentation(null, "", "", true);
+ }
+ }
+}
diff --git a/java/debugger/impl/src/com/intellij/debugger/memory/ui/InstancesWindow.java b/java/debugger/impl/src/com/intellij/debugger/memory/ui/InstancesWindow.java
new file mode 100644
index 000000000000..d9b0c548c413
--- /dev/null
+++ b/java/debugger/impl/src/com/intellij/debugger/memory/ui/InstancesWindow.java
@@ -0,0 +1,530 @@
+/*
+ * Copyright 2000-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.debugger.memory.ui;
+
+import com.intellij.debugger.DebuggerManager;
+import com.intellij.debugger.engine.DebugProcessImpl;
+import com.intellij.debugger.engine.JavaValue;
+import com.intellij.debugger.engine.SuspendContextImpl;
+import com.intellij.debugger.engine.evaluation.EvaluationContext;
+import com.intellij.debugger.engine.evaluation.EvaluationContextImpl;
+import com.intellij.debugger.engine.events.DebuggerContextCommandImpl;
+import com.intellij.debugger.memory.filtering.FilteringResult;
+import com.intellij.debugger.memory.filtering.FilteringTask;
+import com.intellij.debugger.memory.filtering.FilteringTaskCallback;
+import com.intellij.debugger.memory.utils.*;
+import com.intellij.debugger.ui.impl.watch.DebuggerTreeNodeImpl;
+import com.intellij.debugger.ui.impl.watch.MessageDescriptor;
+import com.intellij.debugger.ui.impl.watch.NodeManagerImpl;
+import com.intellij.debugger.ui.tree.NodeDescriptor;
+import com.intellij.openapi.Disposable;
+import com.intellij.openapi.actionSystem.*;
+import com.intellij.openapi.actionSystem.ex.AnActionListener;
+import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.ui.DialogWrapper;
+import com.intellij.openapi.util.Disposer;
+import com.intellij.openapi.wm.IdeFocusManager;
+import com.intellij.psi.search.GlobalSearchScope;
+import com.intellij.ui.DoubleClickListener;
+import com.intellij.ui.JBColor;
+import com.intellij.ui.components.JBLabel;
+import com.intellij.ui.components.JBPanel;
+import com.intellij.util.ui.JBDimension;
+import com.intellij.util.ui.JBUI;
+import com.intellij.util.ui.UIUtil;
+import com.intellij.util.ui.update.UiNotifyConnector;
+import com.intellij.xdebugger.XDebugSession;
+import com.intellij.xdebugger.XDebugSessionListener;
+import com.intellij.xdebugger.XExpression;
+import com.intellij.xdebugger.frame.XValue;
+import com.intellij.xdebugger.frame.XValueChildrenList;
+import com.intellij.xdebugger.impl.XDebugSessionImpl;
+import com.intellij.xdebugger.impl.actions.XDebuggerActionBase;
+import com.intellij.xdebugger.impl.frame.XValueMarkers;
+import com.intellij.xdebugger.impl.ui.XDebuggerExpressionEditor;
+import com.intellij.xdebugger.impl.ui.tree.ValueMarkup;
+import com.intellij.xdebugger.impl.ui.tree.XDebuggerTreeState;
+import com.intellij.xdebugger.impl.ui.tree.actions.XDebuggerTreeActionBase;
+import com.intellij.xdebugger.impl.ui.tree.nodes.XValueNodeImpl;
+import com.sun.jdi.ObjectReference;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.java.debugger.JavaDebuggerEditorsProvider;
+
+import javax.swing.*;
+import javax.swing.tree.TreeNode;
+import java.awt.*;
+import java.awt.event.MouseEvent;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+public class InstancesWindow extends DialogWrapper {
+ private static final Logger LOG = Logger.getInstance(InstancesWindow.class);
+
+ private static final int DEFAULT_WINDOW_WIDTH = 870;
+ private static final int DEFAULT_WINDOW_HEIGHT = 400;
+ private static final int FILTERING_BUTTON_ADDITIONAL_WIDTH = 30;
+ private static final int BORDER_LAYOUT_DEFAULT_GAP = 5;
+ private static final int DEFAULT_INSTANCES_LIMIT = 500000;
+
+ private final Project myProject;
+ private final XDebugSession myDebugSession;
+ private final InstancesProvider myInstancesProvider;
+ private final String myClassName;
+ private MyInstancesView myInstancesView;
+
+ public InstancesWindow(@NotNull XDebugSession session,
+ @NotNull InstancesProvider provider,
+ @NotNull String className) {
+ super(session.getProject(), false);
+
+ myProject = session.getProject();
+ myDebugSession = session;
+ myInstancesProvider = provider;
+ myClassName = className;
+
+ addWarningMessage(null);
+ myDebugSession.addSessionListener(new XDebugSessionListener() {
+ @Override
+ public void sessionStopped() {
+ ApplicationManager.getApplication().invokeLater(() -> close(OK_EXIT_CODE));
+ }
+ }, myDisposable);
+ setModal(false);
+ init();
+ JRootPane root = myInstancesView.getRootPane();
+ root.setDefaultButton(myInstancesView.myFilterButton);
+ }
+
+ private void addWarningMessage(@Nullable String message) {
+ String warning = message == null ? "" : String.format(". Warning: %s", message);
+ setTitle(String.format("Instances of %s%s", myClassName, warning));
+ }
+
+ @NotNull
+ @Override
+ protected String getDimensionServiceKey() {
+ return "#org.jetbrains.debugger.memory.view.InstancesWindow";
+ }
+
+ @Nullable
+ @Override
+ protected JComponent createCenterPanel() {
+ myInstancesView = new MyInstancesView();
+ myInstancesView.setPreferredSize(
+ new JBDimension(DEFAULT_WINDOW_WIDTH, DEFAULT_WINDOW_HEIGHT));
+ return myInstancesView;
+ }
+
+ @Nullable
+ @Override
+ protected JComponent createSouthPanel() {
+ JComponent comp = super.createSouthPanel();
+ if (comp != null) {
+ comp.add(myInstancesView.myProgress, BorderLayout.WEST);
+ }
+
+ return comp;
+ }
+
+ @NotNull
+ @Override
+ protected Action[] createActions() {
+ return new Action[]{new DialogWrapperExitAction("Close", CLOSE_EXIT_CODE)};
+ }
+
+ private class MyInstancesView extends JBPanel implements Disposable {
+ private static final int MAX_TREE_NODE_COUNT = 2000;
+ private static final int FILTERING_CHUNK_SIZE = 50;
+
+ private static final int MAX_DURATION_TO_UPDATE_TREE_SECONDS = 3;
+ private static final int FILTERING_PROGRESS_UPDATING_MIN_DELAY_MILLIS = 17; // ~ 60 fps
+
+ private final InstancesTree myInstancesTree;
+ private final XDebuggerExpressionEditor myFilterConditionEditor;
+ private final XDebugSessionListener myDebugSessionListener = new MySessionListener();
+
+ private final MyNodeManager myNodeManager = new MyNodeManager(myProject);
+
+ private final JButton myFilterButton = new JButton("Filter");
+ private final FilteringProgressView myProgress = new FilteringProgressView();
+
+ private final AnActionListener.Adapter myActionListener = new MyActionListener();
+ private final Object myFilteringTaskLock = new Object();
+
+ private boolean myIsAndroidVM = false;
+
+ private volatile MyFilteringWorker myFilteringTask = null;
+
+ MyInstancesView() {
+ super(new BorderLayout(0, JBUI.scale(BORDER_LAYOUT_DEFAULT_GAP)));
+
+ Disposer.register(InstancesWindow.this.myDisposable, this);
+ XValueMarkers markers = getValueMarkers();
+ ActionManager.getInstance().addAnActionListener(myActionListener, InstancesWindow.this.myDisposable);
+ myDebugSession.addSessionListener(myDebugSessionListener, InstancesWindow.this.myDisposable);
+ JavaDebuggerEditorsProvider editorsProvider = new JavaDebuggerEditorsProvider();
+
+ myFilterConditionEditor = new ExpressionEditorWithHistory(myProject, myClassName,
+ editorsProvider, InstancesWindow.this.myDisposable);
+
+ myFilterButton.setBorder(BorderFactory.createEmptyBorder());
+ Dimension filteringButtonSize = myFilterConditionEditor.getEditorComponent().getPreferredSize();
+ filteringButtonSize.width = JBUI.scale(FILTERING_BUTTON_ADDITIONAL_WIDTH) +
+ myFilterButton.getPreferredSize().width;
+ myFilterButton.setPreferredSize(filteringButtonSize);
+
+ JBPanel filteringPane = new JBPanel(new BorderLayout(JBUI.scale(BORDER_LAYOUT_DEFAULT_GAP), 0));
+ JBLabel sideEffectsWarning = new JBLabel("Warning: filtering may have side effects", SwingConstants.RIGHT);
+ sideEffectsWarning.setBorder(JBUI.Borders.empty(1, 0, 0, 0));
+ sideEffectsWarning.setComponentStyle(UIUtil.ComponentStyle.SMALL);
+ sideEffectsWarning.setFontColor(UIUtil.FontColor.BRIGHTER);
+
+ filteringPane.add(new JBLabel("Condition:"), BorderLayout.WEST);
+ filteringPane.add(myFilterConditionEditor.getComponent(), BorderLayout.CENTER);
+ filteringPane.add(myFilterButton, BorderLayout.EAST);
+ filteringPane.add(sideEffectsWarning, BorderLayout.SOUTH);
+
+ myProgress.addStopActionListener(this::cancelFilteringTask);
+
+ myInstancesTree = new InstancesTree(myProject, myDebugSession, editorsProvider, markers, this::updateInstances);
+
+ myFilterButton.addActionListener(e -> {
+ String expression = myFilterConditionEditor.getExpression().getExpression();
+ if (!expression.isEmpty()) {
+ myFilterConditionEditor.saveTextInHistory();
+ }
+
+ myFilterButton.setEnabled(false);
+ myInstancesTree.rebuildTree(InstancesTree.RebuildPolicy.RELOAD_INSTANCES);
+ });
+
+
+ StackFrameList list = new StackFrameList(myProject,
+ Collections.emptyList(),
+ GlobalSearchScope.allScope(myProject));
+
+ list.addListSelectionListener(e -> list.navigateToSelectedValue(false));
+ new DoubleClickListener() {
+ @Override
+ protected boolean onDoubleClick(MouseEvent event) {
+ list.navigateToSelectedValue(true);
+ return true;
+ }
+ }.installOn(list);
+
+ InstancesWithStackFrameView instancesWithStackFrame = new InstancesWithStackFrameView(myDebugSession,
+ myInstancesTree, list, myClassName);
+
+ add(filteringPane, BorderLayout.NORTH);
+ add(instancesWithStackFrame.getComponent(), BorderLayout.CENTER);
+
+ JComponent focusedComponent = myFilterConditionEditor.getEditorComponent();
+ UiNotifyConnector.doWhenFirstShown(focusedComponent, () ->
+ IdeFocusManager.findInstanceByComponent(focusedComponent)
+ .requestFocus(focusedComponent, true));
+ }
+
+ @Override
+ public void dispose() {
+ cancelFilteringTask();
+ Disposer.dispose(myInstancesTree);
+ }
+
+ private void updateInstances() {
+ DebugProcessImpl debugProcess = (DebugProcessImpl)DebuggerManager.getInstance(myProject)
+ .getDebugProcess(myDebugSession.getDebugProcess().getProcessHandler());
+
+ cancelFilteringTask();
+
+ debugProcess.getManagerThread().schedule(new DebuggerContextCommandImpl(debugProcess.getDebuggerContext()) {
+ @Override
+ public Priority getPriority() {
+ return Priority.LOWEST;
+ }
+
+ @Override
+ public void threadAction(@NotNull SuspendContextImpl suspendContext) {
+ myIsAndroidVM = AndroidUtil.isAndroidVM(debugProcess.getVirtualMachineProxy().getVirtualMachine());
+ int limit = myIsAndroidVM
+ ? AndroidUtil.ANDROID_INSTANCES_LIMIT
+ : DEFAULT_INSTANCES_LIMIT;
+ List instances = myInstancesProvider.getInstances(limit + 1);
+
+ EvaluationContextImpl evaluationContext = debugProcess
+ .getDebuggerContext().createEvaluationContext();
+
+ if (instances.size() > limit) {
+ addWarningMessage(String.format("Not all instances will be loaded (only %d)", limit));
+ instances = instances.subList(0, limit);
+ }
+
+ if (evaluationContext != null) {
+ synchronized (myFilteringTaskLock) {
+ myFilteringTask = new MyFilteringWorker(instances, myFilterConditionEditor.getExpression(), evaluationContext);
+ myFilteringTask.execute();
+ }
+ }
+ }
+ });
+ }
+
+ private void cancelFilteringTask() {
+ if (myFilteringTask != null) {
+ synchronized (myFilteringTaskLock) {
+ if (myFilteringTask != null) {
+ myFilteringTask.cancel();
+ myFilteringTask = null;
+ }
+ }
+ }
+ }
+
+ private XValueMarkers getValueMarkers() {
+ return myDebugSession instanceof XDebugSessionImpl
+ ? ((XDebugSessionImpl)myDebugSession).getValueMarkers()
+ : null;
+ }
+
+ private class MySessionListener implements XDebugSessionListener {
+ private volatile XDebuggerTreeState myTreeState = null;
+
+ @Override
+ public void sessionResumed() {
+ ApplicationManager.getApplication().invokeLater(() -> {
+ myTreeState = XDebuggerTreeState.saveState(myInstancesTree);
+ cancelFilteringTask();
+
+ myInstancesTree.setInfoMessage(
+ "The application is running");
+ });
+ }
+
+ @Override
+ public void sessionPaused() {
+ ApplicationManager.getApplication().invokeLater(() -> {
+ myProgress.setVisible(true);
+ myInstancesTree.rebuildTree(InstancesTree.RebuildPolicy.RELOAD_INSTANCES, myTreeState);
+ });
+ }
+ }
+
+ private class MyActionListener extends AnActionListener.Adapter {
+ @Override
+ public void beforeActionPerformed(AnAction action, DataContext dataContext, AnActionEvent event) {
+ if (dataContext.getData(PlatformDataKeys.CONTEXT_COMPONENT) == myInstancesView.myInstancesTree &&
+ (isAddToWatchesAction(action) || isEvaluateExpressionAction(action))) {
+ final XValueNodeImpl selectedNode = XDebuggerTreeActionBase.getSelectedNode(dataContext);
+ final XValueMarkers markers = getValueMarkers();
+
+ if (markers != null && selectedNode != null) {
+
+ TreeNode currentNode = selectedNode;
+ while (!myInstancesTree.getRoot().equals(currentNode.getParent())) {
+ currentNode = currentNode.getParent();
+ }
+
+ final XValue valueContainer = ((XValueNodeImpl)currentNode).getValueContainer();
+
+ final String expression = valueContainer.getEvaluationExpression();
+ if (expression != null) {
+ markers.markValue(valueContainer,
+ new ValueMarkup(expression.replace("@", ""), new JBColor(0, 0), null));
+ }
+
+ ApplicationManager.getApplication().invokeLater(() -> myInstancesTree
+ .rebuildTree(InstancesTree.RebuildPolicy.ONLY_UPDATE_LABELS));
+ }
+ }
+ }
+
+ private boolean isAddToWatchesAction(AnAction action) {
+ final String className = action.getClass().getSimpleName();
+ return action instanceof XDebuggerTreeActionBase && className.equals("XAddToWatchesAction");
+ }
+
+ private boolean isEvaluateExpressionAction(AnAction action) {
+ final String className = action.getClass().getSimpleName();
+ return action instanceof XDebuggerActionBase && className.equals("EvaluateAction");
+ }
+ }
+
+ private class MyFilteringCallback implements FilteringTaskCallback {
+ private final ErrorsValueGroup myErrorsGroup = new ErrorsValueGroup();
+ private final EvaluationContextImpl myEvaluationContext;
+
+ private long myFilteringStartedTime;
+
+ private int myProceedCount = 0;
+ private int myMatchedCount = 0;
+ private int myErrorsCount = 0;
+
+ private long myLastTreeUpdatingTime;
+ private long myLastProgressUpdatingTime;
+
+ public MyFilteringCallback(@NotNull EvaluationContextImpl evaluationContext) {
+ myEvaluationContext = evaluationContext;
+ }
+
+ private XValueChildrenList myChildren = new XValueChildrenList();
+
+ @Override
+ public void started(int total) {
+ myFilteringStartedTime = System.nanoTime();
+ myLastTreeUpdatingTime = myFilteringStartedTime;
+ myLastProgressUpdatingTime = System.nanoTime();
+ ApplicationManager.getApplication().invokeLater(() -> myProgress.start(total));
+ }
+
+ @NotNull
+ @Override
+ public Action matched(@NotNull ObjectReference ref) {
+ final JavaValue val = new InstanceJavaValue(new InstanceValueDescriptor(myProject, ref),
+ myEvaluationContext, myNodeManager);
+ myMatchedCount++;
+ myProceedCount++;
+ myChildren.add(val);
+ updateProgress();
+ updateTree();
+
+ return myMatchedCount < MAX_TREE_NODE_COUNT ? Action.CONTINUE : Action.STOP;
+ }
+
+ @NotNull
+ @Override
+ public Action notMatched(@NotNull ObjectReference ref) {
+ myProceedCount++;
+ updateProgress();
+
+ return Action.CONTINUE;
+ }
+
+ @NotNull
+ @Override
+ public Action error(@NotNull ObjectReference ref, @NotNull String description) {
+ final JavaValue val = new InstanceJavaValue(new InstanceValueDescriptor(myProject, ref),
+ myEvaluationContext, myNodeManager);
+ myErrorsGroup.addErrorValue(description, val);
+ myProceedCount++;
+ myErrorsCount++;
+ updateProgress();
+ return Action.CONTINUE;
+ }
+
+ @Override
+ public void completed(@NotNull FilteringResult reason) {
+ if (!myErrorsGroup.isEmpty()) {
+ myChildren.addBottomGroup(myErrorsGroup);
+ }
+
+ final long duration = System.nanoTime() - myFilteringStartedTime;
+ LOG.info(String.format("Filtering completed in %d ms for %d instances",
+ TimeUnit.NANOSECONDS.toMillis(duration),
+ myProceedCount));
+
+ final int proceed = myProceedCount;
+ final int matched = myMatchedCount;
+ final int errors = myErrorsCount;
+ final XValueChildrenList childrenList = myChildren;
+ ApplicationManager.getApplication().invokeLater(() -> {
+ myProgress.updateProgress(proceed, matched, errors);
+ myInstancesTree.addChildren(childrenList, true);
+ myFilterButton.setEnabled(true);
+ myProgress.complete(reason);
+ });
+ }
+
+ private void updateProgress() {
+ final long now = System.nanoTime();
+ if (now - myLastProgressUpdatingTime > TimeUnit.MILLISECONDS.toNanos(FILTERING_PROGRESS_UPDATING_MIN_DELAY_MILLIS)) {
+ final int proceed = myProceedCount;
+ final int matched = myMatchedCount;
+ final int errors = myErrorsCount;
+ ApplicationManager.getApplication().invokeLater(() -> myProgress.updateProgress(proceed, matched, errors));
+ myLastProgressUpdatingTime = now;
+ }
+ }
+
+ private void updateTree() {
+ final long now = System.nanoTime();
+ final int newChildrenCount = myChildren.size();
+ if (newChildrenCount >= FILTERING_CHUNK_SIZE ||
+ (newChildrenCount > 0 && now - myLastTreeUpdatingTime > TimeUnit.SECONDS.toNanos(MAX_DURATION_TO_UPDATE_TREE_SECONDS))) {
+ final XValueChildrenList children = myChildren;
+ ApplicationManager.getApplication().invokeLater(() -> myInstancesTree.addChildren(children, false));
+ myChildren = new XValueChildrenList();
+ myLastTreeUpdatingTime = System.nanoTime();
+ }
+ }
+ }
+
+ private class MyFilteringWorker extends SwingWorker {
+ private final FilteringTask myTask;
+
+ MyFilteringWorker(@NotNull List refs,
+ @NotNull XExpression expression,
+ @NotNull EvaluationContextImpl evaluationContext) {
+ if (refs.size() != 0) {
+ DebugProcessImpl debugProcess =
+ (DebugProcessImpl)DebuggerManager.getInstance(myProject).getDebugProcess(myDebugSession.getDebugProcess().getProcessHandler());
+ myTask = new FilteringTask(refs.get(0).referenceType(), debugProcess, expression, refs,
+ new MyFilteringCallback(evaluationContext));
+ }
+ else {
+ myTask = null;
+ }
+ }
+
+ @Override
+ protected Void doInBackground() throws Exception {
+ if (myTask != null) {
+ myTask.run();
+ }
+
+ return null;
+ }
+
+ public void cancel() {
+ myTask.cancel();
+ super.cancel(false);
+ }
+ }
+ }
+
+ private final static class MyNodeManager extends NodeManagerImpl {
+ MyNodeManager(Project project) {
+ super(project, null);
+ }
+
+ @Override
+ public DebuggerTreeNodeImpl createNode(final NodeDescriptor descriptor, EvaluationContext evaluationContext) {
+ return new DebuggerTreeNodeImpl(null, descriptor);
+ }
+
+ @Override
+ public DebuggerTreeNodeImpl createMessageNode(MessageDescriptor descriptor) {
+ return new DebuggerTreeNodeImpl(null, descriptor);
+ }
+
+ @Override
+ public DebuggerTreeNodeImpl createMessageNode(String message) {
+ return new DebuggerTreeNodeImpl(null, new MessageDescriptor(message));
+ }
+ }
+}
diff --git a/java/debugger/impl/src/com/intellij/debugger/memory/ui/InstancesWithStackFrameView.java b/java/debugger/impl/src/com/intellij/debugger/memory/ui/InstancesWithStackFrameView.java
new file mode 100644
index 000000000000..234d6330f7a1
--- /dev/null
+++ b/java/debugger/impl/src/com/intellij/debugger/memory/ui/InstancesWithStackFrameView.java
@@ -0,0 +1,150 @@
+/*
+ * Copyright 2000-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.debugger.memory.ui;
+
+import com.intellij.icons.AllIcons;
+import com.intellij.openapi.actionSystem.AnAction;
+import com.intellij.openapi.actionSystem.AnActionEvent;
+import com.intellij.ui.JBSplitter;
+import com.intellij.ui.components.JBLabel;
+import com.intellij.ui.components.JBScrollPane;
+import com.intellij.ui.components.labels.ActionLink;
+import com.intellij.xdebugger.XDebugSession;
+import com.sun.jdi.ObjectReference;
+import org.jetbrains.annotations.NotNull;
+import com.intellij.debugger.memory.component.CreationPositionTracker;
+import com.intellij.debugger.memory.component.InstancesTracker;
+import com.intellij.debugger.memory.event.InstancesTrackerListener;
+import com.intellij.debugger.memory.tracking.TrackingType;
+import com.intellij.debugger.memory.utils.StackFrameItem;
+
+import javax.swing.*;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+
+class InstancesWithStackFrameView {
+ private static final float DEFAULT_SPLITTER_PROPORTION = 0.7f;
+ private static final String EMPTY_TEXT_WHEN_ITEM_NOT_SELECTED = "Select instance to see stack frame";
+ private static final String EMPTY_TEXT_WHEN_STACK_NOT_FOUND = "No stack frame for this instance";
+ private static final String TEXT_FOR_ARRAYS = "Arrays could not be tracked";
+ private static final List EMPTY_FRAME = Collections.emptyList();
+
+ private float myHidedProportion;
+
+ private final JBSplitter mySplitter = new JBSplitter(false, DEFAULT_SPLITTER_PROPORTION);
+ private boolean myIsHided = false;
+
+ InstancesWithStackFrameView(@NotNull XDebugSession debugSession, @NotNull InstancesTree tree,
+ @NotNull StackFrameList list, String className) {
+ mySplitter.setFirstComponent(new JBScrollPane(tree));
+
+ list.setEmptyText(EMPTY_TEXT_WHEN_ITEM_NOT_SELECTED);
+ JLabel stackTraceLabel;
+ if (isArrayType(className)) {
+ stackTraceLabel = new JBLabel(TEXT_FOR_ARRAYS, SwingConstants.CENTER);
+ }
+ else {
+ ActionLink actionLink = new ActionLink("Enable tracking for new instances",
+ AllIcons.Debugger.MemoryView.ClassTracked,
+ new AnAction() {
+ @Override
+ public void actionPerformed(AnActionEvent e) {
+ InstancesTracker.getInstance(debugSession.getProject())
+ .add(className, TrackingType.CREATION);
+ }
+ });
+
+ actionLink.setHorizontalAlignment(SwingConstants.CENTER);
+ actionLink.setPaintUnderline(false);
+ stackTraceLabel = actionLink;
+ }
+
+ mySplitter.setSplitterProportionKey("InstancesWithStackFrameView.SplitterKey");
+
+ JComponent stackComponent = new JBScrollPane(list);
+
+ CreationPositionTracker tracker = CreationPositionTracker.getInstance(debugSession.getProject());
+ InstancesTracker instancesTracker = InstancesTracker.getInstance(debugSession.getProject());
+ instancesTracker.addTrackerListener(new InstancesTrackerListener() {
+ @Override
+ public void classChanged(@NotNull String name, @NotNull TrackingType type) {
+ if (Objects.equals(className, name) && type == TrackingType.CREATION) {
+ mySplitter.setSecondComponent(stackComponent);
+ }
+ }
+
+ @Override
+ public void classRemoved(@NotNull String name) {
+ if (Objects.equals(name, className)) {
+ mySplitter.setSecondComponent(stackTraceLabel);
+ }
+ }
+ }, tree);
+
+ mySplitter.setSecondComponent(instancesTracker.isTracked(className) ? stackComponent : stackTraceLabel);
+
+ mySplitter.setHonorComponentsMinimumSize(false);
+ myHidedProportion = DEFAULT_SPLITTER_PROPORTION;
+
+ tree.addTreeSelectionListener(e -> {
+ ObjectReference ref = tree.getSelectedReference();
+ if (ref != null && tracker != null) {
+ List stack = tracker.getStack(debugSession, ref);
+ if (stack != null) {
+ list.setFrame(stack);
+ if (mySplitter.getProportion() == 1.f) {
+ mySplitter.setProportion(DEFAULT_SPLITTER_PROPORTION);
+ }
+ return;
+ }
+ list.setEmptyText(EMPTY_TEXT_WHEN_STACK_NOT_FOUND);
+ }
+ else {
+ list.setEmptyText(EMPTY_TEXT_WHEN_ITEM_NOT_SELECTED);
+ }
+
+ list.setFrame(EMPTY_FRAME);
+ });
+ }
+
+ JComponent getComponent() {
+ return mySplitter;
+ }
+
+ private static boolean isArrayType(@NotNull String className) {
+ return className.contains("[]");
+ }
+
+ @SuppressWarnings("unused")
+ private void hideStackFrame() {
+ if (!myIsHided) {
+ myHidedProportion = mySplitter.getProportion();
+ mySplitter.getSecondComponent().setVisible(false);
+ mySplitter.setProportion(1.f);
+ myIsHided = true;
+ }
+ }
+
+ @SuppressWarnings("unused")
+ private void showStackFrame() {
+ if (myIsHided) {
+ mySplitter.getSecondComponent().setVisible(true);
+ mySplitter.setProportion(myHidedProportion);
+ myIsHided = false;
+ }
+ }
+}
diff --git a/java/debugger/impl/src/com/intellij/debugger/memory/ui/StackFrameList.java b/java/debugger/impl/src/com/intellij/debugger/memory/ui/StackFrameList.java
new file mode 100644
index 000000000000..7201ffd57987
--- /dev/null
+++ b/java/debugger/impl/src/com/intellij/debugger/memory/ui/StackFrameList.java
@@ -0,0 +1,154 @@
+/*
+ * Copyright 2000-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.debugger.memory.ui;
+
+import com.intellij.debugger.engine.DebuggerUtils;
+import com.intellij.execution.filters.OpenFileHyperlinkInfo;
+import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.editor.ScrollType;
+import com.intellij.openapi.fileEditor.FileEditor;
+import com.intellij.openapi.fileEditor.FileEditorManager;
+import com.intellij.openapi.fileEditor.OpenFileDescriptor;
+import com.intellij.openapi.fileEditor.impl.FileEditorManagerImpl;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.search.GlobalSearchScope;
+import com.intellij.psi.util.PsiUtilCore;
+import com.intellij.ui.ColoredListCellRenderer;
+import com.intellij.ui.SimpleTextAttributes;
+import com.intellij.ui.components.JBList;
+import org.jetbrains.annotations.NotNull;
+import com.intellij.debugger.memory.utils.StackFrameItem;
+
+import javax.swing.*;
+import java.util.ArrayList;
+import java.util.List;
+
+class StackFrameList extends JBList {
+ private static final char ANONYMOUS_CLASS_DELIMITER = '$';
+ private static final MyOpenFilesState myEditorState = new MyOpenFilesState();
+
+ private List myStackFrames;
+ private final Project myProject;
+ private final GlobalSearchScope myScope;
+ private final MyListModel myModel = new MyListModel();
+
+ StackFrameList(@NotNull Project project,
+ @NotNull List stack,
+ @NotNull GlobalSearchScope searchScope) {
+ super();
+
+ myStackFrames = new ArrayList<>(stack);
+ myProject = project;
+ myScope = searchScope;
+
+ setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+
+ setModel(myModel);
+
+ setCellRenderer(new ColoredListCellRenderer() {
+ @Override
+ protected void customizeCellRenderer(@NotNull JList list,
+ StackFrameItem value, int index, boolean isSelected, boolean hasFocus) {
+ append(String.format("%s:%d, %s", value.methodName(), value.line(), value.className()));
+ String packageName = value.packageName();
+ if (packageName.trim().isEmpty() /*!StringUtils.isEmpty(packageName)*/) {
+ append(String.format(" (%s)", value.packageName()), SimpleTextAttributes.GRAYED_ITALIC_ATTRIBUTES);
+ }
+ }
+ });
+ }
+
+ void setFrame(@NotNull List stack) {
+ myModel.update(stack);
+ }
+
+ void navigateToSelectedValue(boolean focusOnEditor) {
+ StackFrameItem selectedValue = getSelectedValue();
+ if (selectedValue != null) {
+ navigateToFrame(selectedValue, focusOnEditor);
+ }
+ }
+
+ private void navigateToFrame(@NotNull StackFrameItem frame, boolean focusOnEditor) {
+ String path = frame.path();
+ int anonymousClassDelimiterIndex = path.indexOf(ANONYMOUS_CLASS_DELIMITER);
+ int pathLength = anonymousClassDelimiterIndex > 0 ? anonymousClassDelimiterIndex : path.length();
+ path = path.substring(0, pathLength);
+ PsiClass psiClass = DebuggerUtils.findClass(path, myProject, myScope);
+ if (psiClass != null) {
+ ApplicationManager.getApplication().runReadAction(() -> {
+ PsiElement navigationElement = psiClass.getNavigationElement();
+ VirtualFile file = PsiUtilCore.getVirtualFile(navigationElement);
+
+ if (file == null) {
+ file = psiClass.getContainingFile().getVirtualFile();
+ }
+
+ OpenFileHyperlinkInfo info =
+ new OpenFileHyperlinkInfo(myProject, file, frame.line() - 1);
+ OpenFileDescriptor descriptor = info.getDescriptor();
+ if (descriptor != null) {
+ FileEditorManagerImpl manager = (FileEditorManagerImpl)FileEditorManager.getInstance(myProject);
+ VirtualFile lastFile = myEditorState.myLastOpenedFile;
+ if (myEditorState.myIsNeedToCloseLastOpenedFile && lastFile != null &&
+ manager.isFileOpen(lastFile) && !lastFile.equals(descriptor.getFile())) {
+ manager.closeFile(myEditorState.myLastOpenedFile, false, true);
+ }
+
+ descriptor.setScrollType(ScrollType.CENTER);
+ descriptor.setUseCurrentWindow(true);
+
+ if (lastFile == null || !lastFile.equals(descriptor.getFile())) {
+ myEditorState.myIsNeedToCloseLastOpenedFile = !manager.isFileOpen(descriptor.getFile());
+ }
+
+ descriptor.navigateInEditor(myProject, focusOnEditor);
+ FileEditor[] editors = manager.getEditors(descriptor.getFile());
+ if (editors.length != 0) {
+ myEditorState.myLastOpenedFile = descriptor.getFile();
+ }
+ }
+ });
+ }
+ }
+
+ private static class MyOpenFilesState {
+ VirtualFile myLastOpenedFile;
+ boolean myIsNeedToCloseLastOpenedFile;
+ }
+
+ private class MyListModel extends AbstractListModel {
+
+ void update(@NotNull List newFrame) {
+ fireIntervalRemoved(this, 0, getSize());
+ myStackFrames = newFrame;
+ fireIntervalAdded(this, 0, getSize());
+ }
+
+ @Override
+ public int getSize() {
+ return myStackFrames.size();
+ }
+
+ @Override
+ public StackFrameItem getElementAt(int index) {
+ return myStackFrames.get(index);
+ }
+ }
+}
diff --git a/java/debugger/impl/src/com/intellij/debugger/memory/ui/StackFramePopup.java b/java/debugger/impl/src/com/intellij/debugger/memory/ui/StackFramePopup.java
new file mode 100644
index 000000000000..3bf5a6d0d61f
--- /dev/null
+++ b/java/debugger/impl/src/com/intellij/debugger/memory/ui/StackFramePopup.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright 2000-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.debugger.memory.ui;
+
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.ui.popup.JBPopup;
+import com.intellij.openapi.ui.popup.JBPopupFactory;
+import com.intellij.psi.search.GlobalSearchScope;
+import org.jetbrains.annotations.NotNull;
+import com.intellij.debugger.memory.utils.StackFrameItem;
+
+import java.util.List;
+
+public class StackFramePopup {
+ private final Project myProject;
+ private final List myStackFrame;
+ private final GlobalSearchScope myScope;
+
+ public StackFramePopup(@NotNull Project project,
+ @NotNull List stack,
+ @NotNull GlobalSearchScope searchScope) {
+ myProject = project;
+ myStackFrame = stack;
+ myScope = searchScope;
+ }
+
+ public void show() {
+ StackFrameList list = new StackFrameList(myProject, myStackFrame, myScope);
+ list.addListSelectionListener(e -> {
+ if (!e.getValueIsAdjusting()) {
+ list.navigateToSelectedValue(false);
+ }
+ });
+
+ JBPopup popup = JBPopupFactory.getInstance().createListPopupBuilder(list)
+ .setTitle("Select stack frame")
+ .setAutoSelectIfEmpty(true)
+ .setResizable(false)
+ .setItemChoosenCallback(() -> list.navigateToSelectedValue(true))
+ .createPopup();
+
+ list.setSelectedIndex(1);
+ popup.showInFocusCenter();
+ }
+}
diff --git a/java/debugger/impl/src/com/intellij/debugger/memory/utils/AbstractTableColumnDescriptor.java b/java/debugger/impl/src/com/intellij/debugger/memory/utils/AbstractTableColumnDescriptor.java
new file mode 100644
index 000000000000..c651a142e716
--- /dev/null
+++ b/java/debugger/impl/src/com/intellij/debugger/memory/utils/AbstractTableColumnDescriptor.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2000-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.debugger.memory.utils;
+
+public abstract class AbstractTableColumnDescriptor implements AbstractTableModelWithColumns.TableColumnDescriptor {
+ private final String myName;
+ private final Class myClass;
+ protected AbstractTableColumnDescriptor(String name, Class elementClass) {
+ myName = name;
+ myClass = elementClass;
+ }
+
+ @Override
+ public Class getColumnClass() {
+ return myClass;
+ }
+
+
+ @Override
+ public String getName() {
+ return myName;
+ }
+}
diff --git a/java/debugger/impl/src/com/intellij/debugger/memory/utils/AbstractTableModelWithColumns.java b/java/debugger/impl/src/com/intellij/debugger/memory/utils/AbstractTableModelWithColumns.java
new file mode 100644
index 000000000000..d14633c11473
--- /dev/null
+++ b/java/debugger/impl/src/com/intellij/debugger/memory/utils/AbstractTableModelWithColumns.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2000-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.debugger.memory.utils;
+
+import javax.swing.table.AbstractTableModel;
+
+public abstract class AbstractTableModelWithColumns extends AbstractTableModel {
+
+ private final TableColumnDescriptor[] myColumnDescriptors;
+ public AbstractTableModelWithColumns(TableColumnDescriptor[] descriptors) {
+ myColumnDescriptors = descriptors;
+ }
+
+ @Override
+ public Class getColumnClass(int columnIndex) {
+ return myColumnDescriptors[columnIndex].getColumnClass();
+ }
+
+ @Override
+ public String getColumnName(int column) {
+ return myColumnDescriptors[column].getName();
+ }
+
+ @Override
+ public int getColumnCount() {
+ return myColumnDescriptors.length;
+ }
+
+ @Override
+ public Object getValueAt(int rowIndex, int columnIndex) {
+ return myColumnDescriptors[columnIndex].getValue(rowIndex);
+ }
+
+ interface TableColumnDescriptor {
+ Class getColumnClass();
+ Object getValue(int ix);
+ String getName();
+ }
+}
diff --git a/java/debugger/impl/src/com/intellij/debugger/memory/utils/AndroidUtil.java b/java/debugger/impl/src/com/intellij/debugger/memory/utils/AndroidUtil.java
new file mode 100644
index 000000000000..4b22c6f9df6c
--- /dev/null
+++ b/java/debugger/impl/src/com/intellij/debugger/memory/utils/AndroidUtil.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2000-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.debugger.memory.utils;
+
+import com.sun.jdi.VirtualMachine;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Locale;
+
+public class AndroidUtil {
+ public static final int ANDROID_COUNT_BY_CLASSES_BATCH_SIZE = 500;
+ public static final int ANDROID_INSTANCES_LIMIT = 30000;
+
+ public static boolean isAndroidVM(@NotNull VirtualMachine vm) {
+ return vm.name().toLowerCase(Locale.ENGLISH).contains("dalvik");
+ }
+}
diff --git a/java/debugger/impl/src/com/intellij/debugger/memory/utils/ErrorsValueGroup.java b/java/debugger/impl/src/com/intellij/debugger/memory/utils/ErrorsValueGroup.java
new file mode 100644
index 000000000000..50ba2cf355ef
--- /dev/null
+++ b/java/debugger/impl/src/com/intellij/debugger/memory/utils/ErrorsValueGroup.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2000-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.debugger.memory.utils;
+
+import com.intellij.icons.AllIcons;
+import com.intellij.util.containers.HashMap;
+import com.intellij.xdebugger.frame.XCompositeNode;
+import com.intellij.xdebugger.frame.XNamedValue;
+import com.intellij.xdebugger.frame.XValueChildrenList;
+import com.intellij.xdebugger.frame.XValueGroup;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import javax.swing.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class ErrorsValueGroup extends XValueGroup {
+ private final Map> myErrorMessage2ValueMap = new HashMap<>();
+
+ public ErrorsValueGroup() {
+ super("Errors");
+ }
+
+ public void addErrorValue(@NotNull String message, @NotNull XNamedValue value) {
+ List lst;
+ if (!myErrorMessage2ValueMap.containsKey(message)) {
+ myErrorMessage2ValueMap.put(message, new ArrayList<>());
+ }
+
+ lst = myErrorMessage2ValueMap.get(message);
+ lst.add(value);
+ }
+
+ public boolean isEmpty() {
+ return myErrorMessage2ValueMap.isEmpty();
+ }
+
+ @Nullable
+ @Override
+ public Icon getIcon() {
+ return AllIcons.General.Error;
+ }
+
+ @Override
+ public void computeChildren(@NotNull XCompositeNode node) {
+ XValueChildrenList lst = new XValueChildrenList();
+ myErrorMessage2ValueMap.keySet().forEach(s -> lst.addTopGroup(new MyErrorsValueGroup(s)));
+ node.addChildren(lst, true);
+ }
+
+ private class MyErrorsValueGroup extends XValueGroup {
+
+ @Override
+ public void computeChildren(@NotNull XCompositeNode node) {
+ XValueChildrenList lst = new XValueChildrenList();
+ String name = getName();
+ myErrorMessage2ValueMap.get(name).forEach(lst::add);
+ node.addChildren(lst, true);
+ }
+
+ MyErrorsValueGroup(@NotNull String name) {
+ super(name);
+ }
+ }
+}
diff --git a/java/debugger/impl/src/com/intellij/debugger/memory/utils/InstanceJavaValue.java b/java/debugger/impl/src/com/intellij/debugger/memory/utils/InstanceJavaValue.java
new file mode 100644
index 000000000000..a7d2042bce74
--- /dev/null
+++ b/java/debugger/impl/src/com/intellij/debugger/memory/utils/InstanceJavaValue.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2000-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.debugger.memory.utils;
+
+import com.intellij.debugger.engine.JavaValue;
+import com.intellij.debugger.engine.evaluation.EvaluationContextImpl;
+import com.intellij.debugger.ui.impl.watch.NodeManagerImpl;
+import com.intellij.debugger.ui.impl.watch.ValueDescriptorImpl;
+import com.sun.jdi.ObjectReference;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public class InstanceJavaValue extends JavaValue {
+ public InstanceJavaValue(@NotNull ValueDescriptorImpl valueDescriptor,
+ @NotNull EvaluationContextImpl evaluationContext,
+ NodeManagerImpl nodeManager) {
+ super(null, valueDescriptor, evaluationContext, nodeManager, false);
+ }
+
+ @Nullable
+ @Override
+ public String getEvaluationExpression() {
+ ObjectReference ref = ((ObjectReference)getDescriptor().getValue());
+ return NamesUtils.getUniqueName(ref);
+ }
+
+ @Override
+ public boolean canNavigateToSource() {
+ return false;
+ }
+}
diff --git a/java/debugger/impl/src/com/intellij/debugger/memory/utils/InstanceValueDescriptor.java b/java/debugger/impl/src/com/intellij/debugger/memory/utils/InstanceValueDescriptor.java
new file mode 100644
index 000000000000..76202a68253e
--- /dev/null
+++ b/java/debugger/impl/src/com/intellij/debugger/memory/utils/InstanceValueDescriptor.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2000-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.debugger.memory.utils;
+
+import com.intellij.debugger.DebuggerContext;
+import com.intellij.debugger.engine.ContextUtil;
+import com.intellij.debugger.engine.evaluation.EvaluateException;
+import com.intellij.debugger.engine.evaluation.EvaluationContextImpl;
+import com.intellij.debugger.ui.impl.watch.ValueDescriptorImpl;
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.JavaPsiFacade;
+import com.intellij.psi.PsiElementFactory;
+import com.intellij.psi.PsiExpression;
+import com.sun.jdi.ArrayReference;
+import com.sun.jdi.ObjectReference;
+import com.sun.jdi.Value;
+
+public class InstanceValueDescriptor extends ValueDescriptorImpl {
+
+ public InstanceValueDescriptor(Project project, Value value) {
+ super(project, value);
+ }
+
+ @Override
+ public String calcValueName() {
+ ObjectReference ref = ((ObjectReference) getValue());
+ if (ref instanceof ArrayReference) {
+ ArrayReference arrayReference = (ArrayReference) ref;
+ return NamesUtils.getArrayUniqueName(arrayReference);
+ }
+ return NamesUtils.getUniqueName(ref);
+ }
+
+ @Override
+ public Value calcValue(EvaluationContextImpl evaluationContext) throws EvaluateException {
+ return getValue();
+ }
+
+ @Override
+ public boolean isShowIdLabel() {
+ return false;
+ }
+
+ @Override
+ public PsiExpression getDescriptorEvaluation(DebuggerContext debuggerContext) throws EvaluateException {
+ PsiElementFactory elementFactory = JavaPsiFacade.getInstance(myProject).getElementFactory();
+ ObjectReference ref = ((ObjectReference) getValue());
+ String name = NamesUtils.getUniqueName(ref).replace("@", "");
+ String presentation = String.format("%s_DebugLabel", name);
+
+ return elementFactory.createExpressionFromText(presentation, ContextUtil.getContextElement(debuggerContext));
+ }
+}
diff --git a/jps/jps-builders/src/org/jetbrains/jps/javac/ast/JavacTreeScannerSink.java b/java/debugger/impl/src/com/intellij/debugger/memory/utils/InstancesProvider.java
similarity index 69%
rename from jps/jps-builders/src/org/jetbrains/jps/javac/ast/JavacTreeScannerSink.java
rename to java/debugger/impl/src/com/intellij/debugger/memory/utils/InstancesProvider.java
index 04569efe57e7..159c5884e5ff 100644
--- a/jps/jps-builders/src/org/jetbrains/jps/javac/ast/JavacTreeScannerSink.java
+++ b/java/debugger/impl/src/com/intellij/debugger/memory/utils/InstancesProvider.java
@@ -13,14 +13,14 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.jetbrains.jps.javac.ast;
+package com.intellij.debugger.memory.utils;
-import org.jetbrains.jps.javac.ast.api.JavacDef;
-import org.jetbrains.jps.javac.ast.api.JavacRef;
+import com.sun.jdi.ObjectReference;
+import org.jetbrains.annotations.NotNull;
-interface JavacTreeScannerSink {
+import java.util.List;
- void sinkReference(JavacRef.JavacSymbolRefBase ref);
-
- void sinkDeclaration(JavacDef def);
+public interface InstancesProvider {
+ @NotNull
+ List getInstances(int limit);
}
diff --git a/java/debugger/impl/src/com/intellij/debugger/memory/utils/KeyboardUtils.java b/java/debugger/impl/src/com/intellij/debugger/memory/utils/KeyboardUtils.java
new file mode 100644
index 000000000000..0ae37a822941
--- /dev/null
+++ b/java/debugger/impl/src/com/intellij/debugger/memory/utils/KeyboardUtils.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2000-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.debugger.memory.utils;
+
+import java.awt.event.KeyEvent;
+
+public class KeyboardUtils {
+ public static boolean isEnterKey(int keyCode) {
+ return keyCode == KeyEvent.VK_ENTER;
+ }
+
+ public static boolean isUpDownKey(int keyCode) {
+ return keyCode == KeyEvent.VK_UP || keyCode == KeyEvent.VK_DOWN;
+ }
+
+ public static boolean isBackSpace(int keyCode) {
+ return keyCode == KeyEvent.VK_BACK_SPACE;
+ }
+
+ public static boolean isCharacter(int keyCode) {
+ return KeyEvent.getKeyText(keyCode).length() == 1;
+ }
+}
diff --git a/java/debugger/impl/src/com/intellij/debugger/memory/utils/LowestPriorityCommand.java b/java/debugger/impl/src/com/intellij/debugger/memory/utils/LowestPriorityCommand.java
new file mode 100644
index 000000000000..757b990a826d
--- /dev/null
+++ b/java/debugger/impl/src/com/intellij/debugger/memory/utils/LowestPriorityCommand.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2000-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.debugger.memory.utils;
+
+import com.intellij.debugger.engine.SuspendContextImpl;
+import com.intellij.debugger.engine.events.SuspendContextCommandImpl;
+import org.jetbrains.annotations.Nullable;
+
+public class LowestPriorityCommand extends SuspendContextCommandImpl {
+ protected LowestPriorityCommand(@Nullable SuspendContextImpl suspendContext) {
+ super(suspendContext);
+ }
+
+ @Override
+ protected void commandCancelled() {
+ }
+
+ @Override
+ public Priority getPriority() {
+ return Priority.LOWEST;
+ }
+}
diff --git a/java/debugger/impl/src/com/intellij/debugger/memory/utils/NamesUtils.java b/java/debugger/impl/src/com/intellij/debugger/memory/utils/NamesUtils.java
new file mode 100644
index 000000000000..eec5e949ba72
--- /dev/null
+++ b/java/debugger/impl/src/com/intellij/debugger/memory/utils/NamesUtils.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2000-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.debugger.memory.utils;
+
+import com.intellij.openapi.util.text.StringUtil;
+import com.sun.jdi.ArrayReference;
+import com.sun.jdi.ObjectReference;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.regex.Pattern;
+
+class NamesUtils {
+ @NotNull
+ static String getUniqueName(@NotNull ObjectReference ref) {
+ String shortName = StringUtil.getShortName(ref.referenceType().name());
+ String name = shortName.replace("[]", "Array");
+ return String.format("%s@%d", name, ref.uniqueID());
+ }
+
+ @NotNull
+ static String getArrayUniqueName(@NotNull ArrayReference ref) {
+ String shortName = StringUtil.getShortName(ref.referenceType().name());
+ int length = ref.length();
+
+ String name = shortName.replaceFirst(Pattern.quote("[]"), String.format("[%d]", length));
+ return String.format("%s@%d", name, ref.uniqueID());
+ }
+}
diff --git a/java/debugger/impl/src/com/intellij/debugger/memory/utils/SingleAlarmWithMutableDelay.java b/java/debugger/impl/src/com/intellij/debugger/memory/utils/SingleAlarmWithMutableDelay.java
new file mode 100644
index 000000000000..7537abbb6d38
--- /dev/null
+++ b/java/debugger/impl/src/com/intellij/debugger/memory/utils/SingleAlarmWithMutableDelay.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2000-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.debugger.memory.utils;
+
+import com.intellij.openapi.Disposable;
+import com.intellij.util.Alarm;
+import org.jetbrains.annotations.NotNull;
+
+public class SingleAlarmWithMutableDelay extends Alarm {
+ private final Runnable myTask;
+ private volatile int myDelay;
+ public SingleAlarmWithMutableDelay(@NotNull Runnable task, @NotNull Disposable parentDisposable) {
+ super(ThreadToUse.POOLED_THREAD, parentDisposable);
+ myTask = task;
+ }
+
+ public void setDelay(int value) {
+ myDelay = value;
+ }
+
+ public void cancelAndRequest() {
+ if(!isDisposed()) {
+ cancelAllRequests();
+ addRequest(myTask, myDelay);
+ }
+ }
+}
diff --git a/java/debugger/impl/src/com/intellij/debugger/memory/utils/StackFrameItem.java b/java/debugger/impl/src/com/intellij/debugger/memory/utils/StackFrameItem.java
new file mode 100644
index 000000000000..43093813158c
--- /dev/null
+++ b/java/debugger/impl/src/com/intellij/debugger/memory/utils/StackFrameItem.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2000-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.debugger.memory.utils;
+
+import com.intellij.debugger.engine.evaluation.EvaluateException;
+import com.intellij.debugger.jdi.StackFrameProxyImpl;
+import com.intellij.debugger.jdi.ThreadReferenceProxyImpl;
+import com.intellij.openapi.util.text.StringUtil;
+import com.sun.jdi.Location;
+import one.util.streamex.StreamEx;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+
+public class StackFrameItem {
+ private final String myFilePath;
+ private final String myMethodName;
+ private final int myLineNumber;
+
+ public StackFrameItem(@NotNull String path, @NotNull String methodName, int line) {
+ myFilePath = path.replace('\\', '.');
+ myMethodName = methodName;
+ myLineNumber = line;
+ }
+
+ @NotNull
+ public String path() {
+ return myFilePath;
+ }
+
+ @NotNull
+ public String methodName() {
+ return myMethodName;
+ }
+
+ @NotNull
+ public String className() {
+ return StringUtil.getShortName(myFilePath);
+ }
+
+ @NotNull
+ public String packageName() {
+ return StringUtil.getPackageName(myFilePath);
+ }
+
+ public int line() {
+ return myLineNumber;
+ }
+
+ public static List createFrames(ThreadReferenceProxyImpl threadReferenceProxy) throws EvaluateException {
+ List stack = threadReferenceProxy == null ? null : threadReferenceProxy.frames();
+
+ if (stack != null) {
+ return StreamEx.of(stack).map(frame -> {
+ try {
+ Location loc = frame.location();
+ return new StackFrameItem(loc.declaringType().name(), loc.method().name(), loc.lineNumber());
+ }
+ catch (EvaluateException e) {
+ return null;
+ }
+ }).nonNull().toList();
+ }
+ return Collections.emptyList();
+ }
+}
diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointWithHighlighter.java b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointWithHighlighter.java
index 3fea367d86f4..32cb304ae987 100644
--- a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointWithHighlighter.java
+++ b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointWithHighlighter.java
@@ -42,7 +42,6 @@ import com.intellij.util.StringBuilderSpinAllocator;
import com.intellij.xdebugger.XDebuggerManager;
import com.intellij.xdebugger.XSourcePosition;
import com.intellij.xdebugger.breakpoints.XBreakpoint;
-import com.intellij.xdebugger.breakpoints.XBreakpointManager;
import com.intellij.xdebugger.breakpoints.XLineBreakpoint;
import com.intellij.xml.CommonXmlStrings;
import com.sun.jdi.Location;
@@ -307,7 +306,7 @@ public abstract class BreakpointWithHighlighter {
@@ -338,11 +337,9 @@ public abstract class BreakpointWithHighlighter
getCategory();
- public boolean isVisible() {
+ protected boolean isVisible() {
return myVisible;
}
diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/RunToCursorBreakpoint.java b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/RunToCursorBreakpoint.java
index e9d1fffd1924..d872c34763a9 100644
--- a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/RunToCursorBreakpoint.java
+++ b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/RunToCursorBreakpoint.java
@@ -15,6 +15,7 @@
*/
package com.intellij.debugger.ui.breakpoints;
+import com.intellij.debugger.DebuggerBundle;
import com.intellij.debugger.SourcePosition;
import com.intellij.debugger.engine.DebugProcessImpl;
import com.intellij.openapi.project.Project;
@@ -24,6 +25,7 @@ import com.intellij.psi.PsiManager;
import com.intellij.xdebugger.XDebuggerUtil;
import com.intellij.xdebugger.XSourcePosition;
import com.intellij.xdebugger.breakpoints.XLineBreakpointType;
+import com.sun.jdi.event.LocatableEvent;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.java.debugger.breakpoints.properties.JavaLineBreakpointProperties;
@@ -102,7 +104,12 @@ public class RunToCursorBreakpoint extends LineBreakpoint>> CAPTURED_STACKS = Key.create("CAPTURED_STACKS");
+ private static final int MAX_STORED_STACKS = 1000;
+
+ public StackCapturingLineBreakpoint(Project project, DebugProcessImpl debugProcess, @NotNull SourcePosition pos) {
+ super(project, pos, false);
+ myDebugProcess = debugProcess;
+ }
+
+ @Override
+ public boolean processLocatableEvent(SuspendContextCommandImpl action, LocatableEvent event) throws EventProcessingException {
+ try {
+ SuspendContextImpl suspendContext = action.getSuspendContext();
+ if (suspendContext != null) {
+ Map> stacks = myDebugProcess.getUserData(CAPTURED_STACKS);
+ if (stacks == null) {
+ stacks = new LinkedHashMap>() {
+ @Override
+ protected boolean removeEldestEntry(Map.Entry eldest) {
+ return size() > MAX_STORED_STACKS;
+ }
+ };
+ myDebugProcess.putUserData(CAPTURED_STACKS, stacks);
+ }
+ Value key = ContainerUtil.getFirstItem(suspendContext.getFrameProxy().getArgumentValues());
+ stacks.put(key, StackFrameItem.createFrames(suspendContext.getThread()));
+ }
+ }
+ catch (EvaluateException ignored) {
+ }
+ return false;
+ }
+}
diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/impl/watch/CompilingEvaluator.java b/java/debugger/impl/src/com/intellij/debugger/ui/impl/watch/CompilingEvaluator.java
index 6a7c25653a0e..75ab401f215e 100644
--- a/java/debugger/impl/src/com/intellij/debugger/ui/impl/watch/CompilingEvaluator.java
+++ b/java/debugger/impl/src/com/intellij/debugger/ui/impl/watch/CompilingEvaluator.java
@@ -79,12 +79,16 @@ public abstract class CompilingEvaluator implements ExpressionEvaluator {
public Value evaluate(final EvaluationContext evaluationContext) throws EvaluateException {
DebugProcess process = evaluationContext.getDebugProcess();
- ClassLoaderReference classLoader = ClassLoadingUtils.getClassLoader(evaluationContext, process);
+ EvaluationContextImpl autoLoadContext = ((EvaluationContextImpl)evaluationContext).createEvaluationContext(evaluationContext.getThisObject());
+ autoLoadContext.setAutoLoadClasses(true);
+
+ ClassLoaderReference classLoader = ClassLoadingUtils.getClassLoader(autoLoadContext, process);
+ autoLoadContext.setClassLoader(classLoader);
String version = ((VirtualMachineProxyImpl)process.getVirtualMachineProxy()).version();
Collection classes = compile(JdkVersionUtil.getVersion(version));
- defineClasses(classes, evaluationContext, process, classLoader);
+ defineClasses(classes, autoLoadContext, process, classLoader);
try {
// invoke base evaluator on call code
@@ -99,8 +103,7 @@ public abstract class CompilingEvaluator implements ExpressionEvaluator {
return factory.getEvaluatorBuilder().build(factory.createCodeFragment(callCode, copyContext, myProject), position);
}
});
- ((EvaluationContextImpl)evaluationContext).setClassLoader(classLoader);
- return evaluator.evaluate(evaluationContext);
+ return evaluator.evaluate(autoLoadContext);
}
catch (Exception e) {
throw new EvaluateException("Error during generated code invocation " + e, e);
diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/impl/watch/EvaluationDescriptor.java b/java/debugger/impl/src/com/intellij/debugger/ui/impl/watch/EvaluationDescriptor.java
index a84617b9aabe..fb96be1ed0bc 100644
--- a/java/debugger/impl/src/com/intellij/debugger/ui/impl/watch/EvaluationDescriptor.java
+++ b/java/debugger/impl/src/com/intellij/debugger/ui/impl/watch/EvaluationDescriptor.java
@@ -74,13 +74,12 @@ public abstract class EvaluationDescriptor extends ValueDescriptorImpl {
PsiElement psiContext = ContextUtil.getContextElement(evaluationContext, position);
ExpressionEvaluator evaluator = DebuggerInvocationUtil.commitAndRunReadAction(myProject, () -> {
+ PsiCodeFragment code = getEvaluationCode(thisEvaluationContext);
try {
- return DebuggerUtilsEx.findAppropriateCodeFragmentFactory(getEvaluationText(), psiContext)
- .getEvaluatorBuilder()
- .build(getEvaluationCode(thisEvaluationContext), position);
+ return DebuggerUtilsEx.findAppropriateCodeFragmentFactory(getEvaluationText(), psiContext).getEvaluatorBuilder().build(code, position);
}
catch (UnsupportedExpressionException ex) {
- ExpressionEvaluator eval = CompilingEvaluatorImpl.create(myProject, psiContext, this::createCodeFragment);
+ ExpressionEvaluator eval = CompilingEvaluatorImpl.create(myProject, code.getContext(), element -> code);
if (eval != null) {
return eval;
}
diff --git a/java/execution/openapi/src/com/intellij/execution/filters/ExceptionExFilterFactory.java b/java/execution/openapi/src/com/intellij/execution/filters/ExceptionExFilterFactory.java
index 7abd7fe1061e..30651f7d8ba7 100644
--- a/java/execution/openapi/src/com/intellij/execution/filters/ExceptionExFilterFactory.java
+++ b/java/execution/openapi/src/com/intellij/execution/filters/ExceptionExFilterFactory.java
@@ -74,17 +74,16 @@ public class ExceptionExFilterFactory implements ExceptionFilterFactory {
final int lineStartOffset = copiedFragment.getLineStartOffset(i);
final int lineEndOffset = copiedFragment.getLineEndOffset(i);
- String text = copiedFragment.getText(new TextRange(lineStartOffset, lineEndOffset));
- if (!text.contains(".java:")) continue;
- Trinity info = visited.get(text);
+ String lineText = copiedFragment.getText(new TextRange(lineStartOffset, lineEndOffset));
+ if (!lineText.contains(".java:")) continue;
+ Trinity info = visited.get(lineText);
if (info == emptyInfo) continue;
if (info == null) {
info = emptyInfo;
AccessToken token = ApplicationManager.getApplication().acquireReadActionLock();
try {
- worker.execute(text, lineEndOffset);
- Result result = worker.getResult();
+ Result result = worker.execute(lineText, lineEndOffset);
if (result == null) continue;
HyperlinkInfo hyperlinkInfo = result.getHyperlinkInfo();
if (!(hyperlinkInfo instanceof FileHyperlinkInfo)) continue;
@@ -105,7 +104,7 @@ public class ExceptionExFilterFactory implements ExceptionFilterFactory {
}
finally {
token.finish();
- visited.put(text, info);
+ visited.put(lineText, info);
}
}
int off = startOffset + lineStartOffset;
diff --git a/java/execution/openapi/src/com/intellij/execution/filters/ExceptionFilter.java b/java/execution/openapi/src/com/intellij/execution/filters/ExceptionFilter.java
index 24b2bb252e4b..750d95d28268 100644
--- a/java/execution/openapi/src/com/intellij/execution/filters/ExceptionFilter.java
+++ b/java/execution/openapi/src/com/intellij/execution/filters/ExceptionFilter.java
@@ -26,9 +26,9 @@ public class ExceptionFilter implements Filter, DumbAware {
myCache = new ExceptionInfoCache(scope);
}
+ @Override
public Result applyFilter(final String line, final int textEndOffset) {
ExceptionWorker worker = new ExceptionWorker(myCache);
- worker.execute(line, textEndOffset);
- return worker.getResult();
+ return worker.execute(line, textEndOffset);
}
}
diff --git a/java/idea-ui/src/com/intellij/ide/projectWizard/ModuleNameLocationComponent.java b/java/idea-ui/src/com/intellij/ide/projectWizard/ModuleNameLocationComponent.java
index 7516376d6eba..0f428ae8083b 100644
--- a/java/idea-ui/src/com/intellij/ide/projectWizard/ModuleNameLocationComponent.java
+++ b/java/idea-ui/src/com/intellij/ide/projectWizard/ModuleNameLocationComponent.java
@@ -35,6 +35,7 @@ import com.intellij.openapi.util.io.FileUtil;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.ui.DocumentAdapter;
import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
import javax.swing.*;
import javax.swing.event.DocumentEvent;
@@ -65,7 +66,23 @@ public class ModuleNameLocationComponent {
myWizardContext = wizardContext;
}
- public void updateDataModel(AbstractModuleBuilder moduleBuilder) {
+ @Nullable
+ public AbstractModuleBuilder getModuleBuilder() {
+ return ((AbstractModuleBuilder)myWizardContext.getProjectBuilder());
+ }
+
+ public boolean validate() throws ConfigurationException {
+ AbstractModuleBuilder builder = getModuleBuilder();
+ if (builder != null && !builder.validateModuleName(getModuleName())) return false;
+ if (!validateModulePaths()) return false;
+ validateExistingModuleName();
+ return true;
+ }
+
+ public void updateDataModel() {
+ AbstractModuleBuilder moduleBuilder = getModuleBuilder();
+ if (moduleBuilder == null) return;
+
final String moduleName = getModuleName();
moduleBuilder.setName(moduleName);
moduleBuilder.setModuleFilePath(
@@ -195,8 +212,10 @@ public class ModuleNameLocationComponent {
}
}
+ private void validateExistingModuleName() throws ConfigurationException {
+ Project project = myWizardContext.getProject();
+ if (project == null) return;
- public void validateExistingModuleName(Project project) throws ConfigurationException {
final String moduleName = getModuleName();
final Module module;
final ProjectStructureConfigurable fromConfigurable = ProjectStructureConfigurable.getInstance(project);
@@ -211,7 +230,7 @@ public class ModuleNameLocationComponent {
}
}
- public boolean validateModulePaths() throws ConfigurationException {
+ private boolean validateModulePaths() throws ConfigurationException {
final String moduleName = getModuleName();
final String moduleFileDirectory = myModuleFileLocation.getText();
if (moduleFileDirectory.length() == 0) {
diff --git a/java/idea-ui/src/com/intellij/ide/projectWizard/ProjectSettingsStep.java b/java/idea-ui/src/com/intellij/ide/projectWizard/ProjectSettingsStep.java
index 8d4c974f6d36..75d04629c0ae 100644
--- a/java/idea-ui/src/com/intellij/ide/projectWizard/ProjectSettingsStep.java
+++ b/java/idea-ui/src/com/intellij/ide/projectWizard/ProjectSettingsStep.java
@@ -135,15 +135,11 @@ public class ProjectSettingsStep extends ModuleWizardStep implements SettingsSte
@Override
public boolean validate() throws ConfigurationException {
-
if (myWizardContext.isCreatingNewProject()) {
if (!myNamePathComponent.validateNameAndPath(myWizardContext, myFormatPanel.isDefault())) return false;
}
- if (!myModuleNameLocationComponent.validateModulePaths()) return false;
- if (!myWizardContext.isCreatingNewProject()) {
- myModuleNameLocationComponent.validateExistingModuleName(myWizardContext.getProject());
- }
+ if (!myModuleNameLocationComponent.validate()) return false;
if (mySettingsStep != null) {
return mySettingsStep.validate();
@@ -163,17 +159,15 @@ public class ProjectSettingsStep extends ModuleWizardStep implements SettingsSte
@Override
public void updateDataModel() {
-
myWizardContext.setProjectName(myNamePathComponent.getNameValue());
myWizardContext.setProjectFileDirectory(myNamePathComponent.getPath());
myFormatPanel.updateData(myWizardContext);
- ModuleBuilder moduleBuilder = (ModuleBuilder)myWizardContext.getProjectBuilder();
- if (moduleBuilder != null) {
- myModuleNameLocationComponent.updateDataModel(moduleBuilder);
- if (moduleBuilder instanceof TemplateModuleBuilder) {
- myWizardContext.setProjectStorageFormat(StorageScheme.DIRECTORY_BASED);
- }
+ myModuleNameLocationComponent.updateDataModel();
+
+ ProjectBuilder moduleBuilder = myWizardContext.getProjectBuilder();
+ if (moduleBuilder instanceof TemplateModuleBuilder) {
+ myWizardContext.setProjectStorageFormat(StorageScheme.DIRECTORY_BASED);
}
if (mySettingsStep != null) {
diff --git a/java/idea-ui/src/com/intellij/ide/util/newProjectWizard/SelectTemplateStep.java b/java/idea-ui/src/com/intellij/ide/util/newProjectWizard/SelectTemplateStep.java
index a252541d9b2e..0af5eb782400 100644
--- a/java/idea-ui/src/com/intellij/ide/util/newProjectWizard/SelectTemplateStep.java
+++ b/java/idea-ui/src/com/intellij/ide/util/newProjectWizard/SelectTemplateStep.java
@@ -211,10 +211,7 @@ public class SelectTemplateStep extends ModuleWizardStep implements SettingsStep
if (!myNamePathComponent.validateNameAndPath(myWizardContext, myFormatPanel.isDefault())) return false;
}
- if (!myModuleNameLocationComponent.validateModulePaths()) return false;
- if (!myWizardContext.isCreatingNewProject()) {
- myModuleNameLocationComponent.validateExistingModuleName(myWizardContext.getProject());
- }
+ if (!myModuleNameLocationComponent.validate()) return false;
ValidationInfo info = template.validateSettings();
if (info != null) {
@@ -243,17 +240,15 @@ public class SelectTemplateStep extends ModuleWizardStep implements SettingsStep
@Override
public void updateDataModel() {
-
myWizardContext.setProjectBuilder(myModuleBuilder);
myWizardContext.setProjectName(myNamePathComponent.getNameValue());
myWizardContext.setProjectFileDirectory(myNamePathComponent.getPath());
myFormatPanel.updateData(myWizardContext);
- if (myModuleBuilder != null) {
- myModuleNameLocationComponent.updateDataModel(myModuleBuilder);
- if (myModuleBuilder instanceof TemplateModuleBuilder) {
- myWizardContext.setProjectStorageFormat(StorageScheme.DIRECTORY_BASED);
- }
+ myModuleNameLocationComponent.updateDataModel();
+
+ if (myModuleBuilder instanceof TemplateModuleBuilder) {
+ myWizardContext.setProjectStorageFormat(StorageScheme.DIRECTORY_BASED);
}
if (mySettingsStep != null) {
diff --git a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightClassUtil.java b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightClassUtil.java
index fc1bc4b71533..c57b9cd0ccff 100644
--- a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightClassUtil.java
+++ b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightClassUtil.java
@@ -279,7 +279,7 @@ public class HighlightClassUtil {
if (directory instanceof PsiDirectory) {
String simpleName = aClass.getName();
PsiDirectory subDirectory = ((PsiDirectory)directory).findSubdirectory(simpleName);
- if (subDirectory != null && simpleName.equals(subDirectory.getName())) {
+ if (subDirectory != null && simpleName.equals(subDirectory.getName()) && PsiTreeUtil.findChildOfType(subDirectory, PsiJavaFile.class) != null) {
String message = JavaErrorMessages.message("class.clashes.with.package", name);
TextRange range = HighlightNamesUtil.getClassDeclarationTextRange(aClass);
return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(range).descriptionAndTooltip(message).create();
diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/SimplifyStreamApiCallChainsInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/SimplifyStreamApiCallChainsInspection.java
index d1bbf5327cb9..f012f3eb8b5a 100644
--- a/java/java-analysis-impl/src/com/intellij/codeInspection/SimplifyStreamApiCallChainsInspection.java
+++ b/java/java-analysis-impl/src/com/intellij/codeInspection/SimplifyStreamApiCallChainsInspection.java
@@ -24,6 +24,7 @@ import com.intellij.psi.codeStyle.JavaCodeStyleManager;
import com.intellij.psi.impl.PsiDiamondTypeUtil;
import com.intellij.psi.util.*;
import com.siyeh.ig.psiutils.BoolUtils;
+import com.siyeh.ig.psiutils.CommentTracker;
import com.siyeh.ig.psiutils.ExpressionUtils;
import com.siyeh.ig.psiutils.StreamApiUtil;
import org.jetbrains.annotations.Contract;
@@ -59,6 +60,7 @@ public class SimplifyStreamApiCallChainsInspection extends BaseJavaBatchLocalIns
private static final String ANY_MATCH_METHOD = "anyMatch";
private static final String NONE_MATCH_METHOD = "noneMatch";
private static final String ALL_MATCH_METHOD = "allMatch";
+ private static final String TO_ARRAY_METHOD = "toArray";
private static final String COUNTING_COLLECTOR = "counting";
private static final String TO_LIST_COLLECTOR = "toList";
@@ -100,7 +102,10 @@ public class SimplifyStreamApiCallChainsInspection extends BaseJavaBatchLocalIns
else if (isCallOf(method, CommonClassNames.JAVA_UTIL_OPTIONAL, IS_PRESENT_METHOD, 0)) {
handleOptionalIsPresent(methodCall);
}
- else if (isStreamCall(method, ANY_MATCH_METHOD)) {
+ else if (isStreamCall(method, TO_ARRAY_METHOD, false)) {
+ handleToArray(methodCall);
+ }
+ else if (isStreamCall(method, ANY_MATCH_METHOD, true)) {
if(isParentNegated(methodCall)) {
boolean argNegated = isArgumentLambdaNegated(methodCall);
registerMatchFix(methodCall,
@@ -109,7 +114,7 @@ public class SimplifyStreamApiCallChainsInspection extends BaseJavaBatchLocalIns
argNegated ? ALL_MATCH_METHOD : NONE_MATCH_METHOD));
}
}
- else if (isStreamCall(method, NONE_MATCH_METHOD)) {
+ else if (isStreamCall(method, NONE_MATCH_METHOD, true)) {
if(isParentNegated(methodCall)) {
registerMatchFix(methodCall, new SimplifyMatchNegationFix("!"+psiClass.getName()+".noneMatch(...)", ANY_MATCH_METHOD));
}
@@ -117,7 +122,7 @@ public class SimplifyStreamApiCallChainsInspection extends BaseJavaBatchLocalIns
registerMatchFix(methodCall, new SimplifyMatchNegationFix(psiClass.getName()+".noneMatch(x -> !(...))", ALL_MATCH_METHOD));
}
}
- else if (isStreamCall(method, ALL_MATCH_METHOD)) {
+ else if (isStreamCall(method, ALL_MATCH_METHOD, true)) {
if(isArgumentLambdaNegated(methodCall)) {
boolean parentNegated = isParentNegated(methodCall);
registerMatchFix(methodCall,
@@ -131,6 +136,20 @@ public class SimplifyStreamApiCallChainsInspection extends BaseJavaBatchLocalIns
}
}
+ private void handleToArray(PsiMethodCallExpression methodCall) {
+ if(isCollectionStream(getQualifierMethodCall(methodCall))) {
+ PsiArrayType type = getArrayType(methodCall);
+ if(type != null) {
+ PsiElement nameElement = methodCall.getMethodExpression().getReferenceNameElement();
+ LOG.assertTrue(nameElement != null);
+ String replacement = type.equalsToText(CommonClassNames.JAVA_LANG_OBJECT+"[]") ? "" :
+ "new "+type.getCanonicalText().replaceFirst("\\[]", "[0]");
+ holder.registerProblem(nameElement, "Can be replaced with collection.toArray()",
+ new SimplifyCallChainFix(new ReplaceWithToArrayFix(replacement)));
+ }
+ }
+ }
+
void registerMatchFix(PsiMethodCallExpression methodCall, SimplifyMatchNegationFix fix) {
PsiElement nameElement = methodCall.getMethodExpression().getReferenceNameElement();
if(nameElement != null) {
@@ -223,13 +242,6 @@ public class SimplifyStreamApiCallChainsInspection extends BaseJavaBatchLocalIns
}
}
- @Contract("null -> false")
- private boolean isCollectionStream(PsiMethodCallExpression qualifierCall) {
- if (qualifierCall == null) return false;
- PsiMethod qualifier = qualifierCall.resolveMethod();
- return isCallOf(qualifier, CommonClassNames.JAVA_UTIL_COLLECTION, STREAM_METHOD, 0);
- }
-
private void handleStreamForEach(PsiMethodCallExpression methodCall, PsiMethod method) {
final String name;
if (isCallOf(method, CommonClassNames.JAVA_UTIL_STREAM_STREAM, FOR_EACH_METHOD, 1)) {
@@ -306,34 +318,7 @@ public class SimplifyStreamApiCallChainsInspection extends BaseJavaBatchLocalIns
}
private void handleCollectionStream(PsiMethodCallExpression methodCall) {
- final PsiMethodCallExpression qualifierCall = getQualifierMethodCall(methodCall);
- if (qualifierCall == null) return;
- final PsiMethod qualifier = qualifierCall.resolveMethod();
- ReplaceCollectionStreamFix fix = null;
- if (isCallOf(qualifier, CommonClassNames.JAVA_UTIL_ARRAYS, AS_LIST_METHOD, 1)) {
- if (hasSingleArrayArgument(qualifierCall)) {
- fix = new ArraysAsListSingleArrayFix();
- }
- else {
- fix = new ReplaceWithStreamOfFix("Arrays.asList()");
- }
- }
- else if (isCallOf(qualifier, CommonClassNames.JAVA_UTIL_COLLECTIONS, SINGLETON_LIST_METHOD, 1)) {
- if (!hasSingleArrayArgument(qualifierCall)) {
- fix = new ReplaceSingletonWithStreamOfFix("Collections.singletonList()");
- }
- }
- else if (isCallOf(qualifier, CommonClassNames.JAVA_UTIL_COLLECTIONS, SINGLETON_METHOD, 1)) {
- if (!hasSingleArrayArgument(qualifierCall)) {
- fix = new ReplaceSingletonWithStreamOfFix("Collections.singleton()");
- }
- }
- else if (isCallOf(qualifier, CommonClassNames.JAVA_UTIL_COLLECTIONS, EMPTY_LIST_METHOD, 0)) {
- fix = new ReplaceWithStreamEmptyFix(EMPTY_LIST_METHOD);
- }
- else if (isCallOf(qualifier, CommonClassNames.JAVA_UTIL_COLLECTIONS, EMPTY_SET_METHOD, 0)) {
- fix = new ReplaceWithStreamEmptyFix(EMPTY_SET_METHOD);
- }
+ ReplaceCollectionStreamFix fix = findCollectionStreamFix(methodCall);
if (fix != null) {
holder.registerProblem(methodCall, null, fix.getMessage(), new SimplifyCallChainFix(fix));
}
@@ -341,6 +326,102 @@ public class SimplifyStreamApiCallChainsInspection extends BaseJavaBatchLocalIns
};
}
+ @Nullable
+ private static ReplaceCollectionStreamFix findCollectionStreamFix(PsiMethodCallExpression methodCall) {
+ PsiMethodCallExpression qualifierCall = getQualifierMethodCall(methodCall);
+ if (qualifierCall == null) return null;
+ PsiMethod qualifier = qualifierCall.resolveMethod();
+ if (isCallOf(qualifier, CommonClassNames.JAVA_UTIL_ARRAYS, AS_LIST_METHOD, 1)) {
+ return hasSingleArrayArgument(qualifierCall) ? new ArraysAsListSingleArrayFix() : new ReplaceWithStreamOfFix("Arrays.asList()");
+ }
+ else if (isCallOf(qualifier, CommonClassNames.JAVA_UTIL_COLLECTIONS, SINGLETON_LIST_METHOD, 1)) {
+ if (!hasSingleArrayArgument(qualifierCall)) {
+ return new ReplaceSingletonWithStreamOfFix("Collections.singletonList()");
+ }
+ }
+ else if (isCallOf(qualifier, CommonClassNames.JAVA_UTIL_COLLECTIONS, SINGLETON_METHOD, 1)) {
+ if (!hasSingleArrayArgument(qualifierCall)) {
+ return new ReplaceSingletonWithStreamOfFix("Collections.singleton()");
+ }
+ }
+ else if (isCallOf(qualifier, CommonClassNames.JAVA_UTIL_COLLECTIONS, EMPTY_LIST_METHOD, 0)) {
+ return new ReplaceWithStreamEmptyFix(EMPTY_LIST_METHOD);
+ }
+ else if (isCallOf(qualifier, CommonClassNames.JAVA_UTIL_COLLECTIONS, EMPTY_SET_METHOD, 0)) {
+ return new ReplaceWithStreamEmptyFix(EMPTY_SET_METHOD);
+ }
+ return null;
+ }
+
+ @Contract("null -> false")
+ private static boolean isCollectionStream(PsiMethodCallExpression qualifierCall) {
+ if (qualifierCall == null) return false;
+ PsiMethod qualifier = qualifierCall.resolveMethod();
+ return isCallOf(qualifier, CommonClassNames.JAVA_UTIL_COLLECTION, STREAM_METHOD, 0);
+ }
+
+ public static PsiElement simplifyCollectionStreamCalls(PsiElement element) {
+ boolean replaced = true;
+ while(replaced) {
+ replaced = false;
+ PsiElement[] streamCalls =
+ PsiTreeUtil.collectElements(element, e -> e instanceof PsiMethodCallExpression && isCollectionStream((PsiMethodCallExpression)e));
+ for (PsiElement streamCall : streamCalls) {
+ if (streamCall.isValid()) {
+ ReplaceCollectionStreamFix fix = findCollectionStreamFix((PsiMethodCallExpression)streamCall);
+ if (fix != null) {
+ PsiElement replacement = fix.simplify((PsiMethodCallExpression)streamCall);
+ if(replacement != null) {
+ replaced = true;
+ if(element == streamCall) {
+ element = replacement;
+ }
+ }
+ }
+ }
+ }
+ }
+ return element;
+ }
+
+ @Nullable
+ private static PsiArrayType getArrayType(PsiMethodCallExpression call) {
+ PsiType type = call.getType();
+ if(!(type instanceof PsiArrayType)) return null;
+ PsiArrayType candidate = (PsiArrayType)type;
+ PsiExpression[] args = call.getArgumentList().getExpressions();
+ if(args.length == 0) return candidate;
+ if(args.length != 1) return null;
+ PsiExpression supplier = args[0];
+ if(supplier instanceof PsiMethodReferenceExpression) {
+ // like toArray(String[]::new)
+ PsiMethodReferenceExpression methodRef = (PsiMethodReferenceExpression)supplier;
+ PsiTypeElement qualifierType = methodRef.getQualifierType();
+ if (methodRef.isConstructor() && qualifierType != null && candidate.isAssignableFrom(qualifierType.getType())) {
+ return candidate;
+ }
+ } else if(supplier instanceof PsiLambdaExpression) {
+ // like toArray(size -> new String[size])
+ PsiLambdaExpression lambda = (PsiLambdaExpression)supplier;
+ PsiParameter[] parameters = lambda.getParameterList().getParameters();
+ if(parameters.length != 1) return null;
+ PsiParameter sizeParameter = parameters[0];
+ PsiExpression body = LambdaUtil.extractSingleExpressionFromBody(lambda.getBody());
+ if(body instanceof PsiNewExpression) {
+ PsiNewExpression newExpression = (PsiNewExpression)body;
+ PsiExpression[] dimensions = newExpression.getArrayDimensions();
+ PsiType newExpressionType = newExpression.getType();
+ if (dimensions.length != 0 &&
+ ExpressionUtils.isReferenceTo(dimensions[0], sizeParameter) &&
+ newExpressionType != null &&
+ candidate.isAssignableFrom(newExpressionType)) {
+ return candidate;
+ }
+ }
+ }
+ return null;
+ }
+
private static boolean isCollectionConstructor(PsiMethod ctor) {
if(!ctor.getModifierList().hasExplicitModifier(PsiModifier.PUBLIC)) return false;
PsiParameterList list = ctor.getParameterList();
@@ -452,8 +533,10 @@ public class SimplifyStreamApiCallChainsInspection extends BaseJavaBatchLocalIns
return false;
}
- static boolean isStreamCall(@Nullable PsiMethod method, @NotNull String methodName) {
- if (method == null || !methodName.equals(method.getName()) || method.getParameterList().getParametersCount() != 1) {
+ @Contract("null, _, _ -> false")
+ static boolean isStreamCall(@Nullable PsiMethod method, @NotNull String methodName, boolean checkSingleParameter) {
+ if (method == null || !methodName.equals(method.getName()) ||
+ (checkSingleParameter && method.getParameterList().getParametersCount() != 1)) {
return false;
}
final PsiClass containingClass = method.getContainingClass();
@@ -462,7 +545,7 @@ public class SimplifyStreamApiCallChainsInspection extends BaseJavaBatchLocalIns
interface CallChainFix {
String getName();
- void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor);
+ void applyFix(@NotNull Project project, PsiElement element);
}
private static class SimplifyCallChainFix implements LocalQuickFix {
@@ -488,31 +571,11 @@ public class SimplifyStreamApiCallChainsInspection extends BaseJavaBatchLocalIns
@Override
public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
- myFix.applyFix(project, descriptor);
+ myFix.applyFix(project, descriptor.getStartElement());
}
}
- private static abstract class CallChainFixBase implements CallChainFix {
- @Override
- public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
- final PsiElement element = descriptor.getStartElement();
- if (element instanceof PsiMethodCallExpression) {
- final PsiMethodCallExpression expression = (PsiMethodCallExpression)element;
- final PsiExpression forEachMethodQualifier = expression.getMethodExpression().getQualifierExpression();
- if (forEachMethodQualifier instanceof PsiMethodCallExpression) {
- final PsiMethodCallExpression previousExpression = (PsiMethodCallExpression)forEachMethodQualifier;
- final PsiExpression qualifierExpression = previousExpression.getMethodExpression().getQualifierExpression();
- replaceMethodCall(expression, previousExpression, qualifierExpression);
- }
- }
- }
-
- protected abstract void replaceMethodCall(@NotNull PsiMethodCallExpression methodCall,
- @NotNull PsiMethodCallExpression qualifierCall,
- @Nullable PsiExpression qualifierExpression);
- }
-
- private static abstract class ReplaceCollectionStreamFix extends CallChainFixBase {
+ private static abstract class ReplaceCollectionStreamFix implements CallChainFix {
private final String myClassName;
private final String myMethodName;
private final String myQualifierCall;
@@ -542,13 +605,17 @@ public class SimplifyStreamApiCallChainsInspection extends BaseJavaBatchLocalIns
}
@Override
- protected void replaceMethodCall(@NotNull PsiMethodCallExpression methodCall,
- @NotNull PsiMethodCallExpression qualifierCall,
- @Nullable PsiExpression qualifierExpression) {
- methodCall.getArgumentList().replace(qualifierCall.getArgumentList());
+ public void applyFix(@NotNull Project project, PsiElement element) {
+ if (!(element instanceof PsiMethodCallExpression)) return;
+ simplify((PsiMethodCallExpression)element);
+ }
- final Project project = methodCall.getProject();
- String typeParameter = getTypeParameter(qualifierCall);
+ @Nullable
+ private PsiElement simplify(PsiMethodCallExpression streamCall) {
+ PsiMethodCallExpression collectionCall = getQualifierMethodCall(streamCall);
+ if (collectionCall == null) return null;
+ streamCall.getArgumentList().replace(collectionCall.getArgumentList());
+ String typeParameter = getTypeParameter(collectionCall);
String replacement;
if (typeParameter != null) {
replacement = myClassName + ".<" + typeParameter + ">" + myMethodName;
@@ -556,8 +623,9 @@ public class SimplifyStreamApiCallChainsInspection extends BaseJavaBatchLocalIns
else {
replacement = myClassName + "." + myMethodName;
}
- final PsiExpression newMethodExpression = JavaPsiFacade.getElementFactory(project).createExpressionFromText(replacement, methodCall);
- JavaCodeStyleManager.getInstance(project).shortenClassReferences(methodCall.getMethodExpression().replace(newMethodExpression));
+ Project project = streamCall.getProject();
+ PsiExpression newMethodExpression = JavaPsiFacade.getElementFactory(project).createExpressionFromText(replacement, streamCall);
+ return JavaCodeStyleManager.getInstance(project).shortenClassReferences(streamCall.getMethodExpression().replace(newMethodExpression));
}
}
@@ -602,7 +670,7 @@ public class SimplifyStreamApiCallChainsInspection extends BaseJavaBatchLocalIns
}
}
- static class ReplaceStreamMethodFix extends CallChainFixBase {
+ static class ReplaceStreamMethodFix implements CallChainFix {
private final String myStreamMethod;
private final String myCollectionMethod;
private final boolean myChangeSemantics;
@@ -630,19 +698,16 @@ public class SimplifyStreamApiCallChainsInspection extends BaseJavaBatchLocalIns
}
@Override
- protected void replaceMethodCall(@NotNull PsiMethodCallExpression methodCall,
- @NotNull PsiMethodCallExpression qualifierCall,
- @Nullable PsiExpression qualifierExpression) {
- if (qualifierExpression != null) {
- final PsiElement nameElement = methodCall.getMethodExpression().getReferenceNameElement();
- if (nameElement != null) {
- qualifierCall.replace(qualifierExpression);
- if (!myStreamMethod.equals(myCollectionMethod)) {
- final Project project = methodCall.getProject();
- PsiIdentifier collectionMethod = JavaPsiFacade.getElementFactory(project).createIdentifier(myCollectionMethod);
- nameElement.replace(collectionMethod);
- }
- }
+ public void applyFix(@NotNull Project project, PsiElement element) {
+ if (!(element instanceof PsiMethodCallExpression)) return;
+ PsiMethodCallExpression streamMethodCall = (PsiMethodCallExpression)element;
+ PsiMethodCallExpression collectionStreamCall = getQualifierMethodCall(streamMethodCall);
+ if (collectionStreamCall == null) return;
+ PsiExpression collectionExpression = collectionStreamCall.getMethodExpression().getQualifierExpression();
+ if (collectionExpression == null) return;
+ collectionStreamCall.replace(collectionExpression);
+ if (!myStreamMethod.equals(myCollectionMethod)) {
+ streamMethodCall.getMethodExpression().handleElementRename(myCollectionMethod);
}
}
}
@@ -670,8 +735,7 @@ public class SimplifyStreamApiCallChainsInspection extends BaseJavaBatchLocalIns
}
@Override
- public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
- PsiElement element = descriptor.getStartElement();
+ public void applyFix(@NotNull Project project, PsiElement element) {
if (element instanceof PsiMethodCallExpression) {
PsiMethodCallExpression collectCall = (PsiMethodCallExpression)element;
PsiExpression qualifierExpression = collectCall.getMethodExpression().getQualifierExpression();
@@ -737,8 +801,7 @@ public class SimplifyStreamApiCallChainsInspection extends BaseJavaBatchLocalIns
}
@Override
- public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
- PsiElement element = descriptor.getStartElement();
+ public void applyFix(@NotNull Project project, PsiElement element) {
if (element instanceof PsiMethodCallExpression) {
PsiMethodCallExpression isPresentCall = (PsiMethodCallExpression)element;
PsiExpression isPresentQualifier = isPresentCall.getMethodExpression().getQualifierExpression();
@@ -781,8 +844,7 @@ public class SimplifyStreamApiCallChainsInspection extends BaseJavaBatchLocalIns
}
@Override
- public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
- PsiElement element = descriptor.getStartElement();
+ public void applyFix(@NotNull Project project, PsiElement element) {
if(element instanceof PsiIdentifier) {
String from = element.getText();
boolean removeParentNegation;
@@ -836,8 +898,7 @@ public class SimplifyStreamApiCallChainsInspection extends BaseJavaBatchLocalIns
}
@Override
- public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
- PsiElement element = descriptor.getStartElement();
+ public void applyFix(@NotNull Project project, PsiElement element) {
if(!(element instanceof PsiMethodCallExpression)) return;
PsiMethodCallExpression collectCall = (PsiMethodCallExpression)element;
PsiType type = collectCall.getType();
@@ -875,8 +936,7 @@ public class SimplifyStreamApiCallChainsInspection extends BaseJavaBatchLocalIns
}
@Override
- public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
- PsiElement element = descriptor.getStartElement();
+ public void applyFix(@NotNull Project project, PsiElement element) {
if(!(element instanceof PsiIdentifier)) return;
PsiElement parent = element.getParent();
if(!(parent instanceof PsiReferenceExpression)) return;
@@ -890,4 +950,31 @@ public class SimplifyStreamApiCallChainsInspection extends BaseJavaBatchLocalIns
((PsiMethodCallExpression)grandParent).getTypeArgumentList().delete();
}
}
+
+ private static class ReplaceWithToArrayFix implements CallChainFix {
+ private final String myReplacement;
+
+ private ReplaceWithToArrayFix(String replacement) {
+ myReplacement = replacement;
+ }
+
+ @Override
+ public String getName() {
+ return "Replace 'collection.stream().toArray()' with 'collection.toArray()'";
+ }
+
+ @Override
+ public void applyFix(@NotNull Project project, PsiElement element) {
+ PsiMethodCallExpression toArrayCall = PsiTreeUtil.getParentOfType(element, PsiMethodCallExpression.class);
+ if (toArrayCall == null) return;
+ PsiExpression qualifier = toArrayCall.getMethodExpression().getQualifierExpression();
+ if(!(qualifier instanceof PsiMethodCallExpression)) return;
+ PsiMethodCallExpression streamCall = (PsiMethodCallExpression)qualifier;
+ PsiExpression collectionExpression = streamCall.getMethodExpression().getQualifierExpression();
+ if(collectionExpression == null) return;
+ CommentTracker ct = new CommentTracker();
+ PsiElement result = ct.replaceAndRestoreComments(toArrayCall, ct.text(collectionExpression) + ".toArray(" + myReplacement + ")");
+ CodeStyleManager.getInstance(project).reformat(JavaCodeStyleManager.getInstance(project).shortenClassReferences(result));
+ }
+ }
}
diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/util/LambdaGenerationUtil.java b/java/java-analysis-impl/src/com/intellij/codeInspection/util/LambdaGenerationUtil.java
index 67506323e6b0..e66c4abd4246 100644
--- a/java/java-analysis-impl/src/com/intellij/codeInspection/util/LambdaGenerationUtil.java
+++ b/java/java-analysis-impl/src/com/intellij/codeInspection/util/LambdaGenerationUtil.java
@@ -19,6 +19,7 @@ import com.intellij.codeInsight.ExceptionUtil;
import com.intellij.codeInsight.daemon.impl.analysis.HighlightControlFlowUtil;
import com.intellij.psi.*;
import com.intellij.psi.util.PsiTreeUtil;
+import com.intellij.psi.util.PsiUtil;
import org.jetbrains.annotations.Contract;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@@ -104,15 +105,18 @@ public class LambdaGenerationUtil {
if(!myCanBeLambdaBody) return;
super.visitReferenceExpression(expression);
PsiElement element = expression.resolve();
- if (element instanceof PsiVariable &&
- !(element instanceof PsiField) &&
- !myVariableAllowedPredicate.test((PsiVariable)element) &&
- !PsiTreeUtil.isAncestor(myRoot, element, true) &&
- !HighlightControlFlowUtil.isEffectivelyFinal((PsiVariable)element, myRoot, null)) {
+ if (element instanceof PsiVariable && !isAllowedInLambda(expression, (PsiVariable)element)) {
myCanBeLambdaBody = false;
}
}
+ private boolean isAllowedInLambda(PsiReferenceExpression expression, PsiVariable variable) {
+ return variable instanceof PsiField ||
+ myVariableAllowedPredicate.test(variable) ||
+ PsiTreeUtil.isAncestor(myRoot, variable, true) ||
+ !PsiUtil.isAccessedForWriting(expression) && HighlightControlFlowUtil.isEffectivelyFinal(variable, myRoot, null);
+ }
+
@Override
public void visitBreakStatement(PsiBreakStatement statement) {
PsiStatement exitedStatement = statement.findExitedStatement();
diff --git a/java/java-impl/src/com/intellij/application/options/CodeStyleGenerationConfigurable.java b/java/java-impl/src/com/intellij/application/options/CodeStyleGenerationConfigurable.java
index 7988b4ed0963..622129e8085e 100644
--- a/java/java-impl/src/com/intellij/application/options/CodeStyleGenerationConfigurable.java
+++ b/java/java-impl/src/com/intellij/application/options/CodeStyleGenerationConfigurable.java
@@ -84,7 +84,7 @@ public class CodeStyleGenerationConfigurable implements Configurable {
final Condition isApplicable = aClass -> aClass.isAnnotationType();
//noinspection Convert2Diamond
myRepeatAnnotationsModel = new SortedListModel(Comparator.naturalOrder());
- myOverridePanel.add(SpecialAnnotationsUtil.createSpecialAnnotationsListControl("Annotations to Repeat", false, isApplicable, myRepeatAnnotationsModel), gc);
+ myOverridePanel.add(SpecialAnnotationsUtil.createSpecialAnnotationsListControl("Annotations to Copy", false, isApplicable, myRepeatAnnotationsModel), gc);
return myPanel;
}
diff --git a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/AddVariableInitializerFix.java b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/AddVariableInitializerFix.java
index 29690467d913..9fdbd9975d26 100644
--- a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/AddVariableInitializerFix.java
+++ b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/AddVariableInitializerFix.java
@@ -28,6 +28,7 @@ import com.intellij.psi.util.PsiTreeUtil;
import com.intellij.psi.util.PsiTypesUtil;
import com.intellij.psi.util.PsiUtil;
import com.intellij.util.IncorrectOperationException;
+import com.intellij.util.ObjectUtils;
import com.intellij.util.SmartList;
import com.intellij.util.containers.ContainerUtil;
import org.jetbrains.annotations.NotNull;
@@ -94,7 +95,7 @@ public class AddVariableInitializerFix implements IntentionAction {
@Nullable Editor editor) {
if (editor == null) return;
LOG.assertTrue(!initializers.isEmpty());
- final PsiExpression initializer = ContainerUtil.getFirstItem(initializers);
+ final PsiExpression initializer = ObjectUtils.notNull(ContainerUtil.getFirstItem(initializers));
PsiElement context = initializers.size() == 1 ? initializer : PsiTreeUtil.findCommonParent(initializers);
PsiDocumentManager.getInstance(initializer.getProject()).doPostponedOperationsAndUnblockDocument(editor.getDocument());
final TemplateBuilderImpl builder = (TemplateBuilderImpl)TemplateBuilderFactory.getInstance().createTemplateBuilder(context);
diff --git a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreateFromUsageBaseFix.java b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreateFromUsageBaseFix.java
index 911d2410d37b..e9eb75590573 100644
--- a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreateFromUsageBaseFix.java
+++ b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreateFromUsageBaseFix.java
@@ -424,9 +424,7 @@ public abstract class CreateFromUsageBaseFix extends BaseIntentionAction {
final TemplateEditingListener listener,
final String commandName) {
Runnable runnable = () -> TemplateManager.getInstance(project).startTemplate(editor, template, listener);
- ApplicationManager.getApplication().invokeLater(
- () -> CommandProcessor.getInstance().executeCommand(project, runnable, commandName, commandName),
- x -> project.isDisposed() || editor.isDisposed());
+ CommandProcessor.getInstance().executeCommand(project, runnable, commandName, commandName);
}
@Override
diff --git a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/InitializeFinalFieldInConstructorFix.java b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/InitializeFinalFieldInConstructorFix.java
index 76d7d473d7f4..f99520fcac2f 100644
--- a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/InitializeFinalFieldInConstructorFix.java
+++ b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/InitializeFinalFieldInConstructorFix.java
@@ -100,7 +100,10 @@ public class InitializeFinalFieldInConstructorFix implements IntentionAction {
final LookupElement[] suggestedInitializers = AddVariableInitializerFix.suggestInitializer(field);
for (PsiMethod constructor : constructors) {
- rExpressions.add(addFieldInitialization(constructor, suggestedInitializers, field, project));
+ PsiExpression initialization = addFieldInitialization(constructor, suggestedInitializers, field, project);
+ if (initialization != null) {
+ rExpressions.add(initialization);
+ }
}
AddVariableInitializerFix.runAssignmentTemplate(rExpressions, suggestedInitializers, editor);
}
diff --git a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/StaticMembersProcessor.java b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/StaticMembersProcessor.java
index d2806b05ba3d..5ee0b672d2dc 100644
--- a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/StaticMembersProcessor.java
+++ b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/StaticMembersProcessor.java
@@ -78,6 +78,17 @@ abstract class StaticMembersProcessor
return ((PsiAssignmentExpression)parent).getLExpression().getType();
}
}
+ else if (parent instanceof PsiBinaryExpression && JavaTokenType.EQEQ.equals(((PsiBinaryExpression)parent).getOperationTokenType())) {
+ if (myPlace.equals(PsiUtil.skipParenthesizedExprDown(((PsiBinaryExpression)parent).getROperand()))) {
+ return ((PsiBinaryExpression)parent).getLOperand().getType();
+ }
+ if (myPlace.equals(PsiUtil.skipParenthesizedExprDown(((PsiBinaryExpression)parent).getLOperand()))) {
+ PsiExpression rOperand = ((PsiBinaryExpression)parent).getROperand();
+ if (rOperand != null) {
+ return rOperand.getType();
+ }
+ }
+ }
else if (parent instanceof PsiReturnStatement) {
return PsiTypesUtil.getMethodReturnType(parent);
}
diff --git a/java/java-impl/src/com/intellij/codeInsight/lookup/VariableLookupItem.java b/java/java-impl/src/com/intellij/codeInsight/lookup/VariableLookupItem.java
index 9c652cfb82aa..f582048e9f82 100644
--- a/java/java-impl/src/com/intellij/codeInsight/lookup/VariableLookupItem.java
+++ b/java/java-impl/src/com/intellij/codeInsight/lookup/VariableLookupItem.java
@@ -215,7 +215,7 @@ public class VariableLookupItem extends LookupItem implements Typed
TailType.COMMA.processTail(context.getEditor(), context.getTailOffset());
AutoPopupController.getInstance(context.getProject()).autoPopupParameterInfo(context.getEditor(), null);
}
- else if (completionChar == ':' && getAttribute(LookupItem.TAIL_TYPE_ATTR) != TailType.UNKNOWN) {
+ else if (completionChar == ':' && getAttribute(LookupItem.TAIL_TYPE_ATTR) != TailType.UNKNOWN && isTernaryCondition(ref)) {
context.setAddCompletionChar(false);
TailType.COND_EXPR_COLON.processTail(context.getEditor(), context.getTailOffset());
}
@@ -231,6 +231,11 @@ public class VariableLookupItem extends LookupItem implements Typed
}
}
+ private static boolean isTernaryCondition(PsiReferenceExpression ref) {
+ PsiElement parent = ref == null ? null : ref.getParent();
+ return parent instanceof PsiConditionalExpression && ref == ((PsiConditionalExpression)parent).getThenExpression();
+ }
+
public static void makeFinalIfNeeded(@NotNull InsertionContext context, @NotNull PsiVariable variable) {
PsiElement place = context.getFile().findElementAt(context.getTailOffset() - 1);
if (!Registry.is("java.completion.make.outer.variables.final") ||
diff --git a/java/java-impl/src/com/intellij/codeInsight/template/postfix/templates/IntroduceFieldPostfixTemplate.java b/java/java-impl/src/com/intellij/codeInsight/template/postfix/templates/IntroduceFieldPostfixTemplate.java
index b2d746e0608f..66798b20e623 100644
--- a/java/java-impl/src/com/intellij/codeInsight/template/postfix/templates/IntroduceFieldPostfixTemplate.java
+++ b/java/java-impl/src/com/intellij/codeInsight/template/postfix/templates/IntroduceFieldPostfixTemplate.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2000-2014 JetBrains s.r.o.
+ * Copyright 2000-2016 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -56,4 +56,10 @@ public class IntroduceFieldPostfixTemplate extends PostfixTemplateWithExpression
}
};
}
+
+ @Override
+ protected void prepareAndExpandForChooseExpression(@NotNull PsiElement expression, @NotNull Editor editor) {
+ //no write action
+ expandForChooseExpression(expression, editor);
+ }
}
\ No newline at end of file
diff --git a/java/java-impl/src/com/intellij/codeInsight/template/postfix/templates/IntroduceVariablePostfixTemplate.java b/java/java-impl/src/com/intellij/codeInsight/template/postfix/templates/IntroduceVariablePostfixTemplate.java
index 7bf1e8cd03bd..bf13b104684e 100644
--- a/java/java-impl/src/com/intellij/codeInsight/template/postfix/templates/IntroduceVariablePostfixTemplate.java
+++ b/java/java-impl/src/com/intellij/codeInsight/template/postfix/templates/IntroduceVariablePostfixTemplate.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2000-2014 JetBrains s.r.o.
+ * Copyright 2000-2016 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -93,4 +93,10 @@ public class IntroduceVariablePostfixTemplate extends PostfixTemplateWithExpress
}
};
}
+
+ @Override
+ protected void prepareAndExpandForChooseExpression(@NotNull PsiElement expression, @NotNull Editor editor) {
+ //no write action
+ expandForChooseExpression(expression, editor);
+ }
}
\ No newline at end of file
diff --git a/java/java-impl/src/com/intellij/codeInsight/unwrap/JavaLambdaUnwrapper.java b/java/java-impl/src/com/intellij/codeInsight/unwrap/JavaLambdaUnwrapper.java
index d2737cc1d217..86e5b9e315ee 100644
--- a/java/java-impl/src/com/intellij/codeInsight/unwrap/JavaLambdaUnwrapper.java
+++ b/java/java-impl/src/com/intellij/codeInsight/unwrap/JavaLambdaUnwrapper.java
@@ -31,12 +31,6 @@ public class JavaLambdaUnwrapper extends JavaUnwrapper {
return e instanceof PsiLambdaExpression;
}
- @Override
- public PsiElement collectAffectedElements(PsiElement e, List toExtract) {
- super.collectAffectedElements(e, toExtract);
- return JavaAnonymousUnwrapper.findElementToExtractFrom(e);
- }
-
@Override
protected void doUnwrap(PsiElement element, Context context) throws IncorrectOperationException {
PsiElement from = JavaAnonymousUnwrapper.findElementToExtractFrom(element);
diff --git a/java/java-impl/src/com/intellij/codeInspection/CollectionAddAllCanBeReplacedWithConstructorInspection.java b/java/java-impl/src/com/intellij/codeInspection/CollectionAddAllCanBeReplacedWithConstructorInspection.java
index b5bd14915bf5..941b3a5a5fc2 100644
--- a/java/java-impl/src/com/intellij/codeInspection/CollectionAddAllCanBeReplacedWithConstructorInspection.java
+++ b/java/java-impl/src/com/intellij/codeInspection/CollectionAddAllCanBeReplacedWithConstructorInspection.java
@@ -247,14 +247,12 @@ public class CollectionAddAllCanBeReplacedWithConstructorInspection extends Base
@Override
public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
final PsiMethodCallExpression methodCallExpression = myMethodCallExpression.getElement();
-
- LOG.assertTrue(methodCallExpression != null);
-
+ if (methodCallExpression == null) return;
final PsiElement parameter = methodCallExpression.getArgumentList().getExpressions()[0].copy();
final PsiNewExpression element = myAssignmentExpression.getElement();
- LOG.assertTrue(element != null);
+ if (element == null) return;
final PsiExpressionList constructorArguments = element.getArgumentList();
- LOG.assertTrue(constructorArguments != null);
+ if (constructorArguments == null) return;
constructorArguments.add(parameter);
methodCallExpression.delete();
}
diff --git a/java/java-impl/src/com/intellij/codeInspection/streamMigration/BaseStreamApiMigration.java b/java/java-impl/src/com/intellij/codeInspection/streamMigration/BaseStreamApiMigration.java
new file mode 100644
index 000000000000..7d053c658700
--- /dev/null
+++ b/java/java-impl/src/com/intellij/codeInspection/streamMigration/BaseStreamApiMigration.java
@@ -0,0 +1,139 @@
+/*
+ * Copyright 2000-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.codeInspection.streamMigration;
+
+import com.intellij.codeInspection.streamMigration.StreamApiMigrationInspection.CollectionStream;
+import com.intellij.codeInspection.streamMigration.StreamApiMigrationInspection.InitializerUsageStatus;
+import com.intellij.codeInspection.streamMigration.StreamApiMigrationInspection.Operation;
+import com.intellij.codeInspection.streamMigration.StreamApiMigrationInspection.TerminalBlock;
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.*;
+import com.intellij.psi.controlFlow.*;
+import com.intellij.psi.util.PsiTreeUtil;
+import com.siyeh.ig.psiutils.ExpressionUtils;
+import one.util.streamex.StreamEx;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+import java.util.ListIterator;
+import java.util.Objects;
+
+/**
+ * @author Tagir Valeev
+ */
+abstract class BaseStreamApiMigration {
+ private final String myReplacement;
+
+ protected BaseStreamApiMigration(String replacement) {
+ myReplacement = replacement;
+ }
+
+ public String getReplacement() {
+ return myReplacement;
+ }
+
+ abstract PsiElement migrate(@NotNull Project project,
+ @NotNull PsiLoopStatement loopStatement,
+ @NotNull PsiStatement body,
+ @NotNull TerminalBlock tb);
+
+ static PsiElement replaceWithNumericAddition(@NotNull Project project,
+ PsiLoopStatement loopStatement,
+ PsiVariable var,
+ StringBuilder builder,
+ PsiType expressionType) {
+ PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(project);
+ restoreComments(loopStatement, loopStatement.getBody());
+ InitializerUsageStatus status = StreamApiMigrationInspection.getInitializerUsageStatus(var, loopStatement);
+ if (status != InitializerUsageStatus.UNKNOWN) {
+ PsiExpression initializer = var.getInitializer();
+ if (ExpressionUtils.isZero(initializer)) {
+ PsiType type = var.getType();
+ String replacement = (type.equals(expressionType) ? "" : "(" + type.getCanonicalText() + ") ") + builder;
+ return replaceInitializer(loopStatement, var, initializer, replacement, status);
+ }
+ }
+ return loopStatement.replace(elementFactory.createStatementFromText(var.getName() + "+=" + builder + ";", loopStatement));
+ }
+
+ static PsiElement replaceInitializer(PsiLoopStatement loopStatement,
+ PsiVariable var,
+ PsiExpression initializer,
+ String replacement,
+ InitializerUsageStatus status) {
+ Project project = loopStatement.getProject();
+ PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(project);
+ if(status == InitializerUsageStatus.DECLARED_JUST_BEFORE) {
+ initializer.replace(elementFactory.createExpressionFromText(replacement, loopStatement));
+ removeLoop(loopStatement);
+ return var;
+ } else {
+ if(status == InitializerUsageStatus.AT_WANTED_PLACE_ONLY) {
+ initializer.delete();
+ }
+ return
+ loopStatement.replace(elementFactory.createStatementFromText(var.getName() + " = " + replacement + ";", loopStatement));
+ }
+ }
+
+ static void restoreComments(PsiLoopStatement loopStatement, PsiStatement body) {
+ final PsiElement parent = loopStatement.getParent();
+ for (PsiElement comment : PsiTreeUtil.findChildrenOfType(body, PsiComment.class)) {
+ parent.addBefore(comment, loopStatement);
+ }
+ }
+
+ @NotNull
+ static StringBuilder generateStream(@NotNull Operation lastOperation) {
+ return generateStream(lastOperation, false);
+ }
+
+ @NotNull
+ static StringBuilder generateStream(@NotNull Operation lastOperation, boolean noStreamForEmpty) {
+ StringBuilder buffer = new StringBuilder();
+ if(noStreamForEmpty && lastOperation instanceof CollectionStream) {
+ return buffer.append(lastOperation.getExpression().getText());
+ }
+ List replacements =
+ StreamEx.iterate(lastOperation, Objects::nonNull, Operation::getPreviousOp).map(Operation::createReplacement).toList();
+ for(ListIterator it = replacements.listIterator(replacements.size()); it.hasPrevious(); ) {
+ buffer.append(it.previous());
+ }
+ return buffer;
+ }
+
+ static void removeLoop(@NotNull PsiLoopStatement statement) {
+ PsiElement parent = statement.getParent();
+ if (parent instanceof PsiLabeledStatement) {
+ parent.delete();
+ }
+ else {
+ statement.delete();
+ }
+ }
+
+ static boolean isReachable(PsiReturnStatement target) {
+ ControlFlow flow;
+ try {
+ flow = ControlFlowFactory.getInstance(target.getProject())
+ .getControlFlow(target.getParent(), LocalsOrMyInstanceFieldsControlFlowPolicy.getInstance());
+ }
+ catch (AnalysisCanceledException e) {
+ return true;
+ }
+ return ControlFlowUtil.isInstructionReachable(flow, flow.getStartOffset(target), 0);
+ }
+}
diff --git a/java/java-impl/src/com/intellij/codeInspection/streamMigration/ReplaceWithCollectFix.java b/java/java-impl/src/com/intellij/codeInspection/streamMigration/CollectMigration.java
similarity index 96%
rename from java/java-impl/src/com/intellij/codeInspection/streamMigration/ReplaceWithCollectFix.java
rename to java/java-impl/src/com/intellij/codeInspection/streamMigration/CollectMigration.java
index c9e37a316cac..427a5dacb447 100644
--- a/java/java-impl/src/com/intellij/codeInspection/streamMigration/ReplaceWithCollectFix.java
+++ b/java/java-impl/src/com/intellij/codeInspection/streamMigration/CollectMigration.java
@@ -35,19 +35,11 @@ import org.jetbrains.annotations.Nullable;
/**
* @author Tagir Valeev
*/
-class ReplaceWithCollectFix extends MigrateToStreamFix {
- private static final Logger LOG = Logger.getInstance(ReplaceWithCollectFix.class);
+class CollectMigration extends BaseStreamApiMigration {
+ private static final Logger LOG = Logger.getInstance(CollectMigration.class);
- final String myMethodName;
-
- protected ReplaceWithCollectFix(String methodName) {
- myMethodName = methodName;
- }
-
- @NotNull
- @Override
- public String getFamilyName() {
- return "Replace with " + myMethodName;
+ protected CollectMigration(String methodName) {
+ super(methodName);
}
@Nullable
@@ -65,6 +57,7 @@ class ReplaceWithCollectFix extends MigrateToStreamFix {
@NotNull PsiLoopStatement loopStatement,
@NotNull PsiStatement body,
@NotNull TerminalBlock tb) {
+ tb = tb.tryPeelLimit(loopStatement);
PsiElementFactory factory = JavaPsiFacade.getElementFactory(project);
PsiMethodCallExpression call = tb.getSingleMethodCall();
if (call == null) return null;
@@ -174,9 +167,9 @@ class ReplaceWithCollectFix extends MigrateToStreamFix {
if (iteratedValue == null) return null;
PsiExpression qualifierExpression = call.getMethodExpression().getQualifierExpression();
String qualifierText = qualifierExpression != null ? qualifierExpression.getText() : "";
- String collectionText =
- iteratedValue.getType() instanceof PsiArrayType ? CommonClassNames.JAVA_UTIL_ARRAYS + ".asList(" + iteratedValue.getText() + ")" :
- getIteratedValueText(iteratedValue);
+ String collectionText = iteratedValue.getType() instanceof PsiArrayType
+ ? CommonClassNames.JAVA_UTIL_ARRAYS + ".asList(" + iteratedValue.getText() + ")"
+ : iteratedValue.getText();
String callText = StringUtil.getQualifiedName(qualifierText, "addAll(" + collectionText + ");");
return loopStatement.replace(factory.createStatementFromText(callText, loopStatement));
}
diff --git a/java/java-impl/src/com/intellij/codeInspection/streamMigration/ReplaceWithCountFix.java b/java/java-impl/src/com/intellij/codeInspection/streamMigration/CountMigration.java
similarity index 70%
rename from java/java-impl/src/com/intellij/codeInspection/streamMigration/ReplaceWithCountFix.java
rename to java/java-impl/src/com/intellij/codeInspection/streamMigration/CountMigration.java
index 137630e080de..d21823be19f2 100644
--- a/java/java-impl/src/com/intellij/codeInspection/streamMigration/ReplaceWithCountFix.java
+++ b/java/java-impl/src/com/intellij/codeInspection/streamMigration/CountMigration.java
@@ -15,6 +15,7 @@
*/
package com.intellij.codeInspection.streamMigration;
+import com.intellij.codeInspection.streamMigration.StreamApiMigrationInspection.LimitOp;
import com.intellij.openapi.project.Project;
import com.intellij.psi.*;
import org.jetbrains.annotations.NotNull;
@@ -22,25 +23,27 @@ import org.jetbrains.annotations.NotNull;
/**
* @author Tagir Valeev
*/
-class ReplaceWithCountFix extends MigrateToStreamFix {
+class CountMigration extends BaseStreamApiMigration {
- @NotNull
- @Override
- public String getFamilyName() {
- return "Replace with count()";
- }
+ CountMigration() {super("count()");}
@Override
PsiElement migrate(@NotNull Project project,
@NotNull PsiLoopStatement loopStatement,
@NotNull PsiStatement body,
@NotNull StreamApiMigrationInspection.TerminalBlock tb) {
- PsiExpression operand = StreamApiMigrationInspection.extractIncrementedLValue(tb.getSingleExpression(PsiExpression.class));
+ tb = tb.tryPeelLimit(loopStatement);
+ PsiExpression expression = tb.getSingleExpression(PsiExpression.class);
+ StreamApiMigrationInspection.Operation lastOperation = tb.getLastOperation();
+ if (expression == null && lastOperation instanceof LimitOp) {
+ expression = ((LimitOp)lastOperation).getCountExpression();
+ }
+ PsiExpression operand = StreamApiMigrationInspection.extractIncrementedLValue(expression);
if (!(operand instanceof PsiReferenceExpression)) return null;
PsiElement element = ((PsiReferenceExpression)operand).resolve();
if (!(element instanceof PsiLocalVariable)) return null;
PsiLocalVariable var = (PsiLocalVariable)element;
- StringBuilder builder = generateStream(tb.getLastOperation()).append(".count()");
+ StringBuilder builder = generateStream(lastOperation).append(".count()");
return replaceWithNumericAddition(project, loopStatement, var, builder, PsiType.LONG);
}
}
diff --git a/java/java-impl/src/com/intellij/codeInspection/streamMigration/ReplaceWithFindFirstFix.java b/java/java-impl/src/com/intellij/codeInspection/streamMigration/FindFirstMigration.java
similarity index 97%
rename from java/java-impl/src/com/intellij/codeInspection/streamMigration/ReplaceWithFindFirstFix.java
rename to java/java-impl/src/com/intellij/codeInspection/streamMigration/FindFirstMigration.java
index ab83c6f07e02..37b2ea48f337 100644
--- a/java/java-impl/src/com/intellij/codeInspection/streamMigration/ReplaceWithFindFirstFix.java
+++ b/java/java-impl/src/com/intellij/codeInspection/streamMigration/FindFirstMigration.java
@@ -27,12 +27,8 @@ import org.jetbrains.annotations.NotNull;
/**
* @author Tagir Valeev
*/
-class ReplaceWithFindFirstFix extends MigrateToStreamFix {
- @NotNull
- @Override
- public String getFamilyName() {
- return "Replace with findFirst()";
- }
+class FindFirstMigration extends BaseStreamApiMigration {
+ FindFirstMigration() {super("findFirst()");}
@Override
PsiElement migrate(@NotNull Project project,
diff --git a/java/java-impl/src/com/intellij/codeInspection/streamMigration/ReplaceWithForeachCallFix.java b/java/java-impl/src/com/intellij/codeInspection/streamMigration/ForEachMigration.java
similarity index 85%
rename from java/java-impl/src/com/intellij/codeInspection/streamMigration/ReplaceWithForeachCallFix.java
rename to java/java-impl/src/com/intellij/codeInspection/streamMigration/ForEachMigration.java
index becd6fd93e57..9b20b01c1a30 100644
--- a/java/java-impl/src/com/intellij/codeInspection/streamMigration/ReplaceWithForeachCallFix.java
+++ b/java/java-impl/src/com/intellij/codeInspection/streamMigration/ForEachMigration.java
@@ -23,19 +23,11 @@ import org.jetbrains.annotations.NotNull;
/**
* @author Tagir Valeev
*/
-class ReplaceWithForeachCallFix extends MigrateToStreamFix {
- private static final Logger LOG = Logger.getInstance(ReplaceWithForeachCallFix.class);
+class ForEachMigration extends BaseStreamApiMigration {
+ private static final Logger LOG = Logger.getInstance(ForEachMigration.class);
- private final String myForEachMethodName;
-
- protected ReplaceWithForeachCallFix(String forEachMethodName) {
- myForEachMethodName = forEachMethodName;
- }
-
- @NotNull
- @Override
- public String getFamilyName() {
- return "Replace with " + myForEachMethodName;
+ protected ForEachMigration(String forEachMethodName) {
+ super(forEachMethodName);
}
@Override
@@ -50,7 +42,7 @@ class ReplaceWithForeachCallFix extends MigrateToStreamFix {
StringBuilder buffer = generateStream(tb.getLastOperation(), true);
PsiElement block = tb.convertToElement(elementFactory);
- buffer.append(".").append(myForEachMethodName).append("(");
+ buffer.append(".").append(getReplacement()).append("(");
final String functionalExpressionText = tb.getVariable().getName() + " -> " + wrapInBlock(block);
PsiExpressionStatement callStatement = (PsiExpressionStatement)elementFactory
diff --git a/java/java-impl/src/com/intellij/codeInspection/streamMigration/ReplaceWithMatchFix.java b/java/java-impl/src/com/intellij/codeInspection/streamMigration/MatchMigration.java
similarity index 94%
rename from java/java-impl/src/com/intellij/codeInspection/streamMigration/ReplaceWithMatchFix.java
rename to java/java-impl/src/com/intellij/codeInspection/streamMigration/MatchMigration.java
index 1d0b0a14bfff..62c469db45fb 100644
--- a/java/java-impl/src/com/intellij/codeInspection/streamMigration/ReplaceWithMatchFix.java
+++ b/java/java-impl/src/com/intellij/codeInspection/streamMigration/MatchMigration.java
@@ -28,19 +28,11 @@ import org.jetbrains.annotations.NotNull;
/**
* @author Tagir Valeev
*/
-class ReplaceWithMatchFix extends MigrateToStreamFix {
- private static final Logger LOG = Logger.getInstance("#" + ReplaceWithMatchFix.class.getName());
+class MatchMigration extends BaseStreamApiMigration {
+ private static final Logger LOG = Logger.getInstance("#" + MatchMigration.class.getName());
- private final String myMethodName;
-
- public ReplaceWithMatchFix(String methodName) {
- myMethodName = methodName;
- }
-
- @NotNull
- @Override
- public String getFamilyName() {
- return "Replace with " + myMethodName + "()";
+ public MatchMigration(String methodName) {
+ super(methodName+"()");
}
@Override
diff --git a/java/java-impl/src/com/intellij/codeInspection/streamMigration/MigrateToStreamFix.java b/java/java-impl/src/com/intellij/codeInspection/streamMigration/MigrateToStreamFix.java
index 629e4a319b9d..280fdd9dbe08 100644
--- a/java/java-impl/src/com/intellij/codeInspection/streamMigration/MigrateToStreamFix.java
+++ b/java/java-impl/src/com/intellij/codeInspection/streamMigration/MigrateToStreamFix.java
@@ -18,30 +18,41 @@ package com.intellij.codeInspection.streamMigration;
import com.intellij.codeInspection.LambdaCanBeMethodReferenceInspection;
import com.intellij.codeInspection.LocalQuickFix;
import com.intellij.codeInspection.ProblemDescriptor;
-import com.intellij.codeInspection.streamMigration.StreamApiMigrationInspection.*;
+import com.intellij.codeInspection.SimplifyStreamApiCallChainsInspection;
+import com.intellij.codeInspection.streamMigration.StreamApiMigrationInspection.StreamSource;
+import com.intellij.codeInspection.streamMigration.StreamApiMigrationInspection.TerminalBlock;
import com.intellij.openapi.project.Project;
-import com.intellij.psi.*;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiLoopStatement;
+import com.intellij.psi.PsiStatement;
import com.intellij.psi.codeStyle.CodeStyleManager;
import com.intellij.psi.codeStyle.JavaCodeStyleManager;
-import com.intellij.psi.controlFlow.*;
import com.intellij.psi.impl.PsiDiamondTypeUtil;
-import com.intellij.psi.util.PsiTreeUtil;
-import com.siyeh.ig.psiutils.ExpressionUtils;
-import one.util.streamex.StreamEx;
+import org.jetbrains.annotations.Nls;
import org.jetbrains.annotations.NotNull;
-import java.util.List;
-import java.util.ListIterator;
-import java.util.Objects;
-
/**
* @author Tagir Valeev
*/
-abstract class MigrateToStreamFix implements LocalQuickFix {
+class MigrateToStreamFix implements LocalQuickFix {
+ private BaseStreamApiMigration myMigration;
+
+ protected MigrateToStreamFix(BaseStreamApiMigration migration) {
+ myMigration = migration;
+ }
+
+ @Nls
@NotNull
@Override
public String getName() {
- return getFamilyName();
+ return "Replace with "+myMigration.getReplacement();
+ }
+
+ @SuppressWarnings("DialogTitleCapitalization")
+ @NotNull
+ @Override
+ public String getFamilyName() {
+ return "Replace with Stream API equivalent";
}
@Override
@@ -53,7 +64,7 @@ abstract class MigrateToStreamFix implements LocalQuickFix {
PsiStatement body = loopStatement.getBody();
if(body == null || source == null) return;
TerminalBlock tb = TerminalBlock.from(source, body);
- PsiElement result = migrate(project, loopStatement, body, tb);
+ PsiElement result = myMigration.migrate(project, loopStatement, body, tb);
if(result != null) {
source.cleanUpSource();
simplifyAndFormat(project, result);
@@ -61,109 +72,11 @@ abstract class MigrateToStreamFix implements LocalQuickFix {
}
}
- abstract PsiElement migrate(@NotNull Project project,
- @NotNull PsiLoopStatement loopStatement,
- @NotNull PsiStatement body,
- @NotNull TerminalBlock tb);
-
- static PsiElement replaceWithNumericAddition(@NotNull Project project,
- PsiLoopStatement loopStatement,
- PsiVariable var,
- StringBuilder builder,
- PsiType expressionType) {
- PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(project);
- restoreComments(loopStatement, loopStatement.getBody());
- InitializerUsageStatus status = StreamApiMigrationInspection.getInitializerUsageStatus(var, loopStatement);
- if (status != InitializerUsageStatus.UNKNOWN) {
- PsiExpression initializer = var.getInitializer();
- if (ExpressionUtils.isZero(initializer)) {
- PsiType type = var.getType();
- String replacement = (type.equals(expressionType) ? "" : "(" + type.getCanonicalText() + ") ") + builder;
- return replaceInitializer(loopStatement, var, initializer, replacement, status);
- }
- }
- return loopStatement.replace(elementFactory.createStatementFromText(var.getName() + "+=" + builder + ";", loopStatement));
- }
-
- static PsiElement replaceInitializer(PsiLoopStatement loopStatement,
- PsiVariable var,
- PsiExpression initializer,
- String replacement,
- InitializerUsageStatus status) {
- Project project = loopStatement.getProject();
- PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(project);
- if(status == InitializerUsageStatus.DECLARED_JUST_BEFORE) {
- initializer.replace(elementFactory.createExpressionFromText(replacement, loopStatement));
- removeLoop(loopStatement);
- return var;
- } else {
- if(status == InitializerUsageStatus.AT_WANTED_PLACE_ONLY) {
- initializer.delete();
- }
- return
- loopStatement.replace(elementFactory.createStatementFromText(var.getName() + " = " + replacement + ";", loopStatement));
- }
- }
-
static void simplifyAndFormat(@NotNull Project project, PsiElement result) {
if (result == null) return;
LambdaCanBeMethodReferenceInspection.replaceAllLambdasWithMethodReferences(result);
PsiDiamondTypeUtil.removeRedundantTypeArguments(result);
+ result = SimplifyStreamApiCallChainsInspection.simplifyCollectionStreamCalls(result);
CodeStyleManager.getInstance(project).reformat(JavaCodeStyleManager.getInstance(project).shortenClassReferences(result));
}
-
- static void restoreComments(PsiLoopStatement loopStatement, PsiStatement body) {
- final PsiElement parent = loopStatement.getParent();
- for (PsiElement comment : PsiTreeUtil.findChildrenOfType(body, PsiComment.class)) {
- parent.addBefore(comment, loopStatement);
- }
- }
-
- @NotNull
- static StringBuilder generateStream(@NotNull Operation lastOperation) {
- return generateStream(lastOperation, false);
- }
-
- @NotNull
- static StringBuilder generateStream(@NotNull Operation lastOperation, boolean noStreamForEmpty) {
- StringBuilder buffer = new StringBuilder();
- if(noStreamForEmpty && lastOperation instanceof CollectionStream) {
- return buffer.append(lastOperation.getExpression().getText());
- }
- List replacements =
- StreamEx.iterate(lastOperation, Objects::nonNull, Operation::getPreviousOp).map(Operation::createReplacement).toList();
- for(ListIterator it = replacements.listIterator(replacements.size()); it.hasPrevious(); ) {
- buffer.append(it.previous());
- }
- return buffer;
- }
-
- static String getIteratedValueText(PsiExpression iteratedValue) {
- return iteratedValue instanceof PsiCallExpression ||
- iteratedValue instanceof PsiReferenceExpression ||
- iteratedValue instanceof PsiQualifiedExpression ||
- iteratedValue instanceof PsiParenthesizedExpression ? iteratedValue.getText() : "(" + iteratedValue.getText() + ")";
- }
-
- static void removeLoop(@NotNull PsiLoopStatement statement) {
- PsiElement parent = statement.getParent();
- if (parent instanceof PsiLabeledStatement) {
- parent.delete();
- }
- else {
- statement.delete();
- }
- }
-
- static boolean isReachable(PsiReturnStatement target) {
- ControlFlow flow;
- try {
- flow = ControlFlowFactory.getInstance(target.getProject())
- .getControlFlow(target.getParent(), LocalsOrMyInstanceFieldsControlFlowPolicy.getInstance());
- }
- catch (AnalysisCanceledException e) {
- return true;
- }
- return ControlFlowUtil.isInstructionReachable(flow, flow.getStartOffset(target), 0);
- }
}
diff --git a/java/java-impl/src/com/intellij/codeInspection/streamMigration/StreamApiMigrationInspection.java b/java/java-impl/src/com/intellij/codeInspection/streamMigration/StreamApiMigrationInspection.java
index e56fbe8365be..49fcf2a4b288 100644
--- a/java/java-impl/src/com/intellij/codeInspection/streamMigration/StreamApiMigrationInspection.java
+++ b/java/java-impl/src/com/intellij/codeInspection/streamMigration/StreamApiMigrationInspection.java
@@ -21,7 +21,6 @@ import com.intellij.codeInsight.daemon.GroupNames;
import com.intellij.codeInsight.daemon.impl.analysis.HighlightControlFlowUtil;
import com.intellij.codeInspection.BaseJavaBatchLocalInspectionTool;
import com.intellij.codeInspection.LambdaCanBeMethodReferenceInspection;
-import com.intellij.codeInspection.LocalQuickFix;
import com.intellij.codeInspection.ProblemsHolder;
import com.intellij.codeInspection.ui.MultipleCheckboxOptionsPanel;
import com.intellij.codeInspection.util.OptionalUtil;
@@ -45,6 +44,7 @@ import com.intellij.util.containers.ContainerUtil;
import com.intellij.util.containers.IntArrayList;
import com.siyeh.ig.psiutils.*;
import one.util.streamex.EntryStream;
+import one.util.streamex.MoreCollectors;
import one.util.streamex.StreamEx;
import org.jetbrains.annotations.Contract;
import org.jetbrains.annotations.Nls;
@@ -206,12 +206,12 @@ public class StreamApiMigrationInspection extends BaseJavaBatchLocalInspectionTo
}
@Nullable
- private static PsiLocalVariable getIncrementedVariable(TerminalBlock tb, List variables) {
+ private static PsiLocalVariable getIncrementedVariable(PsiExpression expression, TerminalBlock tb, List variables) {
// have only one non-final variable
if(variables.size() != 1) return null;
// have single expression which is either ++x or x++ or x+=1 or x=x+1
- PsiExpression operand = extractIncrementedLValue(tb.getSingleExpression(PsiExpression.class));
+ PsiExpression operand = extractIncrementedLValue(expression);
if(!(operand instanceof PsiReferenceExpression)) return null;
PsiElement element = ((PsiReferenceExpression)operand).resolve();
@@ -306,6 +306,24 @@ public class StreamApiMigrationInspection extends BaseJavaBatchLocalInspectionTo
return extractQualifierClass(tb, call) != null && !tb.dependsOn(qualifierExpression) && canCollect(loop, call);
}
+ private static boolean isCountOperation(PsiLoopStatement statement, List nonFinalVariables, TerminalBlock tb) {
+ PsiLocalVariable variable = getIncrementedVariable(tb.getSingleExpression(PsiExpression.class), tb, nonFinalVariables);
+ LimitOp limitOp = tb.getLastOperation(LimitOp.class);
+ if (limitOp == null) {
+ return variable != null;
+ }
+ PsiExpression counter = PsiUtil.skipParenthesizedExprDown(limitOp.getCountExpression());
+ if (tb.isEmpty()) {
+ // like "if(++count == limit) break"
+ variable = getIncrementedVariable(counter, tb, nonFinalVariables);
+ } else if (!ExpressionUtils.isReferenceTo(counter, variable)) {
+ return false;
+ }
+ return variable != null &&
+ ExpressionUtils.isZero(variable.getInitializer()) &&
+ getInitializerUsageStatus(variable, statement) != UNKNOWN;
+ }
+
private static boolean isCollectCall(TerminalBlock tb) {
PsiMethodCallExpression call = tb.getSingleMethodCall();
if (!isCallOf(call, CommonClassNames.JAVA_UTIL_COLLECTION, "add")) return false;
@@ -314,8 +332,20 @@ public class StreamApiMigrationInspection extends BaseJavaBatchLocalInspectionTo
if (tb.dependsOn(qualifierExpression)) return false;
- if (extractQualifierClass(tb, call) != null) return true;
- if (qualifierExpression instanceof PsiMethodCallExpression) {
+ LimitOp limitOp = tb.getLastOperation(LimitOp.class);
+ PsiClass qualifierClass = extractQualifierClass(tb, call);
+ if (qualifierClass != null) {
+ if (limitOp == null) return true;
+ // like "list.add(x); if(list.size() >= limit) break;"
+ PsiExpression count = limitOp.getCountExpression();
+ if(!(count instanceof PsiMethodCallExpression)) return false;
+ PsiMethodCallExpression sizeCall = (PsiMethodCallExpression)count;
+ PsiExpression sizeQualifier = sizeCall.getMethodExpression().getQualifierExpression();
+ return isCallOf(sizeCall, CommonClassNames.JAVA_UTIL_COLLECTION, "size") &&
+ EquivalenceChecker.getCanonicalPsiEquivalence().expressionsAreEquivalent(sizeQualifier, qualifierExpression) &&
+ InheritanceUtil.isInheritor(qualifierClass, CommonClassNames.JAVA_UTIL_LIST);
+ }
+ if (qualifierExpression instanceof PsiMethodCallExpression && limitOp == null) {
PsiMethodCallExpression qualifierCall = (PsiMethodCallExpression)qualifierExpression;
if (isCallOf(qualifierCall, CommonClassNames.JAVA_UTIL_MAP, "computeIfAbsent")) {
PsiExpression[] args = qualifierCall.getArgumentList().getExpressions();
@@ -324,7 +354,7 @@ public class StreamApiMigrationInspection extends BaseJavaBatchLocalInspectionTo
PsiExpression body = LambdaUtil.extractSingleExpressionFromBody(lambda.getBody());
if (!(body instanceof PsiNewExpression)) return false;
PsiExpressionList ctorArgs = ((PsiNewExpression)body).getArgumentList();
- return ctorArgs != null && ctorArgs.getExpressions().length == 0;
+ return ctorArgs != null && ctorArgs.getExpressions().length == 0 && extractQualifierClass(tb, qualifierCall) != null;
}
}
return false;
@@ -591,115 +621,128 @@ public class StreamApiMigrationInspection extends BaseJavaBatchLocalInspectionTo
TerminalBlock tb = TerminalBlock.from(source, body);
if(tb.isEmpty()) return;
+ BaseStreamApiMigration migration = findMigration(statement, body, tb);
+ if(migration != null) {
+ MigrateToStreamFix[] fixes = {new MigrateToStreamFix(migration)};
+ if (migration instanceof ForEachMigration && tb.hasOperations()) { //for .stream()
+ fixes = ArrayUtil.append(fixes, new MigrateToStreamFix(new ForEachMigration("forEachOrdered")));
+ }
+ myHolder.registerProblem(statement, getRange(statement).shiftRight(-statement.getTextOffset()),
+ "Can be replaced with '" + migration.getReplacement() + "' call", fixes);
+ }
+ }
+
+ @Nullable
+ private BaseStreamApiMigration findMigration(PsiLoopStatement loop, PsiStatement body, TerminalBlock tb) {
final ControlFlow controlFlow;
try {
controlFlow = ControlFlowFactory.getInstance(myHolder.getProject())
.getControlFlow(body, LocalsOrMyInstanceFieldsControlFlowPolicy.getInstance());
}
catch (AnalysisCanceledException ignored) {
- return;
+ return null;
}
- int startOffset = tb.getStartOffset(controlFlow);
- int endOffset = tb.getEndOffset(controlFlow);
- if(startOffset < 0 || endOffset < 0) return;
- final Collection exitPoints = ControlFlowUtil
- .findExitPointsAndStatements(controlFlow, startOffset, endOffset, new IntArrayList(), PsiContinueStatement.class,
- PsiBreakStatement.class, PsiReturnStatement.class, PsiThrowStatement.class);
- startOffset = controlFlow.getStartOffset(body);
- endOffset = controlFlow.getEndOffset(body);
- if(startOffset < 0 || endOffset < 0) return;
- PsiElement surrounder = PsiTreeUtil.getParentOfType(statement, PsiLambdaExpression.class, PsiClass.class);
+ int startOffset = controlFlow.getStartOffset(body);
+ int endOffset = controlFlow.getEndOffset(body);
+ if(startOffset < 0 || endOffset < 0) return null;
+ PsiElement surrounder = PsiTreeUtil.getParentOfType(loop, PsiLambdaExpression.class, PsiClass.class);
final List nonFinalVariables = StreamEx.of(ControlFlowUtil.getUsedVariables(controlFlow, startOffset, endOffset))
.remove(variable -> variable instanceof PsiField)
.remove(variable -> PsiTreeUtil.getParentOfType(variable, PsiLambdaExpression.class, PsiClass.class) != surrounder)
- .remove(variable -> isVariableSuitableForStream(variable, statement, tb)).toList();
+ .remove(variable -> isVariableSuitableForStream(variable, loop, tb)).toList();
- if (exitPoints.isEmpty()) {
- if(getIncrementedVariable(tb, nonFinalVariables) != null) {
- registerProblem(statement, "count", new ReplaceWithCountFix());
- }
- if(getAccumulatedVariable(tb, nonFinalVariables) != null) {
- registerProblem(statement, "sum", new ReplaceWithSumFix());
- }
- if(!nonFinalVariables.isEmpty()) {
- return;
- }
- if (isCollectCall(tb)) {
- boolean addAll = statement instanceof PsiForeachStatement && !tb.hasOperations() && isAddAllCall(tb);
- String methodName;
- if(addAll) {
- methodName = "addAll";
- } else {
- PsiMethodCallExpression call = tb.getSingleMethodCall();
- if(call != null && call.getMethodExpression().getQualifierExpression() instanceof PsiMethodCallExpression) {
- call = (PsiMethodCallExpression)call.getMethodExpression().getQualifierExpression();
- }
- if(canCollect(statement, call)) {
- if(extractToArrayExpression(statement, call) != null)
- methodName = "toArray";
- else
- methodName = "collect";
- } else {
- if (!SUGGEST_FOREACH) return;
- methodName = "forEach";
- }
- }
- registerProblem(statement, methodName, new ReplaceWithCollectFix(methodName));
- }
- else if (isCollectMapCall(statement, tb) && (REPLACE_TRIVIAL_FOREACH || tb.hasOperations())) {
- registerProblem(statement, "collect", new ReplaceWithCollectFix("collect"));
- }
- // do not replace for(T e : arr) {} with Arrays.stream(arr).forEach(e -> {}) even if flag is set
- else if (SUGGEST_FOREACH &&
- (tb.hasOperations() || (!(source instanceof ArrayStream) && (REPLACE_TRIVIAL_FOREACH || !isTrivial(body, statement))))) {
- ReplaceWithForeachCallFix forEachFix = new ReplaceWithForeachCallFix("forEach");
- LocalQuickFix[] fixes = {forEachFix};
- if (tb.hasOperations()) { //for .stream()
- fixes = new LocalQuickFix[] {forEachFix, new ReplaceWithForeachCallFix("forEachOrdered")};
- }
- registerProblem(statement, "forEach", fixes);
- }
- } else {
- if (!tb.hasOperations() && !REPLACE_TRIVIAL_FOREACH) return;
- if (nonFinalVariables.isEmpty() && tb.getSingleStatement() instanceof PsiReturnStatement) {
- handleSingleReturn(statement, tb);
- }
- // Source and intermediate ops should not refer to non-final variables
- if (tb.intermediateAndSourceExpressions()
- .flatCollection(expr -> PsiTreeUtil.collectElementsOfType(expr, PsiReferenceExpression.class))
- .map(PsiReferenceExpression::resolve).anyMatch(nonFinalVariables::contains)) {
- return;
- }
- PsiStatement[] statements = tb.getStatements();
- if (statements.length == 2) {
- PsiStatement breakStatement = statements[1];
- if (!ControlFlowUtils.statementBreaksLoop(breakStatement, statement)) {
- return;
- }
- if (ReferencesSearch.search(tb.getVariable(), new LocalSearchScope(statements)).findFirst() == null
- && exitPoints.size() == 1 && exitPoints.contains(breakStatement)) {
- registerProblem(statement, "anyMatch", new ReplaceWithMatchFix("anyMatch"));
- return;
- }
- if (nonFinalVariables.isEmpty() && statements[0] instanceof PsiExpressionStatement) {
- registerProblem(statement, "findFirst", new ReplaceWithFindFirstFix());
- } else if (nonFinalVariables.size() == 1) {
- PsiAssignmentExpression assignment = ExpressionUtils.getAssignment(statements[0]);
- if(assignment == null) return;
- PsiExpression lValue = assignment.getLExpression();
- if (!(lValue instanceof PsiReferenceExpression)) return;
- PsiElement var = ((PsiReferenceExpression)lValue).resolve();
- if(!(var instanceof PsiVariable) || !nonFinalVariables.contains(var)) return;
- PsiExpression rValue = assignment.getRExpression();
- if(rValue == null || VariableAccessUtils.variableIsUsed((PsiVariable)var, rValue)) return;
- if(tb.getVariable().getType() instanceof PsiPrimitiveType && !ExpressionUtils.isReferenceTo(rValue, tb.getVariable())) return;
- registerProblem(statement, "findFirst", new ReplaceWithFindFirstFix());
- }
+ TerminalBlock tbWithLimit = tb.tryPeelLimit(loop);
+ if (isCountOperation(loop, nonFinalVariables, tbWithLimit)) {
+ return new CountMigration();
+ }
+ if (getAccumulatedVariable(tb, nonFinalVariables) != null) {
+ return new SumMigration();
+ }
+ if (isCollectCall(tbWithLimit) && nonFinalVariables.isEmpty()) {
+ return findCollectMigration(loop, tbWithLimit);
+ }
+ if (isCollectMapCall(loop, tb) && nonFinalVariables.isEmpty() && (REPLACE_TRIVIAL_FOREACH || tb.hasOperations())) {
+ return new CollectMigration("collect");
+ }
+ Collection exitPoints = tb.findExitPoints(controlFlow);
+ if (exitPoints == null) return null;
+ // do not replace for(T e : arr) {} with Arrays.stream(arr).forEach(e -> {}) even if flag is set
+ if (SUGGEST_FOREACH && exitPoints.isEmpty() && nonFinalVariables.isEmpty() &&
+ (tb.hasOperations() ||
+ (!(tb.getSource() instanceof ArrayStream) && (REPLACE_TRIVIAL_FOREACH || !isTrivial(body, loop))))) {
+ return new ForEachMigration("forEach");
+ }
+ if (!tb.hasOperations() && !REPLACE_TRIVIAL_FOREACH) return null;
+ if (nonFinalVariables.isEmpty() && tb.getSingleStatement() instanceof PsiReturnStatement) {
+ return findMigrationForReturn(loop, tb);
+ }
+ // Source and intermediate ops should not refer to non-final variables
+ if (tb.intermediateAndSourceExpressions()
+ .flatCollection(expr -> PsiTreeUtil.collectElementsOfType(expr, PsiReferenceExpression.class))
+ .map(PsiReferenceExpression::resolve).select(PsiVariable.class).anyMatch(nonFinalVariables::contains)) {
+ return null;
+ }
+ PsiStatement[] statements = tb.getStatements();
+ if (statements.length == 2) {
+ PsiStatement breakStatement = statements[1];
+ if (ControlFlowUtils.statementBreaksLoop(breakStatement, loop) &&
+ exitPoints.size() == 1 &&
+ exitPoints.contains(breakStatement)) {
+ return findMigrationForBreak(tb, nonFinalVariables, statements[0]);
}
}
+ return null;
}
- void handleSingleReturn(PsiLoopStatement statement, TerminalBlock tb) {
+ @Nullable
+ private BaseStreamApiMigration findMigrationForBreak(TerminalBlock tb, List nonFinalVariables, PsiStatement statement) {
+ if (ReferencesSearch.search(tb.getVariable(), new LocalSearchScope(statement)).findFirst() == null) {
+ return new MatchMigration("anyMatch");
+ }
+ if (nonFinalVariables.isEmpty() && statement instanceof PsiExpressionStatement) {
+ return new FindFirstMigration();
+ }
+ if (nonFinalVariables.size() == 1) {
+ PsiAssignmentExpression assignment = ExpressionUtils.getAssignment(statement);
+ if(assignment == null) return null;
+ PsiExpression lValue = assignment.getLExpression();
+ if (!(lValue instanceof PsiReferenceExpression)) return null;
+ PsiElement var = ((PsiReferenceExpression)lValue).resolve();
+ if(!(var instanceof PsiVariable) || !nonFinalVariables.contains(var)) return null;
+ PsiExpression rValue = assignment.getRExpression();
+ if(rValue == null || VariableAccessUtils.variableIsUsed((PsiVariable)var, rValue)) return null;
+ if(tb.getVariable().getType() instanceof PsiPrimitiveType && !ExpressionUtils.isReferenceTo(rValue, tb.getVariable())) return null;
+ return new FindFirstMigration();
+ }
+ return null;
+ }
+
+ @Nullable
+ private BaseStreamApiMigration findCollectMigration(PsiLoopStatement statement, TerminalBlock tb) {
+ boolean addAll = statement instanceof PsiForeachStatement && !tb.hasOperations() && isAddAllCall(tb);
+ String methodName;
+ if(addAll) {
+ methodName = "addAll";
+ } else {
+ PsiMethodCallExpression call = tb.getSingleMethodCall();
+ if(call != null && call.getMethodExpression().getQualifierExpression() instanceof PsiMethodCallExpression) {
+ call = (PsiMethodCallExpression)call.getMethodExpression().getQualifierExpression();
+ }
+ if(canCollect(statement, call)) {
+ if(extractToArrayExpression(statement, call) != null)
+ methodName = "toArray";
+ else
+ methodName = "collect";
+ } else {
+ if (!SUGGEST_FOREACH || tb.getLastOperation() instanceof LimitOp) return null;
+ methodName = "forEach";
+ }
+ }
+ return new CollectMigration(methodName);
+ }
+
+ @Nullable
+ private BaseStreamApiMigration findMigrationForReturn(PsiLoopStatement statement, TerminalBlock tb) {
PsiReturnStatement returnStatement = (PsiReturnStatement)tb.getSingleStatement();
PsiExpression value = returnStatement.getReturnValue();
PsiReturnStatement nextReturnStatement = getNextReturnStatement(statement);
@@ -712,29 +755,29 @@ public class StreamApiMigrationInspection extends BaseJavaBatchLocalInspectionTo
}
else {
methodName = "noneMatch";
- Operation lastOp = tb.getLastOperation();
- if(lastOp instanceof FilterOp && (((FilterOp)lastOp).isNegated() ^ BoolUtils.isNegation(lastOp.getExpression()))) {
+ FilterOp lastFilter = tb.getLastOperation(FilterOp.class);
+ if(lastFilter != null && (lastFilter.isNegated() ^ BoolUtils.isNegation(lastFilter.getExpression()))) {
methodName = "allMatch";
}
}
if(nextReturnStatement.getParent() == statement.getParent() ||
ExpressionUtils.isLiteral(nextReturnStatement.getReturnValue(), !foundResult)) {
- registerProblem(statement, methodName, new ReplaceWithMatchFix(methodName));
- return;
+ return new MatchMigration(methodName);
}
}
if (!VariableAccessUtils.variableIsUsed(tb.getVariable(), value)) {
Operation lastOp = tb.getLastOperation();
if (!REPLACE_TRIVIAL_FOREACH && lastOp instanceof StreamSource ||
(lastOp instanceof FilterOp && lastOp.getPreviousOp() instanceof StreamSource)) {
- return;
+ return null;
}
- registerProblem(statement, "anyMatch", new ReplaceWithMatchFix("anyMatch"));
+ return new MatchMigration("anyMatch");
}
if(nextReturnStatement != null && ExpressionUtils.isSimpleExpression(nextReturnStatement.getReturnValue())
&& (!(tb.getVariable().getType() instanceof PsiPrimitiveType) || ExpressionUtils.isReferenceTo(value, tb.getVariable()))) {
- registerProblem(statement, "findFirst", new ReplaceWithFindFirstFix());
+ return new FindFirstMigration();
}
+ return null;
}
@NotNull
@@ -766,11 +809,6 @@ public class StreamApiMigrationInspection extends BaseJavaBatchLocalInspectionTo
throw new IllegalStateException("Unexpected statement type: "+statement);
}
}
-
- private void registerProblem(PsiLoopStatement statement, String methodName, LocalQuickFix... fixes) {
- myHolder.registerProblem(statement, getRange(statement).shiftRight(-statement.getTextOffset()),
- "Can be replaced with '" + methodName + "' call", fixes);
- }
}
/**
@@ -1057,6 +1095,40 @@ public class StreamApiMigrationInspection extends BaseJavaBatchLocalInspectionTo
}
}
+ static class LimitOp extends Operation {
+ private final PsiExpression myCounter;
+ private final int myDelta;
+
+ LimitOp(@Nullable Operation previousOp, PsiExpression counter, PsiExpression expression, PsiVariable variable, int delta) {
+ super(previousOp, expression, variable);
+ LOG.assertTrue(delta >= 0);
+ myDelta = delta;
+ myCounter = counter;
+ }
+
+ @Override
+ String createReplacement() {
+ return ".limit(" + getLimitExpression() + ")";
+ }
+
+ PsiExpression getCountExpression() {
+ return myCounter;
+ }
+
+ private String getLimitExpression() {
+ if(myDelta == 0) {
+ return myExpression.getText();
+ }
+ if (myExpression instanceof PsiLiteralExpression) {
+ Object value = ((PsiLiteralExpression)myExpression).getValue();
+ if (value instanceof Integer || value instanceof Long) {
+ return String.valueOf(((Number)value).longValue() + myDelta);
+ }
+ }
+ return ParenthesesUtils.getText(myExpression, ParenthesesUtils.ADDITIVE_PRECEDENCE) + "+" + myDelta;
+ }
+ }
+
abstract static class StreamSource extends Operation {
protected StreamSource(PsiVariable variable, PsiExpression expression) {
super(null, expression, variable);
@@ -1307,12 +1379,13 @@ public class StreamApiMigrationInspection extends BaseJavaBatchLocalInspectionTo
myPreviousOp = previousOp;
}
- int getStartOffset(ControlFlow cf) {
- return cf.getStartOffset(myStatements[0]);
- }
-
- int getEndOffset(ControlFlow cf) {
- return cf.getEndOffset(myStatements[myStatements.length-1]);
+ Collection findExitPoints(ControlFlow controlFlow) {
+ int startOffset = controlFlow.getStartOffset(myStatements[0]);
+ int endOffset = controlFlow.getEndOffset(myStatements[myStatements.length - 1]);
+ if (startOffset < 0 || endOffset < 0) return null;
+ return ControlFlowUtil
+ .findExitPointsAndStatements(controlFlow, startOffset, endOffset, new IntArrayList(), PsiContinueStatement.class,
+ PsiBreakStatement.class, PsiReturnStatement.class, PsiThrowStatement.class);
}
PsiStatement getSingleStatement() {
@@ -1453,11 +1526,76 @@ public class StreamApiMigrationInspection extends BaseJavaBatchLocalInspectionTo
return null;
}
+ /**
+ * Try to peel off the condition like if(count > limit) break; from the end of current terminal block.
+ *
+ * It's not guaranteed that the peeled condition actually could be translated to the limit operation:
+ * additional checks will be necessary
+ *
+ * @param loop a main loop for which the condition should be peeled off
+ * @return new terminal block with additional limit operation or self if peeling is failed.
+ *
+ */
+ TerminalBlock tryPeelLimit(PsiLoopStatement loop) {
+ if(myStatements.length == 0) return this;
+ TerminalBlock tb = this;
+ PsiStatement[] statements = {};
+ if(myStatements.length > 1) {
+ statements = new PsiStatement[]{myStatements[0]};
+ tb = new TerminalBlock(myPreviousOp, myVariable, Arrays.copyOfRange(myStatements, 1, myStatements.length)).extractFilter();
+ }
+ if (tb == null || !ControlFlowUtils.statementBreaksLoop(tb.getSingleStatement(), loop)) return this;
+ FilterOp filter = tb.getLastOperation(FilterOp.class);
+ if(filter == null) return this;
+ PsiExpression condition = PsiUtil.skipParenthesizedExprDown(filter.getExpression());
+ if(!(condition instanceof PsiBinaryExpression)) return this;
+ PsiBinaryExpression binOp = (PsiBinaryExpression)condition;
+ if(!ComparisonUtils.isComparison(binOp)) return this;
+ String comparison = filter.isNegated() ? ComparisonUtils.getNegatedComparison(binOp.getOperationTokenType())
+ : binOp.getOperationSign().getText();
+ boolean flipped = false;
+ int delta = 0;
+ switch (comparison) {
+ case "==":
+ case ">=":
+ break;
+ case ">":
+ delta = 1;
+ break;
+ case "<":
+ delta = 1;
+ flipped = true;
+ break;
+ case "<=":
+ flipped = true;
+ break;
+ default:
+ return this;
+ }
+ PsiExpression counter = PsiUtil.skipParenthesizedExprDown(flipped ? binOp.getROperand() : binOp.getLOperand());
+ if(counter == null || VariableAccessUtils.variableIsUsed(myVariable, counter)) return this;
+ PsiExpression limit = flipped ? binOp.getLOperand() : binOp.getROperand();
+ if(!ExpressionUtils.isSimpleExpression(limit) || VariableAccessUtils.variableIsUsed(myVariable, limit)) return this;
+ PsiType type = limit.getType();
+ if(!PsiType.INT.equals(type) && !PsiType.LONG.equals(type)) return this;
+ if(counter instanceof PsiPostfixExpression) {
+ delta++;
+ }
+
+ LimitOp limitOp = new LimitOp(filter.getPreviousOp(), counter, limit, myVariable, delta);
+ return new TerminalBlock(limitOp, myVariable, statements);
+ }
+
@NotNull
public Operation getLastOperation() {
return myPreviousOp;
}
+ @Nullable
+ public T getLastOperation(Class clazz) {
+ return clazz.isInstance(myPreviousOp) ? clazz.cast(myPreviousOp) : null;
+ }
+
/**
* Extract all possible intermediate operations
* @return the terminal block with all possible terminal operations extracted (may return this if no operations could be extracted)
@@ -1491,6 +1629,11 @@ public class StreamApiMigrationInspection extends BaseJavaBatchLocalInspectionTo
return ops;
}
+ public StreamSource getSource() {
+ return operations().select(StreamSource.class).collect(MoreCollectors.onlyOne())
+ .orElseThrow(IllegalStateException::new);
+ }
+
/**
* @return stream of physical expressions used in intermediate operations in arbitrary order
*/
diff --git a/java/java-impl/src/com/intellij/codeInspection/streamMigration/ReplaceWithSumFix.java b/java/java-impl/src/com/intellij/codeInspection/streamMigration/SumMigration.java
similarity index 94%
rename from java/java-impl/src/com/intellij/codeInspection/streamMigration/ReplaceWithSumFix.java
rename to java/java-impl/src/com/intellij/codeInspection/streamMigration/SumMigration.java
index 0d9b6f050925..3d0ebbcda6d0 100644
--- a/java/java-impl/src/com/intellij/codeInspection/streamMigration/ReplaceWithSumFix.java
+++ b/java/java-impl/src/com/intellij/codeInspection/streamMigration/SumMigration.java
@@ -25,13 +25,9 @@ import org.jetbrains.annotations.NotNull;
/**
* @author Tagir Valeev
*/
-class ReplaceWithSumFix extends MigrateToStreamFix {
+class SumMigration extends BaseStreamApiMigration {
- @NotNull
- @Override
- public String getFamilyName() {
- return "Replace with sum()";
- }
+ SumMigration() {super("sum()");}
@Override
PsiElement migrate(@NotNull Project project,
diff --git a/java/java-impl/src/com/intellij/codeInspection/streamToLoop/FunctionHelper.java b/java/java-impl/src/com/intellij/codeInspection/streamToLoop/FunctionHelper.java
index fccbd5dbfa7b..66f9802de6fc 100644
--- a/java/java-impl/src/com/intellij/codeInspection/streamToLoop/FunctionHelper.java
+++ b/java/java-impl/src/com/intellij/codeInspection/streamToLoop/FunctionHelper.java
@@ -34,7 +34,11 @@ import org.jetbrains.annotations.Contract;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
-import java.util.*;
+import java.text.MessageFormat;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
import java.util.function.Consumer;
/**
@@ -55,7 +59,7 @@ abstract class FunctionHelper {
return myResultType;
}
- String getText() {
+ final String getText() {
return getExpression().getText();
}
@@ -63,23 +67,26 @@ abstract class FunctionHelper {
/**
* Try to perform "light" transformation. Works only for single-argument SAM. The function helper decides by itself
- * how to name the SAM argument and returns it. After this method invocation normal transform cannot be performed.
+ * how to name the SAM argument and returns the assigned name. After this method invocation normal transform cannot be performed.
*
* @return SAM argument name or null if function helper refused to perform a transformation.
- * @param type
+ * @param type type of the input variable (after generic substitution if applicable)
*/
String tryLightTransform(PsiType type) {
return null;
}
/**
- * Perform an adaptation of current function helper to the replacement context with given parameter names.
- * Must be called exactly once prior using getExpression() or getText()
+ * Adapts this function helper converting it to the valid expression and inlining SAM parameters with provided values.
+ * Must be called exactly once prior using getExpression() or getText().
*
* @param context a context for which transformation should be performed
- * @param newNames names of the SAM parameters (the length must be exactly the same as number of SAM parameters)
+ * @param argumentValues values (expressions) of the SAM parameters to be inlined into function body
+ * (the length must be exactly the same as the number of SAM parameters).
+ * Usually it's just the references to the existing variables, but other expressions
+ * (e.g. constant literals) could be used as well if necessary.
*/
- abstract void transform(StreamToLoopReplacementContext context, String... newNames);
+ abstract void transform(StreamToLoopReplacementContext context, String... argumentValues);
/**
* Rename the references of some variable if it's used inside this function
@@ -148,22 +155,73 @@ abstract class FunctionHelper {
if (expression instanceof PsiMethodReferenceExpression) {
PsiMethodReferenceExpression methodRef = (PsiMethodReferenceExpression)expression;
if (methodRef.resolve() == null) return null;
+ String template = tryInlineMethodReference(paramCount, methodRef);
+ if (template != null) {
+ return new InlinedFunctionHelper(returnType, paramCount, template);
+ }
return new MethodReferenceFunctionHelper(returnType, type, methodRef);
}
if (expression instanceof PsiReferenceExpression && ExpressionUtils.isSimpleExpression(expression)) {
return new SimpleReferenceFunctionHelper(returnType, expression, interfaceMethod.getName());
}
- if (expression instanceof PsiMethodCallExpression &&
- MethodCallUtils
- .isCallToStaticMethod((PsiMethodCallExpression)expression, CommonClassNames.JAVA_UTIL_FUNCTION_FUNCTION, "identity", 0)) {
- return paramCount == 1 ? new IdentityFunctionHelper(returnType) : null;
+ if (expression instanceof PsiMethodCallExpression) {
+ PsiMethodCallExpression call = (PsiMethodCallExpression)expression;
+ if (MethodCallUtils.isCallToStaticMethod(call, CommonClassNames.JAVA_UTIL_FUNCTION_FUNCTION, "identity", 0)) {
+ return paramCount == 1 ? new InlinedFunctionHelper(returnType, 1, "{0}") : null;
+ }
+ if (MethodCallUtils.isCallToStaticMethod(call, CommonClassNames.JAVA_UTIL_COMPARATOR, "naturalOrder", 0)) {
+ return paramCount == 2 ? new InlinedFunctionHelper(returnType, 2, "{0}.compareTo({1})") : null;
+ }
+ if (MethodCallUtils.isCallToStaticMethod(call, CommonClassNames.JAVA_UTIL_COMPARATOR, "reverseOrder", 0) ||
+ MethodCallUtils.isCallToStaticMethod(call, CommonClassNames.JAVA_UTIL_COLLECTIONS, "reverseOrder", 0)) {
+ return paramCount == 2 ? new InlinedFunctionHelper(returnType, 2, "{1}.compareTo({0})") : null;
+ }
}
return new ComplexExpressionFunctionHelper(returnType, type, interfaceMethod.getName(), expression);
}
+ @Nullable
+ private static String tryInlineMethodReference(int paramCount, PsiMethodReferenceExpression methodRef) {
+ PsiElement element = methodRef.resolve();
+ if (element instanceof PsiMethod) {
+ PsiMethod method = (PsiMethod)element;
+ String name = method.getName();
+ PsiClass aClass = method.getContainingClass();
+ if (aClass != null) {
+ String className = aClass.getQualifiedName();
+ if("java.util.Objects".equals(className) && paramCount == 1) {
+ if (name.equals("nonNull")) {
+ return "{0}!=null";
+ }
+ if (name.equals("isNull")) {
+ return "{0}==null";
+ }
+ }
+ if (paramCount == 2 && name.equals("sum") && (CommonClassNames.JAVA_LANG_INTEGER.equals(className) ||
+ CommonClassNames.JAVA_LANG_LONG.equals(className) ||
+ CommonClassNames.JAVA_LANG_DOUBLE.equals(className))) {
+ return "{0}+{1}";
+ }
+ if(CommonClassNames.JAVA_LANG_CLASS.equals(className) && paramCount == 1) {
+ PsiExpression qualifier = methodRef.getQualifierExpression();
+ if(qualifier instanceof PsiClassObjectAccessExpression) {
+ PsiTypeElement type = ((PsiClassObjectAccessExpression)qualifier).getOperand();
+ if(name.equals("isInstance")) {
+ return "{0} instanceof "+type.getText();
+ }
+ if(name.equals("cast")) {
+ return "("+type.getText()+"){0}";
+ }
+ }
+ }
+ }
+ }
+ return null;
+ }
+
@NotNull
@Contract(pure = true)
- static FunctionHelper hashMapSupplier(PsiType type) {
+ static FunctionHelper newObjectSupplier(PsiType type, String instanceClassName) {
return new FunctionHelper(type) {
PsiExpression myExpression;
@@ -173,39 +231,47 @@ abstract class FunctionHelper {
}
@Override
- void transform(StreamToLoopReplacementContext context, String... newNames) {
- LOG.assertTrue(newNames.length == 0);
- myExpression = context.createExpression("new java.util.HashMap<>()");
+ void transform(StreamToLoopReplacementContext context, String... argumentValues) {
+ LOG.assertTrue(argumentValues.length == 0);
+ myExpression = context.createExpression("new "+instanceClassName+"<>()");
}
};
}
- /**
- * Renames references to the variable oldName in given expression into newName
- * @param expression an expression to search-and-replace references inside
- * @param oldName old name
- * @param newName new name
- * @param context context
- * @return resulting expression (might be the same as input expression) or null if expression already had references to newName,
- * so rename may merge two variables
- */
- @NotNull
- static PsiExpression renameVarReference(@NotNull PsiExpression expression,
- String oldName,
- String newName,
- StreamToLoopReplacementContext context) {
- if(oldName.equals(newName)) return expression;
- PsiLambdaExpression lambda = (PsiLambdaExpression)context.createExpression("("+oldName+","+newName+")-> "+expression.getText());
- PsiParameter[] parameters = lambda.getParameterList().getParameters();
- PsiParameter oldVar = parameters[0];
- PsiParameter newVar = parameters[1];
+ static boolean hasVarReference(PsiExpression expression, String name, StreamToLoopReplacementContext context) {
+ PsiLambdaExpression lambda = (PsiLambdaExpression)context.createExpression(name+"->"+expression.getText());
+ PsiParameter var = lambda.getParameterList().getParameters()[0];
PsiElement body = lambda.getBody();
LOG.assertTrue(body != null);
- if(ReferencesSearch.search(newVar, new LocalSearchScope(body)).findFirst() != null) {
- throw new IllegalStateException("Reference with name "+newVar+" already exists in "+lambda.getText());
- }
- for (PsiReference ref : ReferencesSearch.search(oldVar, new LocalSearchScope(body)).findAll()) {
- ref.handleElementRename(newName);
+ return ReferencesSearch.search(var, new LocalSearchScope(body)).findFirst() != null;
+ }
+
+ /**
+ * Replaces all the references to the variable {@code name} in given expression with {@code replacement}.
+ *
+ *
+ * If the replacement is a new name to the variable, the caller must take care that this new name was not used before.
+ *
+ *
+ * @param expression an expression to search-and-replace references inside
+ * @param name a reference name to replace
+ * @param replacement a replacement expression (new name or literal)
+ * @param context context
+ * @return resulting expression (might be the same as input expression)
+ */
+ @NotNull
+ static PsiExpression replaceVarReference(@NotNull PsiExpression expression,
+ String name,
+ String replacement,
+ StreamToLoopReplacementContext context) {
+ if(name.equals(replacement)) return expression;
+ PsiLambdaExpression lambda = (PsiLambdaExpression)context.createExpression(name+"->"+expression.getText());
+ PsiParameter var = lambda.getParameterList().getParameters()[0];
+ PsiElement body = lambda.getBody();
+ LOG.assertTrue(body != null);
+ PsiExpression replacementExpression = context.createExpression(replacement);
+ for (PsiReference ref : ReferencesSearch.search(var, new LocalSearchScope(body)).findAll()) {
+ ref.getElement().replace(replacementExpression);
}
return (PsiExpression)lambda.getBody();
}
@@ -273,7 +339,7 @@ abstract class FunctionHelper {
}
@Override
- void transform(StreamToLoopReplacementContext context, String... newNames) {
+ void transform(StreamToLoopReplacementContext context, String... argumentValues) {
PsiMethodReferenceExpression methodRef = fromText(context, myMethodRef.getText());
PsiExpression qualifier = methodRef.getQualifierExpression();
if(qualifier != null) {
@@ -303,8 +369,8 @@ abstract class FunctionHelper {
PsiElement body = lambda.getBody();
LOG.assertTrue(body instanceof PsiExpression);
myExpression = (PsiExpression)body;
- EntryStream.zip(lambda.getParameterList().getParameters(), newNames)
- .forKeyValue((param, newName) -> myExpression = renameVarReference(myExpression, param.getName(), newName, context));
+ EntryStream.zip(lambda.getParameterList().getParameters(), argumentValues)
+ .forKeyValue((param, newName) -> myExpression = replaceVarReference(myExpression, param.getName(), newName, context));
}
@Override
@@ -336,7 +402,7 @@ abstract class FunctionHelper {
if(oldName.equals(newName)) return;
PsiExpression qualifier = myMethodRef.getQualifierExpression();
if(qualifier == null) return;
- qualifier = renameVarReference(qualifier, oldName, newName, context);
+ qualifier = replaceVarReference(qualifier, oldName, newName, context);
myMethodRef = fromText(context, qualifier.getText()+"::"+myMethodRef.getReferenceName());
}
}
@@ -382,7 +448,7 @@ abstract class FunctionHelper {
@Override
void rename(String oldName, String newName, StreamToLoopReplacementContext context) {
- myExpression = renameVarReference(myExpression, oldName, newName, context);
+ myExpression = replaceVarReference(myExpression, oldName, newName, context);
}
@Override
@@ -391,9 +457,9 @@ abstract class FunctionHelper {
}
@Override
- void transform(StreamToLoopReplacementContext context, String... newNames) {
+ void transform(StreamToLoopReplacementContext context, String... argumentValues) {
String varName = context.declare(myNameCandidate, myFnType, myExpression.getText());
- myFinalExpression = context.createExpression(varName + "." + myMethodName + "(" + String.join(",", newNames) + ")");
+ myFinalExpression = context.createExpression(varName + "." + myMethodName + "(" + String.join(",", argumentValues) + ")");
}
}
@@ -415,13 +481,13 @@ abstract class FunctionHelper {
}
@Override
- void transform(StreamToLoopReplacementContext context, String... newNames) {
- myExpression = context.createExpression(myReference.getText() + "." + myName + "(" + String.join(",", newNames) + ")");
+ void transform(StreamToLoopReplacementContext context, String... argumentValues) {
+ myExpression = context.createExpression(myReference.getText() + "." + myName + "(" + String.join(",", argumentValues) + ")");
}
@Override
void rename(String oldName, String newName, StreamToLoopReplacementContext context) {
- myReference = renameVarReference(myReference, oldName, newName, context);
+ myReference = replaceVarReference(myReference, oldName, newName, context);
}
@Override
@@ -430,11 +496,15 @@ abstract class FunctionHelper {
}
}
- private static class IdentityFunctionHelper extends FunctionHelper {
+ private static class InlinedFunctionHelper extends FunctionHelper {
+ private final int myArgCount;
+ private final String myTemplate;
private PsiExpression myExpression;
- public IdentityFunctionHelper(PsiType type) {
+ public InlinedFunctionHelper(PsiType type, int argCount, String template) {
super(type);
+ myArgCount = argCount;
+ myTemplate = template;
}
@Override
@@ -444,9 +514,9 @@ abstract class FunctionHelper {
}
@Override
- void transform(StreamToLoopReplacementContext context, String... newNames) {
- LOG.assertTrue(newNames.length == 1);
- myExpression = context.createExpression(newNames[0]);
+ void transform(StreamToLoopReplacementContext context, String... argumentValues) {
+ LOG.assertTrue(argumentValues.length == myArgCount);
+ myExpression = context.createExpression(MessageFormat.format(myTemplate, (Object[])argumentValues));
}
}
@@ -470,33 +540,26 @@ abstract class FunctionHelper {
return myBody;
}
- void transform(StreamToLoopReplacementContext context, String... newNames) {
- LOG.assertTrue(newNames.length == myParameters.length);
- EntryStream.zip(myParameters, newNames).forKeyValue(
- (oldName, newName) -> myBody = renameVarReference(myBody, oldName, newName, context));
+ void transform(StreamToLoopReplacementContext context, String... argumentValues) {
+ LOG.assertTrue(argumentValues.length == myParameters.length);
+ EntryStream.zip(myParameters, argumentValues).forKeyValue(
+ (oldName, newName) -> myBody = replaceVarReference(myBody, oldName, newName, context));
}
void rename(String oldName, String newName, StreamToLoopReplacementContext context) {
- OptionalLong idx = StreamEx.of(myParameters).indexOf(newName);
- if(idx.isPresent()) {
+ int idx = ArrayUtil.indexOf(myParameters, newName);
+ if(idx >= 0) {
+ // If new name collides with existing parameter, rename it
for(int i = 1;; i++) {
String paramName = newName+'$'+i;
- if (!paramName.equals(oldName) &&
- !StreamEx.of(myParameters).has(paramName)) {
- try {
- myBody = renameVarReference(myBody, newName, paramName, context);
- myParameters[(int)idx.getAsLong()] = paramName;
- break;
- }
- catch(IllegalStateException ise) {
- // something is really wrong if we already have references to all newName$1, newName$2, ... newName$50
- // or probably IllegalStateException was thrown by something else: at least we don't stuck in endless loop
- if(i > 50) throw ise;
- }
+ if (!paramName.equals(oldName) && !StreamEx.of(myParameters).has(paramName) && !hasVarReference(myBody, paramName, context)) {
+ myBody = replaceVarReference(myBody, newName, paramName, context);
+ myParameters[idx] = paramName;
+ break;
}
}
}
- myBody = renameVarReference(myBody, oldName, newName, context);
+ myBody = replaceVarReference(myBody, oldName, newName, context);
}
@Override
diff --git a/java/java-impl/src/com/intellij/codeInspection/streamToLoop/Operation.java b/java/java-impl/src/com/intellij/codeInspection/streamToLoop/Operation.java
index 9834ab17537d..2c3178014267 100644
--- a/java/java-impl/src/com/intellij/codeInspection/streamToLoop/Operation.java
+++ b/java/java-impl/src/com/intellij/codeInspection/streamToLoop/Operation.java
@@ -264,7 +264,7 @@ abstract class Operation {
@Override
void rename(String oldName, String newName, StreamToLoopReplacementContext context) {
- myExpression = FunctionHelper.renameVarReference(myExpression, oldName, newName, context);
+ myExpression = FunctionHelper.replaceVarReference(myExpression, oldName, newName, context);
}
@Override
@@ -288,7 +288,7 @@ abstract class Operation {
@Override
void rename(String oldName, String newName, StreamToLoopReplacementContext context) {
- myLimit = FunctionHelper.renameVarReference(myLimit, oldName, newName, context);
+ myLimit = FunctionHelper.replaceVarReference(myLimit, oldName, newName, context);
}
@Override
diff --git a/java/java-impl/src/com/intellij/codeInspection/streamToLoop/SourceOperation.java b/java/java-impl/src/com/intellij/codeInspection/streamToLoop/SourceOperation.java
index 6a14a01128dc..8e9b93a4c982 100644
--- a/java/java-impl/src/com/intellij/codeInspection/streamToLoop/SourceOperation.java
+++ b/java/java-impl/src/com/intellij/codeInspection/streamToLoop/SourceOperation.java
@@ -30,7 +30,7 @@ import java.util.Arrays;
import java.util.function.Consumer;
import static com.intellij.codeInspection.streamToLoop.FunctionHelper.processUsedNames;
-import static com.intellij.codeInspection.streamToLoop.FunctionHelper.renameVarReference;
+import static com.intellij.codeInspection.streamToLoop.FunctionHelper.replaceVarReference;
/**
* @author Tagir Valeev
@@ -109,7 +109,7 @@ abstract class SourceOperation extends Operation {
@Override
void rename(String oldName, String newName, StreamToLoopReplacementContext context) {
- myQualifier = renameVarReference(myQualifier, oldName, newName, context);
+ myQualifier = replaceVarReference(myQualifier, oldName, newName, context);
}
@Override
@@ -146,7 +146,7 @@ abstract class SourceOperation extends Operation {
@Override
void rename(String oldName, String newName, StreamToLoopReplacementContext context) {
- Arrays.asList(myArgList).replaceAll(arg -> renameVarReference(arg, oldName, newName, context));
+ Arrays.asList(myArgList).replaceAll(arg -> replaceVarReference(arg, oldName, newName, context));
}
@Override
@@ -189,7 +189,7 @@ abstract class SourceOperation extends Operation {
void rename(String oldName, String newName, StreamToLoopReplacementContext context) {
myFn.rename(oldName, newName, context);
if(myLimit != null) {
- myLimit = renameVarReference(myLimit, oldName, newName, context);
+ myLimit = replaceVarReference(myLimit, oldName, newName, context);
}
}
@@ -227,7 +227,7 @@ abstract class SourceOperation extends Operation {
@Override
void rename(String oldName, String newName, StreamToLoopReplacementContext context) {
- myInitializer = renameVarReference(myInitializer, oldName, newName, context);
+ myInitializer = replaceVarReference(myInitializer, oldName, newName, context);
myFn.rename(oldName, newName, context);
}
@@ -264,8 +264,8 @@ abstract class SourceOperation extends Operation {
@Override
void rename(String oldName, String newName, StreamToLoopReplacementContext context) {
- myOrigin = renameVarReference(myOrigin, oldName, newName, context);
- myBound = renameVarReference(myBound, oldName, newName, context);
+ myOrigin = replaceVarReference(myOrigin, oldName, newName, context);
+ myBound = replaceVarReference(myBound, oldName, newName, context);
}
@Override
diff --git a/java/java-impl/src/com/intellij/codeInspection/streamToLoop/TerminalOperation.java b/java/java-impl/src/com/intellij/codeInspection/streamToLoop/TerminalOperation.java
index d51864f0b85f..09bce16d8bbe 100644
--- a/java/java-impl/src/com/intellij/codeInspection/streamToLoop/TerminalOperation.java
+++ b/java/java-impl/src/com/intellij/codeInspection/streamToLoop/TerminalOperation.java
@@ -17,18 +17,20 @@ package com.intellij.codeInspection.streamToLoop;
import com.intellij.codeInspection.streamToLoop.StreamToLoopInspection.StreamToLoopReplacementContext;
import com.intellij.codeInspection.util.OptionalUtil;
+import com.intellij.openapi.project.Project;
import com.intellij.psi.*;
-import com.intellij.psi.util.InheritanceUtil;
import com.intellij.psi.util.PsiUtil;
import com.intellij.psi.util.TypeConversionUtil;
import com.siyeh.ig.psiutils.BoolUtils;
-import com.siyeh.ig.psiutils.ExpressionUtils;
+import com.siyeh.ig.psiutils.ParenthesesUtils;
import one.util.streamex.StreamEx;
import org.jetbrains.annotations.Contract;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.Arrays;
+import java.util.Collections;
+import java.util.Map;
import java.util.Objects;
import java.util.function.Consumer;
import java.util.function.Function;
@@ -111,20 +113,12 @@ abstract class TerminalOperation extends Operation {
if(args.length == 0) return new ToPrimitiveArrayTerminalOperation(componentType.getCanonicalText());
}
else {
- String arr = "";
+ FunctionHelper fn = null;
if(args.length == 1) {
- if(!(args[0] instanceof PsiMethodReferenceExpression)) return null;
- PsiMethodReferenceExpression arrCtor = (PsiMethodReferenceExpression)args[0];
- if(!arrCtor.isConstructor()) return null;
- PsiTypeElement typeElement = arrCtor.getQualifierType();
- if(typeElement == null) return null;
- PsiType type = typeElement.getType();
- if(!(type instanceof PsiArrayType)) return null;
- arr = "new "+type.getCanonicalText().replaceFirst("\\[]", "[0]");
+ fn = FunctionHelper.create(args[0], 1);
+ if(fn == null) return null;
}
- return new AccumulatedTerminalOperation("list", CommonClassNames.JAVA_UTIL_LIST + "<" + elementType.getCanonicalText() + ">",
- "new "+ CommonClassNames.JAVA_UTIL_ARRAY_LIST+"<>()", "{acc}.add({item});",
- "{acc}.toArray("+arr+")");
+ return new ToArrayTerminalOperation(elementType, fn);
}
}
if ((name.equals("max") || name.equals("min")) && args.length < 2) {
@@ -170,14 +164,15 @@ abstract class TerminalOperation extends Operation {
switch (collectorName) {
case "toList":
if (collectorArgs.length != 0) return null;
- return AccumulatedTerminalOperation.toList(resultType);
+ return ToCollectionTerminalOperation.toList(resultType);
case "toSet":
if (collectorArgs.length != 0) return null;
- return AccumulatedTerminalOperation.toCollection(resultType, CommonClassNames.JAVA_UTIL_HASH_SET, "set");
+ return new ToCollectionTerminalOperation(resultType,
+ FunctionHelper.newObjectSupplier(resultType, CommonClassNames.JAVA_UTIL_HASH_SET), "set");
case "toCollection":
if (collectorArgs.length != 1) return null;
fn = FunctionHelper.create(collectorArgs[0], 0);
- return fn == null ? null : new ToCollectionTerminalOperation(fn);
+ return fn == null ? null : new ToCollectionTerminalOperation(resultType, fn, null);
case "toMap": {
if (collectorArgs.length < 2 || collectorArgs.length > 4) return null;
FunctionHelper key = FunctionHelper.create(collectorArgs[0], 1);
@@ -186,7 +181,7 @@ abstract class TerminalOperation extends Operation {
PsiExpression merger = collectorArgs.length > 2 ? collectorArgs[2] : null;
FunctionHelper supplier = collectorArgs.length == 4
? FunctionHelper.create(collectorArgs[3], 0)
- : FunctionHelper.hashMapSupplier(resultType);
+ : FunctionHelper.newObjectSupplier(resultType, CommonClassNames.JAVA_UTIL_HASH_MAP);
if(supplier == null) return null;
return new ToMapTerminalOperation(key, value, merger, supplier, resultType);
}
@@ -249,7 +244,7 @@ abstract class TerminalOperation extends Operation {
if (resultSubType == null) return null;
CollectorOperation downstreamCollector;
if (collectorArgs.length == 1) {
- downstreamCollector = AccumulatedTerminalOperation.toList(resultSubType).asCollector();
+ downstreamCollector = ToCollectionTerminalOperation.toList(resultSubType).asCollector();
}
else {
PsiExpression downstream = collectorArgs[collectorArgs.length - 1];
@@ -263,7 +258,7 @@ abstract class TerminalOperation extends Operation {
}
FunctionHelper supplier = collectorArgs.length == 3
? FunctionHelper.create(collectorArgs[1], 0)
- : FunctionHelper.hashMapSupplier(resultType);
+ : FunctionHelper.newObjectSupplier(resultType, CommonClassNames.JAVA_UTIL_HASH_MAP);
return new GroupByTerminalOperation(fn, supplier, resultType, downstreamCollector);
}
case "minBy":
@@ -289,6 +284,42 @@ abstract class TerminalOperation extends Operation {
return null;
}
+ /**
+ * Eliminates <? extends> wildcards from type parameters which directly map to the supplied superclass
+ * type parameters and performs downstream correction steps if necessary.
+ *
+ * @param type type to process
+ * @param superClass superclass which type parameters should be corrected
+ * @param downstreamCorrectors Map which keys are superclass type parameter names and values are functions to perform additional
+ * superclass type parameter correction if necessary
+ * @return the corrected type.
+ */
+ @NotNull
+ static PsiType correctTypeParameters(PsiType type, String superClass, Map> downstreamCorrectors) {
+ PsiClass aClass = PsiUtil.resolveClassInClassTypeOnly(type);
+ if(aClass == null) return type;
+
+ PsiSubstitutor origSubstitutor = ((PsiClassType)type).resolveGenerics().getSubstitutor();
+ PsiSubstitutor substitutor = origSubstitutor;
+ Project project = aClass.getProject();
+ PsiClass baseClass = JavaPsiFacade.getInstance(project).findClass(superClass, aClass.getResolveScope());
+ if(baseClass == null) return type;
+ PsiSubstitutor superClassSubstitutor = TypeConversionUtil.getSuperClassSubstitutor(baseClass, aClass, PsiSubstitutor.EMPTY);
+ for (PsiTypeParameter baseParameter : baseClass.getTypeParameters()) {
+ PsiClass substitution = PsiUtil.resolveClassInClassTypeOnly(superClassSubstitutor.substitute(baseParameter));
+ if(substitution instanceof PsiTypeParameter) {
+ PsiTypeParameter subClassParameter = (PsiTypeParameter)substitution;
+ PsiType origType = origSubstitutor.substitute(subClassParameter);
+ PsiType replacedType = GenericsUtil.eliminateWildcards(origType, false, true);
+ replacedType = downstreamCorrectors.getOrDefault(subClassParameter.getName(), Function.identity()).apply(replacedType);
+ if(replacedType != origType) {
+ substitutor = substitutor.put(subClassParameter, replacedType);
+ }
+ }
+ }
+ return substitutor == origSubstitutor ? type : JavaPsiFacade.getElementFactory(project).createType(aClass, substitutor);
+ }
+
static class ReduceTerminalOperation extends TerminalOperation {
private PsiExpression myIdentity;
private String myType;
@@ -425,6 +456,29 @@ abstract class TerminalOperation extends Operation {
}
}
+ static class ToArrayTerminalOperation extends TerminalOperation {
+ private final String myType;
+ private final FunctionHelper mySupplier;
+
+ public ToArrayTerminalOperation(PsiType type, FunctionHelper supplier) {
+ myType = type.getCanonicalText();
+ mySupplier = supplier;
+ }
+
+ @Override
+ String generate(StreamVariable inVar, StreamToLoopReplacementContext context) {
+ String list = context.declareResult("list", CommonClassNames.JAVA_UTIL_LIST + "<" + myType + ">",
+ "new " + CommonClassNames.JAVA_UTIL_ARRAY_LIST + "<>()", false);
+ String toArrayArg = "";
+ if(mySupplier != null) {
+ mySupplier.transform(context, "0");
+ toArrayArg = mySupplier.getText();
+ }
+ context.setFinisher(list + ".toArray(" + toArrayArg + ")");
+ return list+".add("+inVar+");\n";
+ }
+ }
+
static class FindTerminalOperation extends TerminalOperation {
private String myType;
@@ -496,6 +550,8 @@ abstract class TerminalOperation extends Operation {
default void registerUsedNames(Consumer usedNameConsumer) {}
String getSupplier();
String getAccumulator(String acc, String item);
+
+ default PsiType correctReturnType(PsiType type) {return type;}
}
abstract static class CollectorBasedTerminalOperation extends TerminalOperation implements CollectorOperation {
@@ -513,7 +569,8 @@ abstract class TerminalOperation extends Operation {
@Override
String generate(StreamVariable inVar, StreamToLoopReplacementContext context) {
transform(context, inVar.getName());
- String acc = context.declareResult(myAccNameSupplier.apply(context), myType, getSupplier(), true);
+ PsiType resultType = correctReturnType(context.createType(myType));
+ String acc = context.declareResult(myAccNameSupplier.apply(context), resultType.getCanonicalText(), getSupplier(), true);
return getAccumulator(acc, inVar.getName());
}
@@ -588,17 +645,6 @@ abstract class TerminalOperation extends Operation {
return myUpdateTemplate.replace("{acc}", acc).replace("{item}", item);
}
- @NotNull
- static AccumulatedTerminalOperation toCollection(PsiType collectionType, String implementationType, String varName) {
- return new AccumulatedTerminalOperation(varName, collectionType.getCanonicalText(), "new " + implementationType + "<>()",
- "{acc}.add({item});");
- }
-
- @NotNull
- private static AccumulatedTerminalOperation toList(@NotNull PsiType resultType) {
- return toCollection(resultType, CommonClassNames.JAVA_UTIL_ARRAY_LIST, "list");
- }
-
@NotNull
static AccumulatedTerminalOperation summing(PsiType type) {
return new AccumulatedTerminalOperation("sum", type.getCanonicalText(), "0", "{acc}+={item};");
@@ -612,57 +658,63 @@ abstract class TerminalOperation extends Operation {
}
static class ToCollectionTerminalOperation extends CollectorBasedTerminalOperation {
- public ToCollectionTerminalOperation(FunctionHelper fn) {
- super(fn.getResultType(), context -> fn.suggestFinalOutputNames(context, null, "collection").get(0), fn);
+ public ToCollectionTerminalOperation(PsiType resultType, FunctionHelper fn, String desiredName) {
+ super(resultType.getCanonicalText(), context -> fn.suggestFinalOutputNames(context, desiredName, "collection").get(0), fn);
}
@Override
public String getAccumulator(String acc, String item) {
return acc+".add("+item+");\n";
}
+
+ @Override
+ public PsiType correctReturnType(PsiType type) {
+ return correctTypeParameters(type, CommonClassNames.JAVA_UTIL_COLLECTION, Collections.emptyMap());
+ }
+
+ @NotNull
+ private static ToCollectionTerminalOperation toList(@NotNull PsiType resultType) {
+ return new ToCollectionTerminalOperation(resultType, FunctionHelper.newObjectSupplier(resultType, CommonClassNames.JAVA_UTIL_ARRAY_LIST), "list");
+ }
}
static class MinMaxTerminalOperation extends TerminalOperation {
private String myType;
private String myTemplate;
private String myComparatorType;
- private @Nullable PsiExpression myComparator;
+ private @Nullable FunctionHelper myComparator;
- public MinMaxTerminalOperation(String type, String template, @Nullable PsiExpression comparator) {
+ public MinMaxTerminalOperation(String type, String template, @Nullable FunctionHelper comparator) {
myType = type;
myTemplate = template;
myComparator = comparator;
if(comparator != null) {
- PsiType comparatorType = comparator.getType();
- if(comparatorType != null) {
- myComparatorType = comparatorType.getCanonicalText();
- } else {
- myComparatorType = CommonClassNames.JAVA_UTIL_COMPARATOR+"<"+myType+">";
- }
+ myComparatorType = CommonClassNames.JAVA_UTIL_COMPARATOR+"<"+myType+">";
}
}
@Override
public void registerUsedNames(Consumer usedNameConsumer) {
if(myComparator != null) {
- FunctionHelper.processUsedNames(myComparator, usedNameConsumer);
+ myComparator.registerUsedNames(usedNameConsumer);
}
}
@Override
String generate(StreamVariable inVar, StreamToLoopReplacementContext context) {
- String comparator = "";
- if(myComparator != null) {
- comparator = myComparator.getText();
- if(!ExpressionUtils.isSimpleExpression(context.createExpression(comparator))) {
- comparator = context.declare("comparator", myComparatorType, comparator);
- }
- }
String seen = context.declare("seen", "boolean", "false");
String best = context.declareResult("best", myType, TypeConversionUtil.isPrimitive(myType) ? "0" : "null", false);
- String type = myType;
- context.setFinisher(new ConditionalExpression.Optional(type, seen, best));
- String comparePredicate = myTemplate.replace("{best}", best).replace("{item}", inVar.getName()).replace("{comparator}", comparator);
+ context.setFinisher(new ConditionalExpression.Optional(myType, seen, best));
+ String comparePredicate;
+ if(myComparator != null) {
+ myComparator.transform(context, inVar.getName(), best);
+ PsiExpression expression = myComparator.getExpression();
+ int expressionPrecedence = ParenthesesUtils.getPrecedence(expression);
+ String text = expressionPrecedence >= ParenthesesUtils.EQUALITY_PRECEDENCE ? "("+expression.getText()+")" : expression.getText();
+ comparePredicate = myTemplate.replace("{comparator}", text);
+ } else {
+ comparePredicate = myTemplate.replace("{best}", best).replace("{item}", inVar.getName());
+ }
return "if(!" + seen + " || " + comparePredicate + ") {\n" +
seen + "=true;\n" +
best + "=" + inVar + ";\n}\n";
@@ -678,8 +730,12 @@ abstract class TerminalOperation extends Operation {
if (PsiType.DOUBLE.equalsToText(elementType)) {
return new MinMaxTerminalOperation(elementType, "java.lang.Double.compare({item},{best})" + sign + "0", null);
}
- } else if(InheritanceUtil.isInheritor(comparator.getType(), CommonClassNames.JAVA_UTIL_COMPARATOR)) {
- return new MinMaxTerminalOperation(elementType, "{comparator}.compare({item},{best})" + sign + "0", comparator);
+ }
+ else {
+ FunctionHelper fn = FunctionHelper.create(comparator, 2);
+ if(fn != null) {
+ return new MinMaxTerminalOperation(elementType, "{comparator}"+sign+"0", fn);
+ }
}
return null;
}
@@ -700,6 +756,11 @@ abstract class TerminalOperation extends Operation {
myMerger = merger;
}
+ @Override
+ public PsiType correctReturnType(PsiType type) {
+ return correctTypeParameters(type, CommonClassNames.JAVA_UTIL_MAP, Collections.emptyMap());
+ }
+
@Override
public void registerUsedNames(Consumer usedNameConsumer) {
super.registerUsedNames(usedNameConsumer);
@@ -763,6 +824,11 @@ abstract class TerminalOperation extends Operation {
myCollector = collector;
}
+ @Override
+ public PsiType correctReturnType(PsiType type) {
+ return correctTypeParameters(type, CommonClassNames.JAVA_UTIL_MAP, Collections.singletonMap("V", myCollector::correctReturnType));
+ }
+
@Override
public void registerUsedNames(Consumer usedNameConsumer) {
super.registerUsedNames(usedNameConsumer);
@@ -816,11 +882,14 @@ abstract class TerminalOperation extends Operation {
@Override
String generate(StreamVariable inVar, StreamToLoopReplacementContext context) {
- String map = context.declareResult("map", myResultType, "new java.util.HashMap<>()", true);
+ PsiType resultType = context.createType(myResultType);
+ resultType = correctTypeParameters(resultType, CommonClassNames.JAVA_UTIL_MAP,
+ Collections.singletonMap("V", myCollector::correctReturnType));
+ String map = context.declareResult("map", resultType.getCanonicalText(), "new java.util.HashMap<>()", true);
myPredicate.transform(context, inVar.getName());
myCollector.transform(context, inVar.getName());
- context.addInitStep(map+".put(false, "+myCollector.getSupplier()+");");
- context.addInitStep(map+".put(true, "+myCollector.getSupplier()+");");
+ context.addInitStep(map + ".put(false, " + myCollector.getSupplier() + ");");
+ context.addInitStep(map + ".put(true, " + myCollector.getSupplier() + ");");
return myCollector.getAccumulator(map + ".get(" + myPredicate.getText() + ")", inVar.getName());
}
}
@@ -847,6 +916,11 @@ abstract class TerminalOperation extends Operation {
myMapper.suggestVariableName(inVar, 0);
}
+ @Override
+ public PsiType correctReturnType(PsiType type) {
+ return myDownstreamCollector.correctReturnType(type);
+ }
+
@Override
CollectorOperation asCollector() {
return myDownstreamCollector == null ? null : this;
diff --git a/java/java-impl/src/com/intellij/ide/actions/CreateClassAction.java b/java/java-impl/src/com/intellij/ide/actions/CreateClassAction.java
index 7100e2d7505b..6e998df1000f 100644
--- a/java/java-impl/src/com/intellij/ide/actions/CreateClassAction.java
+++ b/java/java-impl/src/com/intellij/ide/actions/CreateClassAction.java
@@ -100,6 +100,11 @@ public class CreateClassAction extends JavaCreateTemplateInPackageAction getLiveTemplateDefaults(@NotNull DataContext ctx) {
Module module = LangDataKeys.MODULE.getData(ctx);
- return Collections.singletonMap("MODULE_NAME", module != null ? module.getName() : "module_name");
+ return Collections.singletonMap("MODULE_NAME", module != null ? StringUtil.sanitizeJavaIdentifier(module.getName()) : "module_name");
}
}
\ No newline at end of file
diff --git a/java/java-impl/src/com/intellij/ide/util/PackageUtil.java b/java/java-impl/src/com/intellij/ide/util/PackageUtil.java
index e1582d6d2b4f..e48ef65df984 100644
--- a/java/java-impl/src/com/intellij/ide/util/PackageUtil.java
+++ b/java/java-impl/src/com/intellij/ide/util/PackageUtil.java
@@ -16,6 +16,7 @@
package com.intellij.ide.util;
import com.intellij.ide.IdeBundle;
+import com.intellij.ide.actions.CreateFileAction;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.command.CommandProcessor;
import com.intellij.openapi.diagnostic.Logger;
@@ -393,10 +394,6 @@ public class PackageUtil {
@NotNull
public static PsiDirectory findOrCreateSubdirectory(@NotNull PsiDirectory directory, @NotNull String directoryName) {
- PsiDirectory subDirectory = directory.findSubdirectory(directoryName);
- if (subDirectory == null) {
- subDirectory = directory.createSubdirectory(directoryName);
- }
- return subDirectory;
+ return CreateFileAction.findOrCreateSubdirectory(directory, directoryName);
}
}
diff --git a/java/java-impl/src/com/intellij/openapi/vcs/contentAnnotation/VcsContentAnnotationExceptionFilter.java b/java/java-impl/src/com/intellij/openapi/vcs/contentAnnotation/VcsContentAnnotationExceptionFilter.java
index bf0f4cd68254..aaf5e99ee85f 100644
--- a/java/java-impl/src/com/intellij/openapi/vcs/contentAnnotation/VcsContentAnnotationExceptionFilter.java
+++ b/java/java-impl/src/com/intellij/openapi/vcs/contentAnnotation/VcsContentAnnotationExceptionFilter.java
@@ -106,12 +106,8 @@ public class VcsContentAnnotationExceptionFilter implements Filter, FilterMixin
final int lineStartOffset = copiedFragment.getLineStartOffset(i);
final int lineEndOffset = copiedFragment.getLineEndOffset(i);
final ExceptionWorker worker = new ExceptionWorker(myCache);
- final String[] lineText = new String[1];
- ApplicationManager.getApplication().runReadAction(() -> {
- lineText[0] = copiedFragment.getText(new TextRange(lineStartOffset, lineEndOffset));
- worker.execute(lineText[0], lineEndOffset);
- });
- if (worker.getResult() != null) {
+ final String lineText = copiedFragment.getText(new TextRange(lineStartOffset, lineEndOffset));
+ if (ApplicationManager.getApplication().runReadAction((Computable)() -> worker.execute(lineText, lineEndOffset)) != null) {
VirtualFile vf = worker.getFile().getVirtualFile();
if (vf.getFileSystem().isReadOnly()) continue;
@@ -133,7 +129,7 @@ public class VcsContentAnnotationExceptionFilter implements Filter, FilterMixin
if (document == null) return;
int startFileOffset = worker.getInfo().getThird().getStartOffset();
- int idx = lineText[0].indexOf(':', startFileOffset);
+ int idx = lineText.indexOf(':', startFileOffset);
int endIdx = idx == -1 ? worker.getInfo().getThird().getEndOffset() : idx;
consumer.consume(new MyAdditionalHighlight(startOffset + lineStartOffset + startFileOffset + 1, startOffset + lineStartOffset + endIdx));
diff --git a/java/java-impl/src/com/intellij/psi/impl/file/JavaDirectoryServiceImpl.java b/java/java-impl/src/com/intellij/psi/impl/file/JavaDirectoryServiceImpl.java
index 19f5fd5aee05..935758413f6c 100644
--- a/java/java-impl/src/com/intellij/psi/impl/file/JavaDirectoryServiceImpl.java
+++ b/java/java-impl/src/com/intellij/psi/impl/file/JavaDirectoryServiceImpl.java
@@ -25,6 +25,7 @@ import com.intellij.ide.fileTemplates.FileTemplateManager;
import com.intellij.ide.fileTemplates.FileTemplateUtil;
import com.intellij.ide.fileTemplates.JavaTemplateUtil;
import com.intellij.ide.fileTemplates.ui.CreateFromTemplateDialog;
+import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.fileTypes.StdFileTypes;
import com.intellij.openapi.project.Project;
@@ -123,6 +124,9 @@ public class JavaDirectoryServiceImpl extends CoreJavaDirectoryService {
String name,
String templateName,
boolean askToDefineVariables, @NotNull Map additionalProperties) throws IncorrectOperationException {
+ if (askToDefineVariables) {
+ LOG.assertTrue(!ApplicationManager.getApplication().isWriteAccessAllowed());
+ }
//checkCreateClassOrInterface(dir, name);
Project project = dir.getProject();
diff --git a/java/java-impl/src/com/intellij/refactoring/encapsulateFields/EncapsulateFieldsProcessor.java b/java/java-impl/src/com/intellij/refactoring/encapsulateFields/EncapsulateFieldsProcessor.java
index a1d4f7323455..1804d5f2f9cd 100644
--- a/java/java-impl/src/com/intellij/refactoring/encapsulateFields/EncapsulateFieldsProcessor.java
+++ b/java/java-impl/src/com/intellij/refactoring/encapsulateFields/EncapsulateFieldsProcessor.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2000-2015 JetBrains s.r.o.
+ * Copyright 2000-2016 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -173,7 +173,7 @@ public class EncapsulateFieldsProcessor extends BaseRefactoringProcessor {
PsiElement element = info.getElement();
if (element != null) {
PsiElement parent = element.getParent();
- if (RefactoringUtil.isPlusPlusOrMinusMinus(parent) && !(parent.getParent() instanceof PsiExpressionStatement)) {
+ if (PsiUtil.isIncrementDecrementOperation(parent) && !(parent.getParent() instanceof PsiExpressionStatement)) {
conflicts.putValue(parent, "Unable to proceed with postfix/prefix expression when it's result type is used");
}
}
diff --git a/java/java-impl/src/com/intellij/refactoring/encapsulateFields/JavaEncapsulateFieldHelper.java b/java/java-impl/src/com/intellij/refactoring/encapsulateFields/JavaEncapsulateFieldHelper.java
index 25c9c0ea1278..06aa52cab4b2 100644
--- a/java/java-impl/src/com/intellij/refactoring/encapsulateFields/JavaEncapsulateFieldHelper.java
+++ b/java/java-impl/src/com/intellij/refactoring/encapsulateFields/JavaEncapsulateFieldHelper.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2000-2013 JetBrains s.r.o.
+ * Copyright 2000-2016 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -17,13 +17,10 @@ package com.intellij.refactoring.encapsulateFields;
import com.intellij.codeInsight.generation.GenerateMembersUtil;
import com.intellij.openapi.diagnostic.Logger;
-import com.intellij.openapi.util.Condition;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.psi.*;
import com.intellij.psi.tree.IElementType;
-import com.intellij.psi.util.PropertyUtil;
import com.intellij.psi.util.PsiUtil;
-import com.intellij.refactoring.util.RefactoringUtil;
import com.intellij.util.IncorrectOperationException;
import com.intellij.util.VisibilityUtil;
import com.intellij.util.containers.ContainerUtil;
@@ -180,7 +177,7 @@ public class JavaEncapsulateFieldHelper extends EncapsulateFieldHelper {
}
}
}
- else if (RefactoringUtil.isPlusPlusOrMinusMinus(parent)){
+ else if (PsiUtil.isIncrementDecrementOperation(parent)){
IElementType sign;
if (parent instanceof PsiPrefixExpression){
sign = ((PsiPrefixExpression)parent).getOperationTokenType();
diff --git a/java/java-impl/src/com/intellij/refactoring/extractMethod/ExtractMethodProcessor.java b/java/java-impl/src/com/intellij/refactoring/extractMethod/ExtractMethodProcessor.java
index a82b31f8615c..3bea44ff6101 100644
--- a/java/java-impl/src/com/intellij/refactoring/extractMethod/ExtractMethodProcessor.java
+++ b/java/java-impl/src/com/intellij/refactoring/extractMethod/ExtractMethodProcessor.java
@@ -1169,7 +1169,7 @@ public class ExtractMethodProcessor implements MatchProvider {
}
});
}
- else {
+ else if (!PsiUtil.isLanguageLevel8OrHigher(method)){
method.accept(new JavaRecursiveElementVisitor() {
@Override public void visitReferenceExpression(PsiReferenceExpression expression) {
final PsiElement resolved = expression.resolve();
diff --git a/java/java-impl/src/com/intellij/refactoring/extractMethodObject/ExtractLightMethodObjectHandler.java b/java/java-impl/src/com/intellij/refactoring/extractMethodObject/ExtractLightMethodObjectHandler.java
index c9ca2c95695f..712b9921e0dd 100644
--- a/java/java-impl/src/com/intellij/refactoring/extractMethodObject/ExtractLightMethodObjectHandler.java
+++ b/java/java-impl/src/com/intellij/refactoring/extractMethodObject/ExtractLightMethodObjectHandler.java
@@ -108,7 +108,7 @@ public class ExtractLightMethodObjectHandler {
}
}
- final PsiClass containingClass = PsiTreeUtil.getParentOfType(originalAnchor, PsiClass.class);
+ final PsiClass containingClass = PsiTreeUtil.getParentOfType(originalAnchor, PsiClass.class, false);
if (containingClass == null) {
return null;
}
diff --git a/java/java-impl/src/com/intellij/refactoring/extractclass/ExtractClassProcessor.java b/java/java-impl/src/com/intellij/refactoring/extractclass/ExtractClassProcessor.java
index c3570eec6605..3221ef5a5a8b 100644
--- a/java/java-impl/src/com/intellij/refactoring/extractclass/ExtractClassProcessor.java
+++ b/java/java-impl/src/com/intellij/refactoring/extractclass/ExtractClassProcessor.java
@@ -25,7 +25,6 @@ import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.module.Module;
import com.intellij.openapi.module.ModuleUtil;
import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.Condition;
import com.intellij.openapi.util.Ref;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.psi.*;
@@ -40,6 +39,7 @@ import com.intellij.psi.tree.IElementType;
import com.intellij.psi.util.InheritanceUtil;
import com.intellij.psi.util.PropertyUtil;
import com.intellij.psi.util.PsiTreeUtil;
+import com.intellij.psi.util.PsiUtil;
import com.intellij.refactoring.MoveDestination;
import com.intellij.refactoring.RefactorJBundle;
import com.intellij.refactoring.extractclass.usageInfo.*;
@@ -630,7 +630,7 @@ public class ExtractClassProcessor extends FixableUsagesRefactoringProcessor {
if (element instanceof PsiReferenceExpression) {
final PsiReferenceExpression exp = (PsiReferenceExpression)element;
- if (RefactoringUtil.isPlusPlusOrMinusMinus(exp.getParent())) {
+ if (PsiUtil.isIncrementDecrementOperation(exp.getParent())) {
usages.add(isStatic
? new ReplaceStaticVariableIncrementDecrement(exp, qualifiedName)
: new ReplaceInstanceVariableIncrementDecrement(exp, delegateFieldName, setter, getter, field.getName()));
diff --git a/java/java-impl/src/com/intellij/refactoring/inline/InlineLocalHandler.java b/java/java-impl/src/com/intellij/refactoring/inline/InlineLocalHandler.java
index b045fda2888b..d48e13b43989 100644
--- a/java/java-impl/src/com/intellij/refactoring/inline/InlineLocalHandler.java
+++ b/java/java-impl/src/com/intellij/refactoring/inline/InlineLocalHandler.java
@@ -36,7 +36,6 @@ import com.intellij.openapi.wm.WindowManager;
import com.intellij.psi.*;
import com.intellij.psi.controlFlow.DefUseUtil;
import com.intellij.psi.search.searches.ReferencesSearch;
-import com.intellij.psi.tree.IElementType;
import com.intellij.psi.util.PsiTreeUtil;
import com.intellij.psi.util.PsiUtil;
import com.intellij.psi.util.PsiUtilCore;
@@ -46,6 +45,7 @@ import com.intellij.refactoring.listeners.RefactoringEventData;
import com.intellij.refactoring.listeners.RefactoringEventListener;
import com.intellij.refactoring.util.CommonRefactoringUtil;
import com.intellij.refactoring.util.InlineUtil;
+import com.intellij.refactoring.util.RefactoringUtil;
import com.intellij.util.ArrayUtil;
import com.intellij.util.Query;
import com.intellij.util.containers.ContainerUtil;
@@ -295,29 +295,15 @@ public class InlineLocalHandler extends JavaInlineActionHandler {
if (((PsiArrayAccessExpression)parent).getIndexExpression() == element) continue;
if (defToInline instanceof PsiExpression && !(defToInline instanceof PsiNewExpression)) continue;
element = parent;
- parent = parent.getParent();
}
- if (parent instanceof PsiAssignmentExpression && element == ((PsiAssignmentExpression)parent).getLExpression()
- || isUnaryWriteExpression(parent)) {
-
+ if (RefactoringUtil.isAssignmentLHS(element)) {
return element;
}
}
return null;
}
- private static boolean isUnaryWriteExpression(PsiElement parent) {
- IElementType tokenType = null;
- if (parent instanceof PsiPrefixExpression) {
- tokenType = ((PsiPrefixExpression)parent).getOperationTokenType();
- }
- if (parent instanceof PsiPostfixExpression) {
- tokenType = ((PsiPostfixExpression)parent).getOperationTokenType();
- }
- return tokenType == JavaTokenType.PLUSPLUS || tokenType == JavaTokenType.MINUSMINUS;
- }
-
private static boolean isSameDefinition(final PsiElement def, final PsiExpression defToInline) {
if (def instanceof PsiLocalVariable) return defToInline.equals(((PsiLocalVariable)def).getInitializer());
final PsiElement parent = def.getParent();
diff --git a/java/java-impl/src/com/intellij/refactoring/move/moveClassesOrPackages/JavaMoveDirectoryWithClassesHelper.java b/java/java-impl/src/com/intellij/refactoring/move/moveClassesOrPackages/JavaMoveDirectoryWithClassesHelper.java
index 2583d27f7db5..fcf6f86204ae 100644
--- a/java/java-impl/src/com/intellij/refactoring/move/moveClassesOrPackages/JavaMoveDirectoryWithClassesHelper.java
+++ b/java/java-impl/src/com/intellij/refactoring/move/moveClassesOrPackages/JavaMoveDirectoryWithClassesHelper.java
@@ -5,13 +5,13 @@ import com.intellij.openapi.project.Project;
import com.intellij.psi.*;
import com.intellij.psi.search.GlobalSearchScope;
import com.intellij.psi.search.searches.ReferencesSearch;
+import com.intellij.psi.util.FileTypeUtils;
import com.intellij.psi.util.PsiTreeUtil;
import com.intellij.refactoring.listeners.RefactoringElementListener;
import com.intellij.refactoring.util.RefactoringConflictsUtil;
import com.intellij.usageView.UsageInfo;
import com.intellij.util.Function;
import com.intellij.util.containers.MultiMap;
-import com.intellij.psi.util.FileTypeUtils;
import java.util.*;
@@ -51,7 +51,7 @@ public class JavaMoveDirectoryWithClassesHelper extends MoveDirectoryWithClasses
for (PsiReference reference : ReferencesSearch.search(aPackage, GlobalSearchScope.projectScope(project))) {
final PsiElement element = reference.getElement();
final PsiImportStatementBase statementBase = PsiTreeUtil.getParentOfType(element, PsiImportStatementBase.class);
- if (statementBase != null && statementBase.isOnDemand()) {
+ if (statementBase != null && statementBase.isOnDemand() && !isUnderRefactoring(statementBase, directoriesToMove)) {
usages.add(new RemoveOnDemandImportStatementsUsageInfo(statementBase));
}
}
@@ -60,9 +60,9 @@ public class JavaMoveDirectoryWithClassesHelper extends MoveDirectoryWithClasses
}
}
- private static boolean isUnderRefactoring(PsiDirectory packageDirectory, PsiDirectory[] directoriesToMove) {
+ private static boolean isUnderRefactoring(PsiElement psiElement, PsiDirectory[] directoriesToMove) {
for (PsiDirectory directory : directoriesToMove) {
- if (PsiTreeUtil.isAncestor(directory, packageDirectory, true)) {
+ if (PsiTreeUtil.isAncestor(directory, psiElement, true)) {
return true;
}
}
diff --git a/java/java-impl/src/com/intellij/refactoring/util/LambdaRefactoringUtil.java b/java/java-impl/src/com/intellij/refactoring/util/LambdaRefactoringUtil.java
index 1721264cff2a..98f43b8be70b 100644
--- a/java/java-impl/src/com/intellij/refactoring/util/LambdaRefactoringUtil.java
+++ b/java/java-impl/src/com/intellij/refactoring/util/LambdaRefactoringUtil.java
@@ -28,7 +28,6 @@ import com.intellij.psi.codeStyle.VariableKind;
import com.intellij.psi.util.MethodSignature;
import com.intellij.psi.util.PsiTreeUtil;
import com.intellij.psi.util.PsiUtil;
-import com.intellij.psi.util.RedundantCastUtil;
import com.intellij.refactoring.introduceField.ElementToWorkOn;
import com.intellij.refactoring.introduceVariable.IntroduceVariableHandler;
import com.intellij.util.Function;
@@ -77,8 +76,7 @@ public class LambdaRefactoringUtil {
}
final PsiParameter[] psiParameters = resolve instanceof PsiMethod ? ((PsiMethod)resolve).getParameterList().getParameters() : null;
- final StringBuilder buf = new StringBuilder("(");
- buf.append(GenericsUtil.getVariableTypeByExpressionType(functionalInterfaceType).getCanonicalText()).append(")");
+ final StringBuilder buf = new StringBuilder();
final PsiParameterList parameterList = interfaceMethod.getParameterList();
final PsiParameter[] parameters = parameterList.getParameters();
@@ -224,14 +222,17 @@ public class LambdaRefactoringUtil {
}
+ PsiLambdaExpression lambdaExpression = (PsiLambdaExpression)referenceExpression.replace(elementFactory.createExpressionFromText(buf.toString(), referenceExpression));
+ /*
final PsiTypeCastExpression typeCastExpression = (PsiTypeCastExpression)referenceExpression.replace(elementFactory.createExpressionFromText(buf.toString(), referenceExpression));
- PsiLambdaExpression lambdaExpression = (PsiLambdaExpression)typeCastExpression.getOperand();
+
LOG.assertTrue(lambdaExpression != null, buf.toString());
if (RedundantCastUtil.isCastRedundant(typeCastExpression) || ignoreCast) {
final PsiExpression operand = typeCastExpression.getOperand();
LOG.assertTrue(operand != null);
lambdaExpression = (PsiLambdaExpression)typeCastExpression.replace(operand);
}
+ */
if (simplifyToExpressionLambda) {
simplifyToExpressionLambda(lambdaExpression);
diff --git a/java/java-impl/src/com/intellij/refactoring/util/RefactoringUtil.java b/java/java-impl/src/com/intellij/refactoring/util/RefactoringUtil.java
index e8bc507d2375..34cc63ce8ceb 100644
--- a/java/java-impl/src/com/intellij/refactoring/util/RefactoringUtil.java
+++ b/java/java-impl/src/com/intellij/refactoring/util/RefactoringUtil.java
@@ -44,7 +44,6 @@ import com.intellij.psi.javadoc.PsiDocTagValue;
import com.intellij.psi.search.LocalSearchScope;
import com.intellij.psi.search.SearchScope;
import com.intellij.psi.search.searches.ReferencesSearch;
-import com.intellij.psi.tree.IElementType;
import com.intellij.psi.util.*;
import com.intellij.refactoring.PackageWrapper;
import com.intellij.refactoring.introduceField.ElementToWorkOn;
@@ -421,25 +420,8 @@ public class RefactoringUtil {
return type;
}
- public static boolean isAssignmentLHS(PsiElement element) {
- PsiElement parent = element.getParent();
-
- return parent instanceof PsiAssignmentExpression && element.equals(((PsiAssignmentExpression)parent).getLExpression()) ||
- isPlusPlusOrMinusMinus(parent);
- }
-
- public static boolean isPlusPlusOrMinusMinus(PsiElement element) {
- if (element instanceof PsiPrefixExpression) {
- return ((PsiPrefixExpression)element).getOperationTokenType() == JavaTokenType.PLUSPLUS ||
- ((PsiPrefixExpression)element).getOperationTokenType() == JavaTokenType.MINUSMINUS;
- }
- else if (element instanceof PsiPostfixExpression) {
- IElementType operandTokenType = ((PsiPostfixExpression)element).getOperationTokenType();
- return operandTokenType == JavaTokenType.PLUSPLUS || operandTokenType == JavaTokenType.MINUSMINUS;
- }
- else {
- return false;
- }
+ public static boolean isAssignmentLHS(@NotNull PsiElement element) {
+ return element instanceof PsiExpression && PsiUtil.isAccessedForWriting((PsiExpression)element);
}
private static void removeFinalParameters(PsiMethod method) throws IncorrectOperationException {
@@ -646,7 +628,7 @@ public class RefactoringUtil {
return EXPR_COPY_PROHIBITED;
}
- if (isPlusPlusOrMinusMinus(element)) {
+ if (PsiUtil.isIncrementDecrementOperation(element)) {
return EXPR_COPY_PROHIBITED;
}
diff --git a/java/java-indexing-impl/src/com/intellij/compiler/CompilerDirectHierarchyInfo.java b/java/java-indexing-impl/src/com/intellij/compiler/CompilerDirectHierarchyInfo.java
index 5557746a8e83..d21a662f0b67 100644
--- a/java/java-indexing-impl/src/com/intellij/compiler/CompilerDirectHierarchyInfo.java
+++ b/java/java-indexing-impl/src/com/intellij/compiler/CompilerDirectHierarchyInfo.java
@@ -22,7 +22,7 @@ import org.jetbrains.annotations.NotNull;
import java.util.stream.Stream;
/**
- * represents search result for functional expressions or inheritance hierarchy of given interface/class
+ * represents search result for functional expressions or inheritance hierarchy of given interface/class using indices built on compilation time.
*/
public interface CompilerDirectHierarchyInfo {
/**
diff --git a/java/java-indexing-impl/src/com/intellij/compiler/CompilerReferenceService.java b/java/java-indexing-impl/src/com/intellij/compiler/CompilerReferenceService.java
index 0459aae0d45e..909d749396b8 100644
--- a/java/java-indexing-impl/src/com/intellij/compiler/CompilerReferenceService.java
+++ b/java/java-indexing-impl/src/com/intellij/compiler/CompilerReferenceService.java
@@ -26,6 +26,12 @@ import com.intellij.psi.search.GlobalSearchScope;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
+/**
+ * The service is intended to provide an information about class/method/field usages or classes hierarchy that is obtained on compilation time.
+ * It means that this service should not affect any find usages result when initial project is not compiled or project language is not support
+ * by {@link LanguageLightRefAdapter} extension. Any result provided by this service should be valid even if some part of a given project was
+ * modified after compilation.
+ */
public abstract class CompilerReferenceService extends AbstractProjectComponent {
public static final RegistryValue IS_ENABLED_KEY = Registry.get("compiler.ref.index");
@@ -37,15 +43,27 @@ public abstract class CompilerReferenceService extends AbstractProjectComponent
return project.getComponent(CompilerReferenceService.class);
}
+ /**
+ * @return a scope where given element has no references in code. This scope might be not a strict scope where element is not occurred.
+ */
@Nullable
public abstract GlobalSearchScope getScopeWithoutCodeReferences(@NotNull PsiElement element);
+ /**
+ * @return a hierarchy of direct inheritors built on compilation time.
+ * This hierarchy is restricted by searchFileType and searchScope.
+ */
@Nullable
public abstract CompilerDirectHierarchyInfo getDirectInheritors(@NotNull PsiNamedElement aClass,
@NotNull GlobalSearchScope useScope,
@NotNull GlobalSearchScope searchScope,
@NotNull FileType searchFileType);
+
+ /**
+ * @return a stream of functional expressions that implement given functional interface.
+ * This hierarchy is restricted by searchFileType and searchScope.
+ */
@Nullable
public abstract CompilerDirectHierarchyInfo getFunExpressions(@NotNull PsiNamedElement functionalInterface,
@NotNull GlobalSearchScope useScope,
diff --git a/java/java-psi-api/src/com/intellij/codeInsight/AnnotationTargetUtil.java b/java/java-psi-api/src/com/intellij/codeInsight/AnnotationTargetUtil.java
index 324cb0e657a8..6f48206a0c79 100644
--- a/java/java-psi-api/src/com/intellij/codeInsight/AnnotationTargetUtil.java
+++ b/java/java-psi-api/src/com/intellij/codeInsight/AnnotationTargetUtil.java
@@ -29,7 +29,7 @@ import java.util.Set;
* @author peter
*/
public class AnnotationTargetUtil {
- private static final Logger LOG = Logger.getInstance("#com.intellij.codeInsight.AnnotationUtil");
+ private static final Logger LOG = Logger.getInstance(AnnotationTargetUtil.class);
public static final Set DEFAULT_TARGETS = ContainerUtil.immutableSet(
TargetType.PACKAGE, TargetType.TYPE, TargetType.ANNOTATION_TYPE, TargetType.FIELD, TargetType.METHOD, TargetType.CONSTRUCTOR,
@@ -94,11 +94,11 @@ public class AnnotationTargetUtil {
if (scope instanceof PsiForeachStatement) {
return LOCAL_VARIABLE_TARGETS;
}
- if (scope instanceof PsiParameterList && scope.getParent() instanceof PsiLambdaExpression &&
+ if (scope instanceof PsiParameterList && scope.getParent() instanceof PsiLambdaExpression &&
((PsiParameter)element).getTypeElement() == null) {
return TargetType.EMPTY_ARRAY;
}
-
+
return PARAMETER_TARGETS;
}
if (element instanceof PsiLocalVariable) {
diff --git a/java/java-psi-api/src/com/intellij/psi/PsiAnnotation.java b/java/java-psi-api/src/com/intellij/psi/PsiAnnotation.java
index 7027c6788957..631b70802154 100644
--- a/java/java-psi-api/src/com/intellij/psi/PsiAnnotation.java
+++ b/java/java-psi-api/src/com/intellij/psi/PsiAnnotation.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2000-2013 JetBrains s.r.o.
+ * Copyright 2000-2016 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -47,7 +47,7 @@ public interface PsiAnnotation extends PsiAnnotationMemberValue, PsiMetaOwner {
*/
enum TargetType {
// see java.lang.annotation.ElementType
- TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, ANNOTATION_TYPE, PACKAGE, TYPE_USE, TYPE_PARAMETER,
+ TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, ANNOTATION_TYPE, PACKAGE, TYPE_USE, TYPE_PARAMETER, MODULE,
// auxiliary value, used when it's impossible to determine annotation's targets
UNKNOWN;
diff --git a/java/java-psi-api/src/com/intellij/psi/util/PsiUtil.java b/java/java-psi-api/src/com/intellij/psi/util/PsiUtil.java
index d79299b27445..d16641d1459b 100644
--- a/java/java-psi-api/src/com/intellij/psi/util/PsiUtil.java
+++ b/java/java-psi-api/src/com/intellij/psi/util/PsiUtil.java
@@ -83,18 +83,8 @@ public final class PsiUtil extends PsiUtilCore {
public static boolean isAccessedForWriting(@NotNull PsiExpression expr) {
if (isOnAssignmentLeftHand(expr)) return true;
- PsiElement parent = PsiTreeUtil.skipParentsOfType(expr, PsiParenthesizedExpression.class);
- if (parent instanceof PsiPrefixExpression) {
- IElementType tokenType = ((PsiPrefixExpression) parent).getOperationTokenType();
- return tokenType == JavaTokenType.PLUSPLUS || tokenType == JavaTokenType.MINUSMINUS;
- }
- else if (parent instanceof PsiPostfixExpression) {
- IElementType tokenType = ((PsiPostfixExpression) parent).getOperationTokenType();
- return tokenType == JavaTokenType.PLUSPLUS || tokenType == JavaTokenType.MINUSMINUS;
- }
- else {
- return false;
- }
+ PsiElement parent = skipParenthesizedExprUp(expr.getParent());
+ return isIncrementDecrementOperation(parent);
}
public static boolean isAccessedForReading(@NotNull PsiExpression expr) {
@@ -116,6 +106,19 @@ public final class PsiUtil extends PsiUtilCore {
public static JavaResolveResult getAccessObjectClass(@NotNull PsiExpression expression) {
if (expression instanceof PsiSuperExpression) return JavaResolveResult.EMPTY;
PsiType type = expression.getType();
+ final JavaResolveResult accessObject = getAccessObjectClass(type, expression.getProject());
+ if (accessObject != null) return accessObject;
+
+ if (type == null && expression instanceof PsiReferenceExpression) {
+ JavaResolveResult resolveResult = ((PsiReferenceExpression)expression).advancedResolve(false);
+ if (resolveResult.getElement() instanceof PsiClass) {
+ return resolveResult;
+ }
+ }
+ return JavaResolveResult.EMPTY;
+ }
+
+ private static JavaResolveResult getAccessObjectClass(PsiType type, Project project) {
if (type instanceof PsiClassType) {
return ((PsiClassType)type).resolveGenerics();
}
@@ -132,22 +135,19 @@ public final class PsiUtil extends PsiUtilCore {
final PsiClass resolved = ((PsiClassType)upperBound).resolve();
final PsiFile containingFile = resolved != null ? resolved.getContainingFile() : null;
final String packageName = containingFile instanceof PsiClassOwner ? ((PsiClassOwner)containingFile).getPackageName() : null;
- String classText = StringUtil.isEmptyOrSpaces(packageName) ? "" : "package " +packageName + ";\n ";
+ String classText = StringUtil.isEmptyOrSpaces(packageName) ? "" : "package " + packageName + ";\n ";
classText += "class I {}";
final PsiJavaFile file =
- (PsiJavaFile)PsiFileFactory.getInstance(expression.getProject()).createFileFromText("inference_dummy.java", JavaLanguage.INSTANCE, classText);
+ (PsiJavaFile)PsiFileFactory.getInstance(project).createFileFromText("inference_dummy.java", JavaLanguage.INSTANCE, classText);
final PsiTypeParameter freshParameter = file.getClasses()[0].getTypeParameters()[0];
return new ClassCandidateInfo(freshParameter, PsiSubstitutor.EMPTY);
}
}
- if (type == null && expression instanceof PsiReferenceExpression) {
- JavaResolveResult resolveResult = ((PsiReferenceExpression)expression).advancedResolve(false);
- if (resolveResult.getElement() instanceof PsiClass) {
- return resolveResult;
- }
+ if (type instanceof PsiArrayType) {
+ return getAccessObjectClass(((PsiArrayType)type).getComponentType(), project);
}
- return JavaResolveResult.EMPTY;
+ return null;
}
public static boolean isConstantExpression(@Nullable PsiExpression expression) {
@@ -330,7 +330,8 @@ public final class PsiUtil extends PsiUtilCore {
return codeBlock;
}
- public static boolean isIncrementDecrementOperation(@NotNull PsiElement element) {
+ @Contract("null -> false")
+ public static boolean isIncrementDecrementOperation(@Nullable PsiElement element) {
if (element instanceof PsiPostfixExpression) {
final IElementType sign = ((PsiPostfixExpression)element).getOperationTokenType();
if (sign == JavaTokenType.PLUSPLUS || sign == JavaTokenType.MINUSMINUS)
diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/PsiClassImplUtil.java b/java/java-psi-impl/src/com/intellij/psi/impl/PsiClassImplUtil.java
index 491f4b20e8cc..8129627033e5 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/PsiClassImplUtil.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/PsiClassImplUtil.java
@@ -388,7 +388,7 @@ public class PsiClassImplUtil {
String currentName = ((PsiMember)element).getName();
List listByName = map.get(currentName);
if (listByName == null) {
- listByName = ContainerUtil.newArrayList();
+ listByName = ContainerUtil.newSmartList();
map.put(currentName, listByName);
}
listByName.add((PsiMember)element);
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advFixture/PackageLocalClassUsedinArrayTypeOutsidePackage.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advFixture/PackageLocalClassUsedinArrayTypeOutsidePackage.java
new file mode 100644
index 000000000000..2901de562e1a
--- /dev/null
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advFixture/PackageLocalClassUsedinArrayTypeOutsidePackage.java
@@ -0,0 +1,7 @@
+package b;
+class C {
+ {
+ int u = a.B.getAs().length;
+ a.B.getAs().clone();
+ }
+}
\ No newline at end of file
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/packageClassClashNoClassInDir/pkg/sub.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/packageClassClashNoClassInDir/pkg/sub.java
new file mode 100644
index 000000000000..bcb9c34e7aaa
--- /dev/null
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/packageClassClashNoClassInDir/pkg/sub.java
@@ -0,0 +1,3 @@
+package pkg;
+
+public class sub { }
\ No newline at end of file
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/packageClassClashNoClassInDir/pkg/sub/empty.txt b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting/packageClassClashNoClassInDir/pkg/sub/empty.txt
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/completion/normal/FinishMethodReferenceWithColon.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/completion/normal/FinishMethodReferenceWithColon.java
new file mode 100644
index 000000000000..8f03430b7345
--- /dev/null
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/completion/normal/FinishMethodReferenceWithColon.java
@@ -0,0 +1,11 @@
+import java.util.stream.Stream;
+
+abstract class ColonAutoComplete {
+ void dv(Stream stream, Checker checker) {
+ stream.filter(checkx)
+ }
+}
+
+interface Checker {
+ public boolean check(Integer s);
+}
\ No newline at end of file
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/completion/normal/FinishMethodReferenceWithColon_after.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/completion/normal/FinishMethodReferenceWithColon_after.java
new file mode 100644
index 000000000000..856ad34cd8be
--- /dev/null
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/completion/normal/FinishMethodReferenceWithColon_after.java
@@ -0,0 +1,11 @@
+import java.util.stream.Stream;
+
+abstract class ColonAutoComplete {
+ void dv(Stream stream, Checker checker) {
+ stream.filter(checker:x)
+ }
+}
+
+interface Checker {
+ public boolean check(Integer s);
+}
\ No newline at end of file
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/beforeAssignmentIncomplete.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/beforeAssignmentIncomplete.java
new file mode 100644
index 000000000000..a02b43d29a99
--- /dev/null
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/beforeAssignmentIncomplete.java
@@ -0,0 +1,13 @@
+// "Replace Optional.isPresent() condition with functional style expression" "false"
+
+import java.util.Optional;
+
+public class Main {
+ void assignVariable(Optional