diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java
index d9abdcd23a8..3e78ed8ab2b 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java
@@ -78,15 +78,18 @@ public class CallResolver {
     private ArgumentTypeResolver argumentTypeResolver;
     private GenericCandidateResolver genericCandidateResolver;
     private CallCompleter callCompleter;
-    @NotNull private final TaskPrioritizer taskPrioritizer;
+    private final TaskPrioritizer taskPrioritizer;
+    private final ResolutionResultsHandler resolutionResultsHandler;
 
     private static final PerformanceCounter callResolvePerfCounter = PerformanceCounter.Companion.create("Call resolve", ExpressionTypingVisitorDispatcher.typeInfoPerfCounter);
     private static final PerformanceCounter candidatePerfCounter = PerformanceCounter.Companion.create("Call resolve candidate analysis", true);
 
     public CallResolver(
-            @NotNull TaskPrioritizer taskPrioritizer
+            @NotNull TaskPrioritizer taskPrioritizer,
+            @NotNull ResolutionResultsHandler resolutionResultsHandler
     ) {
         this.taskPrioritizer = taskPrioritizer;
+        this.resolutionResultsHandler = resolutionResultsHandler;
     }
 
     // component dependency cycle
@@ -590,7 +593,7 @@ public class CallResolver {
             addResolvedCall(task, callTransformer, context);
         }
 
-        OverloadResolutionResultsImpl<F> results = ResolutionResultsHandler.INSTANCE.computeResultAndReportErrors(
+        OverloadResolutionResultsImpl<F> results = resolutionResultsHandler.computeResultAndReportErrors(
                 task, task.getResolvedCalls());
         if (!results.isSingleResult() && !results.isIncomplete()) {
             argumentTypeResolver.checkTypesWithNoCallee(task.toBasic());
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/OverloadingConflictResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/OverloadingConflictResolver.java
index a15aeb37bf2..11f86bb86ad 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/OverloadingConflictResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/OverloadingConflictResolver.java
@@ -34,9 +34,7 @@ import java.util.Set;
 
 public class OverloadingConflictResolver {
 
-    public static OverloadingConflictResolver INSTANCE = new OverloadingConflictResolver();
-
-    private OverloadingConflictResolver() {}
+    public OverloadingConflictResolver() {}
 
     @Nullable
     public <D extends CallableDescriptor> MutableResolvedCall<D> findMaximallySpecific(
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/ResolutionResultsHandler.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/ResolutionResultsHandler.java
index dfdea00c980..1e446fc8a30 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/ResolutionResultsHandler.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/ResolutionResultsHandler.java
@@ -34,9 +34,11 @@ import static org.jetbrains.kotlin.resolve.calls.model.ResolvedCallImpl.MAP_TO_R
 import static org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus.*;
 
 public class ResolutionResultsHandler {
-    public static ResolutionResultsHandler INSTANCE = new ResolutionResultsHandler();
+    private final OverloadingConflictResolver overloadingConflictResolver;
 
-    private ResolutionResultsHandler() {}
+    public ResolutionResultsHandler(@NotNull OverloadingConflictResolver overloadingConflictResolver) {
+        this.overloadingConflictResolver = overloadingConflictResolver;
+    }
 
     @NotNull
     public <D extends CallableDescriptor> OverloadResolutionResultsImpl<D> computeResultAndReportErrors(
@@ -184,13 +186,13 @@ public class ResolutionResultsHandler {
             return OverloadResolutionResultsImpl.success(noOverrides.iterator().next());
         }
 
-        MutableResolvedCall<D> maximallySpecific = OverloadingConflictResolver.INSTANCE.findMaximallySpecific(noOverrides, false);
+        MutableResolvedCall<D> maximallySpecific = overloadingConflictResolver.findMaximallySpecific(noOverrides, false);
         if (maximallySpecific != null) {
             return OverloadResolutionResultsImpl.success(maximallySpecific);
         }
 
         if (discriminateGenerics) {
-            MutableResolvedCall<D> maximallySpecificGenericsDiscriminated = OverloadingConflictResolver.INSTANCE.findMaximallySpecific(
+            MutableResolvedCall<D> maximallySpecificGenericsDiscriminated = overloadingConflictResolver.findMaximallySpecific(
                     noOverrides, true);
             if (maximallySpecificGenericsDiscriminated != null) {
                 return OverloadResolutionResultsImpl.success(maximallySpecificGenericsDiscriminated);