cleanup

platform/core-impl/src/com/intellij/openapi/editor/ex/PrioritizedDocumentListener.java

@@ -38,7 +38,11 @@ public interface PrioritizedDocumentListener extends DocumentListener {
   Comparator<? super DocumentListener> COMPARATOR = new Comparator<Object>() {
     @Override
     public int compare(Object o1, Object o2) {
-      return getPriority(o1) - getPriority(o2);
+      return integerCompare(getPriority(o1), getPriority(o2));
+    }
+
+    private int integerCompare(int x, int y) {
+        return x < y ? -1 : x == y ? 0 : 1;
     }
 
     private int getPriority(@NotNull Object o) {

platform/lang-impl/src/com/intellij/execution/impl/ConsoleViewRunningState.java

@@ -61,7 +61,7 @@ public class ConsoleViewRunningState extends ConsoleState {
     // attach to process stdin
     if (attachToStdIn) {
       final OutputStream processInput = myProcessHandler.getProcessInput();
-      myUserInputWriter = processInput != null ? createOutputStreamWriter(processInput, processHandler) : null;
+      myUserInputWriter = processInput == null ? null : createOutputStreamWriter(processInput, processHandler);
     }
     else {
       myUserInputWriter = null;

platform/util/src/com/intellij/util/containers/Queue.java

@@ -19,6 +19,7 @@ import com.intellij.util.ArrayUtil;
 import com.intellij.util.Processor;
 import org.jetbrains.annotations.NotNull;
 
+import java.lang.reflect.Array;
 import java.util.Arrays;
 import java.util.List;
 
@@ -70,14 +71,26 @@ public class Queue<T> {
     return isWrapped ? myArray.length - myFirst + myLast : myLast - myFirst;
   }
 
+  @NotNull
   public List<T> toList() {
     return Arrays.asList(normalize(size()));
   }
 
+  @NotNull
   public Object[] toArray() {
     return normalize(size());
   }
 
+  @NotNull
+  public T[] toArray(T[] array) {
+    if (array.length < size()) {
+      //noinspection unchecked
+      array = (T[])Array.newInstance(array.getClass().getComponentType(), size());
+    }
+
+    return normalize(array);
+  }
+
   public T pullFirst() {
     T result = peekFirst();
     myArray[myFirst] = null;
@@ -103,8 +116,13 @@ public class Queue<T> {
     return length;
   }
 
+  @NotNull
   private T[] normalize(int capacity) {
     @SuppressWarnings("unchecked") T[] result = (T[])new Object[capacity];
+    return normalize(result);
+  }
+
+  private T[] normalize(T[] result) {
     if (isWrapped) {
       int tailLength = copyFromTo(myFirst, myArray.length, result, 0);
       copyFromTo(0, myLast, result, tailLength);
@@ -122,17 +140,9 @@ public class Queue<T> {
   }
 
   public T set(int index, T value) {
-    int arrayIndex;
-    if (isWrapped) {
-      if (myFirst + index >= myArray.length) {
-        arrayIndex = index - myArray.length + myFirst;
-      }
-      else {
-        arrayIndex = myFirst + index;
-      }
-    }
-    else {
-      arrayIndex = myFirst + index;
+    int arrayIndex = myFirst + index;
+    if (isWrapped && arrayIndex >= myArray.length) {
+      arrayIndex -= myArray.length;
     }
     final Object old = myArray[arrayIndex];
     myArray[arrayIndex] = value;

platform/util/src/com/intellij/util/containers/SortedList.java

@@ -15,6 +15,9 @@
  */
 package com.intellij.util.containers;
 
+import com.intellij.util.SmartList;
+import org.jetbrains.annotations.NotNull;
+
 import java.util.*;
 
 /**
@@ -23,26 +26,27 @@ import java.util.*;
 public class SortedList<T> extends AbstractList<T>{
   private final SortedMap<T, List<T>> myMap;
   private final Comparator<T> myComparator;
-  private List<T> myDelegate = null;
+  private List<T> myDelegate;
 
-  public SortedList(final Comparator<T> comparator) {
+  public SortedList(@NotNull Comparator<T> comparator) {
     myComparator = comparator;
     myMap = new TreeMap<T, List<T>>(comparator);
   }
 
+  @NotNull
   public Comparator<T> getComparator() {
     return myComparator;
   }
 
   @Override
   public void add(final int index, final T element) {
-    _addToMap(element);
+    addToMap(element);
   }
 
-  private void _addToMap(T element) {
+  private void addToMap(T element) {
     List<T> group = myMap.get(element);
     if (group == null) {
-      myMap.put(element, group = new ArrayList<T>());
+      myMap.put(element, group = new SmartList<T>());
     }
     group.add(element);
     myDelegate = null;
@@ -50,7 +54,7 @@ public class SortedList<T> extends AbstractList<T>{
 
   @Override
   public boolean add(T t) {
-    _addToMap(t);
+    addToMap(t);
     return true;
   }
 
@@ -76,15 +80,16 @@ public class SortedList<T> extends AbstractList<T>{
 
   @Override
   public T get(final int index) {
-    ensureLinearized();
-    return myDelegate.get(index);
+    return ensureLinearized().get(index);
   }
 
+  @NotNull
   private List<T> ensureLinearized() {
-    if (myDelegate == null) {
-      myDelegate = ContainerUtil.concat(myMap.values());
+    List<T> delegate = myDelegate;
+    if (delegate == null) {
+      myDelegate = delegate = ContainerUtil.concat(myMap.values());
     }
-    return myDelegate;
+    return delegate;
   }
 
   @Override
@@ -100,7 +105,6 @@ public class SortedList<T> extends AbstractList<T>{
 
   @Override
   public int size() {
-    ensureLinearized();
-    return myDelegate.size();
+    return ensureLinearized().size();
   }
 }