OverloadingConflictResolver made singleton

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java

@@ -39,8 +39,6 @@ import org.jetbrains.jet.lang.resolve.calls.CandidateResolver;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import org.jetbrains.jet.lang.resolve.TypeResolver;
 import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver;
-import org.jetbrains.jet.lang.resolve.calls.results.ResolutionResultsHandler;
-import org.jetbrains.jet.lang.resolve.calls.results.OverloadingConflictResolver;
 import org.jetbrains.jet.lang.resolve.ImportsResolver;
 import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver;
 import org.jetbrains.jet.lang.resolve.OverloadResolver;
@@ -88,8 +86,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
     private ExpressionTypingServices expressionTypingServices;
     private TypeResolver typeResolver;
     private QualifiedExpressionResolver qualifiedExpressionResolver;
-    private ResolutionResultsHandler resolutionResultsHandler;
-    private OverloadingConflictResolver overloadingConflictResolver;
     private ImportsResolver importsResolver;
     private ScriptHeaderResolver scriptHeaderResolver;
     private OverloadResolver overloadResolver;
@@ -138,8 +134,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.expressionTypingServices = new ExpressionTypingServices();
         this.typeResolver = new TypeResolver();
         this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
-        this.resolutionResultsHandler = new ResolutionResultsHandler();
-        this.overloadingConflictResolver = new OverloadingConflictResolver();
         this.importsResolver = new ImportsResolver();
         this.scriptHeaderResolver = new ScriptHeaderResolver();
         this.overloadResolver = new OverloadResolver();
@@ -221,7 +215,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
 
         callResolver.setCandidateResolver(candidateResolver);
         callResolver.setExpressionTypingServices(expressionTypingServices);
-        callResolver.setResolutionResultsHandler(resolutionResultsHandler);
         callResolver.setTypeResolver(typeResolver);
 
         candidateResolver.setExpressionTypingServices(expressionTypingServices);
@@ -237,8 +230,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         typeResolver.setModuleConfiguration(moduleConfiguration);
         typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
 
-        resolutionResultsHandler.setOverloadingConflictResolver(overloadingConflictResolver);
-
         importsResolver.setConfiguration(moduleConfiguration);
         importsResolver.setContext(topDownAnalysisContext);
         importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);

compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java

@@ -30,8 +30,6 @@ import org.jetbrains.jet.lang.resolve.DescriptorResolver;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
 import org.jetbrains.jet.lang.resolve.TypeResolver;
 import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver;
-import org.jetbrains.jet.lang.resolve.calls.results.ResolutionResultsHandler;
-import org.jetbrains.jet.lang.resolve.calls.results.OverloadingConflictResolver;
 import org.jetbrains.jet.lang.resolve.ControlFlowAnalyzer;
 import org.jetbrains.jet.lang.resolve.DeclarationsChecker;
 import org.jetbrains.jet.lang.resolve.ScriptBodyResolver;
@@ -55,8 +53,6 @@ public class InjectorForBodyResolve {
     private AnnotationResolver annotationResolver;
     private TypeResolver typeResolver;
     private QualifiedExpressionResolver qualifiedExpressionResolver;
-    private ResolutionResultsHandler resolutionResultsHandler;
-    private OverloadingConflictResolver overloadingConflictResolver;
     private ControlFlowAnalyzer controlFlowAnalyzer;
     private DeclarationsChecker declarationsChecker;
     private ScriptBodyResolver scriptBodyResolver;
@@ -82,8 +78,6 @@ public class InjectorForBodyResolve {
         this.annotationResolver = new AnnotationResolver();
         this.typeResolver = new TypeResolver();
         this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
-        this.resolutionResultsHandler = new ResolutionResultsHandler();
-        this.overloadingConflictResolver = new OverloadingConflictResolver();
         this.controlFlowAnalyzer = new ControlFlowAnalyzer();
         this.declarationsChecker = new DeclarationsChecker();
         this.scriptBodyResolver = new ScriptBodyResolver();
@@ -101,7 +95,6 @@ public class InjectorForBodyResolve {
 
         callResolver.setCandidateResolver(candidateResolver);
         callResolver.setExpressionTypingServices(expressionTypingServices);
-        callResolver.setResolutionResultsHandler(resolutionResultsHandler);
         callResolver.setTypeResolver(typeResolver);
 
         candidateResolver.setExpressionTypingServices(expressionTypingServices);
@@ -124,8 +117,6 @@ public class InjectorForBodyResolve {
         typeResolver.setModuleConfiguration(moduleConfiguration);
         typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
 
-        resolutionResultsHandler.setOverloadingConflictResolver(overloadingConflictResolver);
-
         controlFlowAnalyzer.setTopDownAnalysisParameters(topDownAnalysisParameters);
         controlFlowAnalyzer.setTrace(bindingTrace);
 

compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java

@@ -29,8 +29,6 @@ import org.jetbrains.jet.lang.resolve.AnnotationResolver;
 import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
 import org.jetbrains.jet.lang.resolve.calls.CandidateResolver;
-import org.jetbrains.jet.lang.resolve.calls.results.ResolutionResultsHandler;
-import org.jetbrains.jet.lang.resolve.calls.results.OverloadingConflictResolver;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
 
@@ -49,8 +47,6 @@ public class InjectorForLazyResolve {
     private QualifiedExpressionResolver qualifiedExpressionResolver;
     private CallResolver callResolver;
     private CandidateResolver candidateResolver;
-    private ResolutionResultsHandler resolutionResultsHandler;
-    private OverloadingConflictResolver overloadingConflictResolver;
 
     public InjectorForLazyResolve(
         @NotNull Project project,
@@ -70,8 +66,6 @@ public class InjectorForLazyResolve {
         this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
         this.callResolver = new CallResolver();
         this.candidateResolver = new CandidateResolver();
-        this.resolutionResultsHandler = new ResolutionResultsHandler();
-        this.overloadingConflictResolver = new OverloadingConflictResolver();
 
         this.descriptorResolver.setAnnotationResolver(annotationResolver);
         this.descriptorResolver.setExpressionTypingServices(expressionTypingServices);
@@ -92,14 +86,11 @@ public class InjectorForLazyResolve {
 
         callResolver.setCandidateResolver(candidateResolver);
         callResolver.setExpressionTypingServices(expressionTypingServices);
-        callResolver.setResolutionResultsHandler(resolutionResultsHandler);
         callResolver.setTypeResolver(typeResolver);
 
         candidateResolver.setExpressionTypingServices(expressionTypingServices);
         candidateResolver.setTypeResolver(typeResolver);
 
-        resolutionResultsHandler.setOverloadingConflictResolver(overloadingConflictResolver);
-
     }
 
     @PreDestroy

compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java

@@ -26,8 +26,6 @@ import org.jetbrains.jet.lang.resolve.TypeResolver;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
 import org.jetbrains.jet.lang.resolve.DescriptorResolver;
 import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver;
-import org.jetbrains.jet.lang.resolve.calls.results.ResolutionResultsHandler;
-import org.jetbrains.jet.lang.resolve.calls.results.OverloadingConflictResolver;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
 
@@ -43,8 +41,6 @@ public class InjectorForMacros {
     private AnnotationResolver annotationResolver;
     private DescriptorResolver descriptorResolver;
     private QualifiedExpressionResolver qualifiedExpressionResolver;
-    private ResolutionResultsHandler resolutionResultsHandler;
-    private OverloadingConflictResolver overloadingConflictResolver;
 
     public InjectorForMacros(
         @NotNull Project project,
@@ -59,8 +55,6 @@ public class InjectorForMacros {
         this.annotationResolver = new AnnotationResolver();
         this.descriptorResolver = new DescriptorResolver();
         this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
-        this.resolutionResultsHandler = new ResolutionResultsHandler();
-        this.overloadingConflictResolver = new OverloadingConflictResolver();
 
         this.expressionTypingServices.setCallResolver(callResolver);
         this.expressionTypingServices.setDescriptorResolver(descriptorResolver);
@@ -69,7 +63,6 @@ public class InjectorForMacros {
 
         callResolver.setCandidateResolver(candidateResolver);
         callResolver.setExpressionTypingServices(expressionTypingServices);
-        callResolver.setResolutionResultsHandler(resolutionResultsHandler);
         callResolver.setTypeResolver(typeResolver);
 
         candidateResolver.setExpressionTypingServices(expressionTypingServices);
@@ -87,8 +80,6 @@ public class InjectorForMacros {
         descriptorResolver.setExpressionTypingServices(expressionTypingServices);
         descriptorResolver.setTypeResolver(typeResolver);
 
-        resolutionResultsHandler.setOverloadingConflictResolver(overloadingConflictResolver);
-
     }
 
     @PreDestroy

compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java

@@ -37,8 +37,6 @@ import org.jetbrains.jet.lang.resolve.calls.CandidateResolver;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import org.jetbrains.jet.lang.resolve.TypeResolver;
 import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver;
-import org.jetbrains.jet.lang.resolve.calls.results.ResolutionResultsHandler;
-import org.jetbrains.jet.lang.resolve.calls.results.OverloadingConflictResolver;
 import org.jetbrains.jet.lang.resolve.ImportsResolver;
 import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver;
 import org.jetbrains.jet.lang.resolve.OverloadResolver;
@@ -71,8 +69,6 @@ public class InjectorForTopDownAnalyzerBasic {
     private ExpressionTypingServices expressionTypingServices;
     private TypeResolver typeResolver;
     private QualifiedExpressionResolver qualifiedExpressionResolver;
-    private ResolutionResultsHandler resolutionResultsHandler;
-    private OverloadingConflictResolver overloadingConflictResolver;
     private ImportsResolver importsResolver;
     private ScriptHeaderResolver scriptHeaderResolver;
     private OverloadResolver overloadResolver;
@@ -107,8 +103,6 @@ public class InjectorForTopDownAnalyzerBasic {
         this.expressionTypingServices = new ExpressionTypingServices();
         this.typeResolver = new TypeResolver();
         this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
-        this.resolutionResultsHandler = new ResolutionResultsHandler();
-        this.overloadingConflictResolver = new OverloadingConflictResolver();
         this.importsResolver = new ImportsResolver();
         this.scriptHeaderResolver = new ScriptHeaderResolver();
         this.overloadResolver = new OverloadResolver();
@@ -164,7 +158,6 @@ public class InjectorForTopDownAnalyzerBasic {
 
         callResolver.setCandidateResolver(candidateResolver);
         callResolver.setExpressionTypingServices(expressionTypingServices);
-        callResolver.setResolutionResultsHandler(resolutionResultsHandler);
         callResolver.setTypeResolver(typeResolver);
 
         candidateResolver.setExpressionTypingServices(expressionTypingServices);
@@ -180,8 +173,6 @@ public class InjectorForTopDownAnalyzerBasic {
         typeResolver.setModuleConfiguration(moduleConfiguration);
         typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
 
-        resolutionResultsHandler.setOverloadingConflictResolver(overloadingConflictResolver);
-
         importsResolver.setConfiguration(moduleConfiguration);
         importsResolver.setContext(topDownAnalysisContext);
         importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java

@@ -63,8 +63,6 @@ import static org.jetbrains.jet.lang.types.TypeUtils.NO_EXPECTED_TYPE;
 public class CallResolver {
     private final JetTypeChecker typeChecker = JetTypeChecker.INSTANCE;
 
-    @NotNull
-    private ResolutionResultsHandler resolutionResultsHandler;
     @NotNull
     private ExpressionTypingServices expressionTypingServices;
     @NotNull
@@ -72,11 +70,6 @@ public class CallResolver {
     @NotNull
     private CandidateResolver candidateResolver;
 
-    @Inject
-    public void setResolutionResultsHandler(@NotNull ResolutionResultsHandler resolutionResultsHandler) {
-        this.resolutionResultsHandler = resolutionResultsHandler;
-    }
-
     @Inject
     public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) {
         this.expressionTypingServices = expressionTypingServices;
@@ -331,7 +324,7 @@ public class CallResolver {
             candidateResolver.completeTypeInferenceDependentOnExpectedTypeForCall(
                     CallResolutionContext.create(context, tracing, resolvedCall), successful, failed);
         }
-        OverloadResolutionResultsImpl<D> results = resolutionResultsHandler.computeResultAndReportErrors(context.trace, tracing, successful,
+        OverloadResolutionResultsImpl<D> results = ResolutionResultsHandler.INSTANCE.computeResultAndReportErrors(context.trace, tracing, successful,
                                                                                                          failed);
         if (!results.isSingleResult()) {
             candidateResolver.checkTypesWithNoCallee(context);
@@ -505,7 +498,7 @@ public class CallResolver {
             }
         }
 
-        OverloadResolutionResultsImpl<F> results = resolutionResultsHandler.computeResultAndReportErrors(
+        OverloadResolutionResultsImpl<F> results = ResolutionResultsHandler.INSTANCE.computeResultAndReportErrors(
                 task.trace, task.tracing, task.getResolvedCalls());
         if (!results.isSingleResult() && !results.isIncomplete()) {
             candidateResolver.checkTypesWithNoCallee(task.toBasic());

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/results/OverloadingConflictResolver.java

@@ -40,6 +40,10 @@ import java.util.Set;
  */
 public class OverloadingConflictResolver {
 
+    public static OverloadingConflictResolver INSTANCE = new OverloadingConflictResolver();
+
+    private OverloadingConflictResolver() {}
+
     @Nullable
     public <D extends CallableDescriptor> ResolvedCallWithTrace<D> findMaximallySpecific(
             @NotNull Set<ResolvedCallWithTrace<D>> candidates,
@@ -79,7 +83,11 @@ public class OverloadingConflictResolver {
      * Int < Long
      * Int < Short < Byte
      */
-    private <Descriptor extends CallableDescriptor> boolean moreSpecific(Descriptor f, Descriptor g, boolean discriminateGenericDescriptors) {
+    private <Descriptor extends CallableDescriptor> boolean moreSpecific(
+            Descriptor f,
+            Descriptor g,
+            boolean discriminateGenericDescriptors
+    ) {
         if (f.getContainingDeclaration() instanceof ScriptDescriptor && g.getContainingDeclaration() instanceof ScriptDescriptor) {
             ScriptDescriptor fs = (ScriptDescriptor) f.getContainingDeclaration();
             ScriptDescriptor gs = (ScriptDescriptor) g.getContainingDeclaration();

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/results/ResolutionResultsHandler.java

@@ -24,7 +24,6 @@ import org.jetbrains.jet.lang.resolve.OverridingUtil;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallWithTrace;
 import org.jetbrains.jet.lang.resolve.calls.tasks.TracingStrategy;
 
-import javax.inject.Inject;
 import java.util.Collection;
 import java.util.EnumSet;
 import java.util.Iterator;
@@ -37,19 +36,16 @@ import static org.jetbrains.jet.lang.resolve.calls.results.ResolutionStatus.STRO
 import static org.jetbrains.jet.lang.resolve.calls.results.ResolutionStatus.UNKNOWN_STATUS;
 
 public class ResolutionResultsHandler {
-    @NotNull
+    public static ResolutionResultsHandler INSTANCE = new ResolutionResultsHandler();
-    private OverloadingConflictResolver overloadingConflictResolver;
 
-    @Inject
+    private ResolutionResultsHandler() {}
-    public void setOverloadingConflictResolver(@NotNull OverloadingConflictResolver overloadingConflictResolver) {
-        this.overloadingConflictResolver = overloadingConflictResolver;
-    }
 
     @NotNull
     public <D extends CallableDescriptor> OverloadResolutionResultsImpl<D> computeResultAndReportErrors(
             @NotNull BindingTrace trace,
             @NotNull TracingStrategy tracing,
-            @NotNull Set<ResolvedCallWithTrace<D>> candidates) {
+            @NotNull Set<ResolvedCallWithTrace<D>> candidates
+    ) {
         Set<ResolvedCallWithTrace<D>> successfulCandidates = Sets.newLinkedHashSet();
         Set<ResolvedCallWithTrace<D>> failedCandidates = Sets.newLinkedHashSet();
         for (ResolvedCallWithTrace<D> candidateCall : candidates) {
@@ -72,7 +68,8 @@ public class ResolutionResultsHandler {
             @NotNull BindingTrace trace,
             @NotNull TracingStrategy tracing,
             @NotNull Set<ResolvedCallWithTrace<D>> successfulCandidates,
-            @NotNull Set<ResolvedCallWithTrace<D>> failedCandidates) {
+            @NotNull Set<ResolvedCallWithTrace<D>> failedCandidates
+    ) {
         // TODO : maybe it's better to filter overrides out first, and only then look for the maximally specific
 
         if (successfulCandidates.size() > 0) {
@@ -137,7 +134,7 @@ public class ResolutionResultsHandler {
         }
     }
 
-    private static <D extends CallableDescriptor> boolean allClean(Collection<ResolvedCallWithTrace<D>> results) {
+    private <D extends CallableDescriptor> boolean allClean(Collection<ResolvedCallWithTrace<D>> results) {
         for (ResolvedCallWithTrace<D> result : results) {
             if (result.isDirty()) return false;
         }
@@ -161,13 +158,13 @@ public class ResolutionResultsHandler {
             if (cleanCandidates.isEmpty()) {
                 cleanCandidates = candidates;
             }
-            ResolvedCallWithTrace<D> maximallySpecific = overloadingConflictResolver.findMaximallySpecific(cleanCandidates, false);
+            ResolvedCallWithTrace<D> maximallySpecific = OverloadingConflictResolver.INSTANCE.findMaximallySpecific(cleanCandidates, false);
             if (maximallySpecific != null) {
                 return OverloadResolutionResultsImpl.success(maximallySpecific);
             }
 
             if (discriminateGenerics) {
-                ResolvedCallWithTrace<D> maximallySpecificGenericsDiscriminated = overloadingConflictResolver.findMaximallySpecific(cleanCandidates, true);
+                ResolvedCallWithTrace<D> maximallySpecificGenericsDiscriminated = OverloadingConflictResolver.INSTANCE.findMaximallySpecific(cleanCandidates, true);
                 if (maximallySpecificGenericsDiscriminated != null) {
                     return OverloadResolutionResultsImpl.success(maximallySpecificGenericsDiscriminated);
                 }

compiler/tests/org/jetbrains/jet/di/InjectorForTests.java

@@ -27,8 +27,6 @@ import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
 import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver;
 import org.jetbrains.jet.lang.resolve.calls.CandidateResolver;
-import org.jetbrains.jet.lang.resolve.calls.results.ResolutionResultsHandler;
-import org.jetbrains.jet.lang.resolve.calls.results.OverloadingConflictResolver;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
 
@@ -45,8 +43,6 @@ public class InjectorForTests {
     private AnnotationResolver annotationResolver;
     private QualifiedExpressionResolver qualifiedExpressionResolver;
     private CandidateResolver candidateResolver;
-    private ResolutionResultsHandler resolutionResultsHandler;
-    private OverloadingConflictResolver overloadingConflictResolver;
 
     public InjectorForTests(
         @NotNull Project project
@@ -61,8 +57,6 @@ public class InjectorForTests {
         this.annotationResolver = new AnnotationResolver();
         this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
         this.candidateResolver = new CandidateResolver();
-        this.resolutionResultsHandler = new ResolutionResultsHandler();
-        this.overloadingConflictResolver = new OverloadingConflictResolver();
 
         this.descriptorResolver.setAnnotationResolver(annotationResolver);
         this.descriptorResolver.setExpressionTypingServices(expressionTypingServices);
@@ -80,7 +74,6 @@ public class InjectorForTests {
 
         this.callResolver.setCandidateResolver(candidateResolver);
         this.callResolver.setExpressionTypingServices(expressionTypingServices);
-        this.callResolver.setResolutionResultsHandler(resolutionResultsHandler);
         this.callResolver.setTypeResolver(typeResolver);
 
         annotationResolver.setCallResolver(callResolver);
@@ -89,8 +82,6 @@ public class InjectorForTests {
         candidateResolver.setExpressionTypingServices(expressionTypingServices);
         candidateResolver.setTypeResolver(typeResolver);
 
-        resolutionResultsHandler.setOverloadingConflictResolver(overloadingConflictResolver);
-
     }
 
     @PreDestroy

js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java

@@ -37,8 +37,6 @@ import org.jetbrains.jet.lang.resolve.calls.CandidateResolver;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import org.jetbrains.jet.lang.resolve.TypeResolver;
 import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver;
-import org.jetbrains.jet.lang.resolve.calls.results.ResolutionResultsHandler;
-import org.jetbrains.jet.lang.resolve.calls.results.OverloadingConflictResolver;
 import org.jetbrains.jet.lang.resolve.ImportsResolver;
 import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver;
 import org.jetbrains.jet.lang.resolve.OverloadResolver;
@@ -71,8 +69,6 @@ public class InjectorForTopDownAnalyzerForJs {
     private ExpressionTypingServices expressionTypingServices;
     private TypeResolver typeResolver;
     private QualifiedExpressionResolver qualifiedExpressionResolver;
-    private ResolutionResultsHandler resolutionResultsHandler;
-    private OverloadingConflictResolver overloadingConflictResolver;
     private ImportsResolver importsResolver;
     private ScriptHeaderResolver scriptHeaderResolver;
     private OverloadResolver overloadResolver;
@@ -107,8 +103,6 @@ public class InjectorForTopDownAnalyzerForJs {
         this.expressionTypingServices = new ExpressionTypingServices();
         this.typeResolver = new TypeResolver();
         this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
-        this.resolutionResultsHandler = new ResolutionResultsHandler();
-        this.overloadingConflictResolver = new OverloadingConflictResolver();
         this.importsResolver = new ImportsResolver();
         this.scriptHeaderResolver = new ScriptHeaderResolver();
         this.overloadResolver = new OverloadResolver();
@@ -164,7 +158,6 @@ public class InjectorForTopDownAnalyzerForJs {
 
         callResolver.setCandidateResolver(candidateResolver);
         callResolver.setExpressionTypingServices(expressionTypingServices);
-        callResolver.setResolutionResultsHandler(resolutionResultsHandler);
         callResolver.setTypeResolver(typeResolver);
 
         candidateResolver.setExpressionTypingServices(expressionTypingServices);
@@ -180,8 +173,6 @@ public class InjectorForTopDownAnalyzerForJs {
         typeResolver.setModuleConfiguration(moduleConfiguration);
         typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
 
-        resolutionResultsHandler.setOverloadingConflictResolver(overloadingConflictResolver);
-
         importsResolver.setConfiguration(moduleConfiguration);
         importsResolver.setContext(topDownAnalysisContext);
         importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);