cleanup: prefer to use resolvedPromise

platform/platform-impl/src/com/intellij/openapi/vfs/impl/http/RemoteFileInfoImpl.java

@@ -30,13 +30,14 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.concurrency.AsyncPromise;
 import org.jetbrains.concurrency.Promise;
-import org.jetbrains.concurrency.PromiseKt;
 
 import java.io.File;
 import java.io.IOException;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicBoolean;
 
+import static org.jetbrains.concurrency.Promises.rejectedPromise;
+
 /**
  * @author nik
  */
@@ -306,7 +307,7 @@ public class RemoteFileInfoImpl implements RemoteContentProvider.DownloadingCall
 
         case ERROR_OCCURRED:
         default:
-          return PromiseKt.rejectedPromise("errorOccurred");
+          return rejectedPromise("errorOccurred");
       }
     }
   }

platform/projectModel-api/src/org/jetbrains/concurrency/DonePromise.java

@@ -23,6 +23,9 @@ import org.jetbrains.annotations.Nullable;
 
 import java.util.concurrent.TimeUnit;
 
+import static org.jetbrains.concurrency.Promises.rejectedPromise;
+import static org.jetbrains.concurrency.Promises.resolvedPromise;
+
 class DonePromise<T> implements Getter<T>, Promise<T> {
   private final T result;
 
@@ -62,10 +65,10 @@ class DonePromise<T> implements Getter<T>, Promise<T> {
   @Override
   public <SUB_RESULT> Promise<SUB_RESULT> then(@NotNull Function<? super T, ? extends SUB_RESULT> done) {
     if (done instanceof Obsolescent && ((Obsolescent)done).isObsolete()) {
-      return PromiseKt.rejectedPromise("obsolete");
+      return rejectedPromise("obsolete");
     }
     else {
-      return Promise.resolve(done.fun(result));
+      return resolvedPromise(done.fun(result));
     }
   }
 

platform/projectModel-api/src/org/jetbrains/concurrency/Promise.java

@@ -24,7 +24,7 @@ import java.util.concurrent.TimeUnit;
 
 public interface Promise<T> {
   Promise<Void> DONE = new DonePromise<>(null);
-  Promise<Void> REJECTED = PromiseKt.getREJECTED();
+  Promise<Void> REJECTED = Promises.rejectedPromise();
 
   enum State {
     PENDING, FULFILLED, REJECTED

platform/projectModel-api/src/org/jetbrains/concurrency/promise-ex.kt

@@ -1,76 +0,0 @@
-/*
- * 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.
- */
-@file:JvmName("Promises")
-package org.jetbrains.concurrency
-
-import com.intellij.util.Consumer
-
-fun resolvedPromise(): Promise<*> = Promise.DONE
-
-fun <T> resolvedPromise(result: T) = Promise.resolve(result)
-
-fun all(promises: Collection<Promise<*>>) = if (promises.size == 1) promises.first() else all(promises, null)
-
-fun <T> all(promises: Collection<Promise<*>>, totalResult: T?): Promise<T> {
-  if (promises.isEmpty()) {
-    return resolvedPromise(null)
-  }
-
-  val totalPromise = AsyncPromise<T>()
-  val done = CountDownConsumer(promises.size, totalPromise, totalResult)
-  val rejected = Consumer<Throwable> { error -> totalPromise.setError(error) }
-
-  for (promise in promises) {
-    promise.done(done)
-    promise.rejected(rejected)
-  }
-  return totalPromise
-}
-
-private class CountDownConsumer<T>(@Volatile private var countDown: Int, private val promise: AsyncPromise<T>, private val totalResult: T?) : Consumer<Any?> {
-  override fun consume(t: Any?) {
-    if (--countDown == 0) {
-      promise.setResult(totalResult)
-    }
-  }
-}
-
-fun <T> any(promises: Collection<Promise<T>>, totalError: String): Promise<T> {
-  if (promises.isEmpty()) {
-    return resolvedPromise(null)
-  }
-  else if (promises.size == 1) {
-    return promises.first()
-  }
-
-  val totalPromise = AsyncPromise<T>()
-  val done = Consumer<T> { result -> totalPromise.setResult(result) }
-  val rejected = object : Consumer<Throwable> {
-    @Volatile private var toConsume = promises.size
-
-    override fun consume(throwable: Throwable) {
-      if (--toConsume <= 0) {
-        totalPromise.setError(totalError)
-      }
-    }
-  }
-
-  for (promise in promises) {
-    promise.done(done)
-    promise.rejected(rejected)
-  }
-  return totalPromise
-}

platform/projectModel-api/src/org/jetbrains/concurrency/promise.kt

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+@file:JvmName("Promises")
 package org.jetbrains.concurrency
 
 import com.intellij.openapi.application.ApplicationManager
@@ -37,7 +38,6 @@ abstract class ObsolescentConsumer<T>(private val obsolescent: Obsolescent) : Ob
   override fun isObsolete() = obsolescent.isObsolete
 }
 
-
 inline fun <T, SUB_RESULT> Promise<T>.then(obsolescent: Obsolescent, crossinline handler: (T) -> SUB_RESULT) = then(object : ObsolescentFunction<T, SUB_RESULT> {
   override fun `fun`(param: T) = handler(param)
 
@@ -186,4 +186,61 @@ fun ActionCallback.toPromise(): Promise<Void> {
   val promise = AsyncPromise<Void>()
   doWhenDone { promise.setResult(null) }.doWhenRejected { error -> promise.setError(createError(error ?: "Internal error")) }
   return promise
+}
+
+fun resolvedPromise(): Promise<*> = Promise.DONE
+
+fun <T> resolvedPromise(result: T) = Promise.resolve(result)
+
+fun all(promises: Collection<Promise<*>>) = if (promises.size == 1) promises.first() else all(promises, null)
+
+fun <T> all(promises: Collection<Promise<*>>, totalResult: T?): Promise<T> {
+  if (promises.isEmpty()) {
+    return resolvedPromise(null)
+  }
+
+  val totalPromise = AsyncPromise<T>()
+  val done = CountDownConsumer(promises.size, totalPromise, totalResult)
+  val rejected = Consumer<Throwable> { error -> totalPromise.setError(error) }
+
+  for (promise in promises) {
+    promise.done(done)
+    promise.rejected(rejected)
+  }
+  return totalPromise
+}
+
+private class CountDownConsumer<T>(@Volatile private var countDown: Int, private val promise: AsyncPromise<T>, private val totalResult: T?) : Consumer<Any?> {
+  override fun consume(t: Any?) {
+    if (--countDown == 0) {
+      promise.setResult(totalResult)
+    }
+  }
+}
+
+fun <T> any(promises: Collection<Promise<T>>, totalError: String): Promise<T> {
+  if (promises.isEmpty()) {
+    return resolvedPromise(null)
+  }
+  else if (promises.size == 1) {
+    return promises.first()
+  }
+
+  val totalPromise = AsyncPromise<T>()
+  val done = Consumer<T> { result -> totalPromise.setResult(result) }
+  val rejected = object : Consumer<Throwable> {
+    @Volatile private var toConsume = promises.size
+
+    override fun consume(throwable: Throwable) {
+      if (--toConsume <= 0) {
+        totalPromise.setError(totalError)
+      }
+    }
+  }
+
+  for (promise in promises) {
+    promise.done(done)
+    promise.rejected(rejected)
+  }
+  return totalPromise
 }

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/XDebuggerUtilImpl.java

@@ -77,13 +77,14 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.concurrency.AsyncPromise;
 import org.jetbrains.concurrency.Promise;
-import org.jetbrains.concurrency.PromiseKt;
 
 import javax.swing.*;
 import javax.swing.event.ListSelectionEvent;
 import javax.swing.event.ListSelectionListener;
 import java.util.*;
 
+import static org.jetbrains.concurrency.Promises.rejectedPromise;
+
 /**
  * @author nik
  */
@@ -271,7 +272,7 @@ public class XDebuggerUtilImpl extends XDebuggerUtil {
             Promise.resolve((XLineBreakpoint)breakpointManager.addLineBreakpoint(type, file.getUrl(), line, properties, temporary)));
           return;
         }
-        result.setResult(PromiseKt.<XLineBreakpoint>rejectedPromise());
+        result.setResult(rejectedPromise());
       }
     }.execute().getResultObject();
   }
@@ -431,7 +432,7 @@ public class XDebuggerUtilImpl extends XDebuggerUtil {
 
   @Override
   public <B extends XBreakpoint<?>> Comparator<B> getDefaultBreakpointComparator(final XBreakpointType<B, ?> type) {
-    return (o1, o2) -> type.getDisplayText(o1).compareTo(type.getDisplayText(o2));
+    return Comparator.comparing(type::getDisplayText);
   }
 
   @Override

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/breakpoints/XBreakpointUtil.java

@@ -38,12 +38,12 @@ import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.concurrency.Promise;
-import org.jetbrains.concurrency.PromiseKt;
 
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 
+import static org.jetbrains.concurrency.Promises.rejectedPromise;
+
 /**
  * @author nik
  */
@@ -103,7 +103,7 @@ public class XBreakpointUtil {
     for (DebuggerSupport debuggerSupport : DebuggerSupport.getDebuggerSupports()) {
       panelProviders.add(debuggerSupport.getBreakpointPanelProvider());
     }
-    Collections.sort(panelProviders, (o1, o2) -> o2.getPriority() - o1.getPriority());
+    panelProviders.sort((o1, o2) -> o2.getPriority() - o1.getPriority());
     return panelProviders;
   }
 
@@ -184,6 +184,6 @@ public class XBreakpointUtil {
       }
     }
 
-    return PromiseKt.rejectedPromise();
+    return rejectedPromise();
   }
 }