Transform OverloadUtil into OverloadChecker component.

compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java

@@ -69,6 +69,7 @@ public class BodyResolver {
     @NotNull private final ValueParameterResolver valueParameterResolver;
     @NotNull private final BodyResolveCache bodyResolveCache;
     @NotNull private final KotlinBuiltIns builtIns;
+    @NotNull private final OverloadChecker overloadChecker;
 
     public BodyResolver(
             @NotNull AnnotationResolver annotationResolver,
@@ -82,7 +83,8 @@ public class BodyResolver {
             @NotNull BindingTrace trace,
             @NotNull ValueParameterResolver valueParameterResolver,
             @NotNull AnnotationChecker annotationChecker,
-            @NotNull KotlinBuiltIns builtIns
+            @NotNull KotlinBuiltIns builtIns,
+            @NotNull OverloadChecker overloadChecker
     ) {
         this.annotationResolver = annotationResolver;
         this.bodyResolveCache = bodyResolveCache;
@@ -93,6 +95,7 @@ public class BodyResolver {
         this.expressionTypingServices = expressionTypingServices;
         this.functionAnalyzerExtension = functionAnalyzerExtension;
         this.annotationChecker = annotationChecker;
+        this.overloadChecker = overloadChecker;
         this.trace = new ObservableBindingTrace(trace);
         this.valueParameterResolver = valueParameterResolver;
         this.builtIns = builtIns;
@@ -259,7 +262,7 @@ public class BodyResolver {
         final LexicalScope scopeForConstructor =
                 primaryConstructor == null
                 ? null
-                : FunctionDescriptorUtil.getFunctionInnerScope(scopeForConstructorResolution, primaryConstructor, trace);
+                : FunctionDescriptorUtil.getFunctionInnerScope(scopeForConstructorResolution, primaryConstructor, trace, overloadChecker);
         final ExpressionTypingServices typeInferrer = expressionTypingServices; // TODO : flow
 
         final Map<KtTypeReference, KotlinType> supertypes = Maps.newLinkedHashMap();
@@ -778,7 +781,7 @@ public class BodyResolver {
             @Nullable Function1<LexicalScope, LexicalScope> headerScopeFactory
     ) {
         PreliminaryDeclarationVisitor.Companion.createForDeclaration(function, trace);
-        LexicalScope innerScope = FunctionDescriptorUtil.getFunctionInnerScope(scope, functionDescriptor, trace);
+        LexicalScope innerScope = FunctionDescriptorUtil.getFunctionInnerScope(scope, functionDescriptor, trace, overloadChecker);
         List<KtParameter> valueParameters = function.getValueParameters();
         List<ValueParameterDescriptor> valueParameterDescriptors = functionDescriptor.getValueParameters();
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java

@@ -76,6 +76,7 @@ public class DescriptorResolver {
     @NotNull private final SupertypeLoopChecker supertypeLoopsResolver;
     @NotNull private final VariableTypeResolver variableTypeResolver;
     @NotNull private final ExpressionTypingServices expressionTypingServices;
+    @NotNull private final OverloadChecker overloadChecker;
 
     public DescriptorResolver(
             @NotNull AnnotationResolver annotationResolver,
@@ -84,7 +85,8 @@ public class DescriptorResolver {
             @NotNull TypeResolver typeResolver,
             @NotNull SupertypeLoopChecker supertypeLoopsResolver,
             @NotNull VariableTypeResolver variableTypeResolver,
-            @NotNull ExpressionTypingServices expressionTypingServices
+            @NotNull ExpressionTypingServices expressionTypingServices,
+            @NotNull OverloadChecker overloadChecker
     ) {
         this.annotationResolver = annotationResolver;
         this.builtIns = builtIns;
@@ -93,6 +95,7 @@ public class DescriptorResolver {
         this.supertypeLoopsResolver = supertypeLoopsResolver;
         this.variableTypeResolver = variableTypeResolver;
         this.expressionTypingServices = expressionTypingServices;
+        this.overloadChecker = overloadChecker;
     }
 
     public List<KotlinType> resolveSupertypes(
@@ -722,7 +725,7 @@ public class DescriptorResolver {
             }
             else {
                 LexicalWritableScope writableScope = new LexicalWritableScope(
-                        scope, containingDeclaration, false, null, new TraceBasedLocalRedeclarationChecker(trace),
+                        scope, containingDeclaration, false, null, new TraceBasedLocalRedeclarationChecker(trace, overloadChecker),
                         LexicalScopeKind.PROPERTY_HEADER);
                 typeParameterDescriptors = resolveTypeParametersForCallableDescriptor(
                         propertyDescriptor, writableScope, scope, typeParameters, trace);

compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt

@@ -61,7 +61,8 @@ class FunctionDescriptorResolver(
         private val storageManager: StorageManager,
         private val expressionTypingServices: ExpressionTypingServices,
         private val builtIns: KotlinBuiltIns,
-        private val modifiersChecker: ModifiersChecker
+        private val modifiersChecker: ModifiersChecker,
+        private val overloadChecker: OverloadChecker
 ) {
     fun resolveFunctionDescriptor(
             containingDescriptor: DeclarationDescriptor,
@@ -142,7 +143,7 @@ class FunctionDescriptorResolver(
             expectedFunctionType: KotlinType
     ) {
         val innerScope = LexicalWritableScope(scope, functionDescriptor, true, null,
-                                              TraceBasedLocalRedeclarationChecker(trace), LexicalScopeKind.FUNCTION_HEADER)
+                                              TraceBasedLocalRedeclarationChecker(trace, overloadChecker), LexicalScopeKind.FUNCTION_HEADER)
 
         val typeParameterDescriptors = descriptorResolver.
                 resolveTypeParametersForCallableDescriptor(functionDescriptor, innerScope, scope, function.typeParameters, trace)
@@ -285,7 +286,7 @@ class FunctionDescriptorResolver(
                 scope,
                 constructorDescriptor,
                 false, null,
-                TraceBasedLocalRedeclarationChecker(trace),
+                TraceBasedLocalRedeclarationChecker(trace, overloadChecker),
                 LexicalScopeKind.CONSTRUCTOR_HEADER
         )
         val constructor = constructorDescriptor.initialize(

compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorUtil.java

@@ -53,9 +53,10 @@ public class FunctionDescriptorUtil {
 
     @NotNull
     public static LexicalScope getFunctionInnerScope(
-            @NotNull LexicalScope outerScope, @NotNull FunctionDescriptor descriptor, @NotNull BindingTrace trace
+            @NotNull LexicalScope outerScope, @NotNull FunctionDescriptor descriptor,
+            @NotNull BindingTrace trace, @NotNull OverloadChecker overloadChecker
     ) {
-        return getFunctionInnerScope(outerScope, descriptor, new TraceBasedLocalRedeclarationChecker(trace));
+        return getFunctionInnerScope(outerScope, descriptor, new TraceBasedLocalRedeclarationChecker(trace, overloadChecker));
     }
 
     @NotNull

compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadChecker.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2015 JetBrains s.r.o.
+ * Copyright 2010-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.
@@ -31,11 +31,11 @@ import org.jetbrains.kotlin.types.ErrorUtils
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.utils.singletonOrEmptyList
 
-object OverloadUtil {
+class OverloadChecker {
     /**
      * Does not check names.
      */
-    @JvmStatic fun isOverloadable(a: DeclarationDescriptor, b: DeclarationDescriptor): Boolean {
+    fun isOverloadable(a: DeclarationDescriptor, b: DeclarationDescriptor): Boolean {
         val aCategory = getDeclarationCategory(a)
         val bCategory = getDeclarationCategory(b)
 
@@ -96,7 +96,7 @@ object OverloadUtil {
                     error("Unexpected declaration kind: $a")
             }
 
-    @JvmStatic fun groupModulePackageMembersByFqName(
+    fun groupModulePackageMembersByFqName(
             c: BodiesResolveContext,
             overloadFilter: OverloadFilter
     ): MultiMap<FqNameUnsafe, DeclarationDescriptorNonRoot> {
@@ -172,7 +172,7 @@ object OverloadUtil {
             this is DeclarationDescriptorWithVisibility &&
             Visibilities.isPrivate(this.visibility)
 
-    @JvmStatic fun getPossibleRedeclarationGroups(
+    fun getPossibleRedeclarationGroups(
             members: Collection<DeclarationDescriptorNonRoot>
     ): Collection<Collection<DeclarationDescriptorNonRoot>> {
         val result = arrayListOf<Collection<DeclarationDescriptorNonRoot>>()

compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadResolver.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2015 JetBrains s.r.o.
+ * Copyright 2010-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.
@@ -26,7 +26,9 @@ import org.jetbrains.kotlin.utils.addToStdlib.check
 
 class OverloadResolver(
         private val trace: BindingTrace,
-        private val overloadFilter: OverloadFilter) {
+        private val overloadFilter: OverloadFilter,
+        private val overloadChecker: OverloadChecker
+) {
 
     fun checkOverloads(c: BodiesResolveContext) {
         val inClasses = findConstructorsInNestedClasses(c)
@@ -63,7 +65,7 @@ class OverloadResolver(
     }
 
     private fun checkOverloadsInPackages(c: BodiesResolveContext) {
-        val membersByName = OverloadUtil.groupModulePackageMembersByFqName(c, overloadFilter)
+        val membersByName = overloadChecker.groupModulePackageMembersByFqName(c, overloadFilter)
 
         for (e in membersByName.entrySet()) {
             checkOverloadsInPackage(e.value)
@@ -91,7 +93,7 @@ class OverloadResolver(
 
     private fun checkOverloadsInPackage(members: Collection<DeclarationDescriptorNonRoot>) {
         if (members.size == 1) return
-        for (redeclarationGroup in OverloadUtil.getPossibleRedeclarationGroups(members)) {
+        for (redeclarationGroup in overloadChecker.getPossibleRedeclarationGroups(members)) {
             reportRedeclarations(findRedeclarations(redeclarationGroup))
         }
     }
@@ -114,7 +116,7 @@ class OverloadResolver(
                 if (isConstructorsOfDifferentRedeclaredClasses(member1, member2)) continue
                 if (isTopLevelMainInDifferentFiles(member1, member2)) continue
 
-                if (!OverloadUtil.isOverloadable(member1, member2)) {
+                if (!overloadChecker.isOverloadable(member1, member2)) {
                     val ktDeclaration = DescriptorToSourceUtils.descriptorToDeclaration(member1) as KtDeclaration?
                     redeclarations.add(ktDeclaration to member1)
                 }

compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/LocalRedeclarationChecker.kt

@@ -22,10 +22,10 @@ import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.resolve.OverloadUtil
+import org.jetbrains.kotlin.resolve.OverloadChecker
 
 
-abstract class AbstractLocalRedeclarationChecker : LocalRedeclarationChecker {
+abstract class AbstractLocalRedeclarationChecker(val overloadChecker: OverloadChecker) : LocalRedeclarationChecker {
     override fun checkBeforeAddingToScope(scope: LexicalScope, newDescriptor: DeclarationDescriptor) {
         val name = newDescriptor.name
         val location = NoLookupLocation.WHEN_CHECK_REDECLARATIONS
@@ -47,7 +47,7 @@ abstract class AbstractLocalRedeclarationChecker : LocalRedeclarationChecker {
                             otherFunctions
 
                 for (overloadedDescriptor in potentiallyConflictingOverloads) {
-                    if (!OverloadUtil.isOverloadable(overloadedDescriptor, newDescriptor)) {
+                    if (!overloadChecker.isOverloadable(overloadedDescriptor, newDescriptor)) {
                         handleConflictingOverloads(newDescriptor, overloadedDescriptor)
                         break
                     }
@@ -61,7 +61,7 @@ abstract class AbstractLocalRedeclarationChecker : LocalRedeclarationChecker {
     protected abstract fun handleConflictingOverloads(first: CallableMemberDescriptor, second: CallableMemberDescriptor)
 }
 
-object ThrowingLocalRedeclarationChecker : AbstractLocalRedeclarationChecker() {
+class ThrowingLocalRedeclarationChecker(overloadChecker: OverloadChecker) : AbstractLocalRedeclarationChecker(overloadChecker) {
     override fun handleRedeclaration(first: DeclarationDescriptor, second: DeclarationDescriptor) {
         throw IllegalStateException(String.format("Redeclaration: %s (%s) and %s (%s) (no line info available)",
                                                   DescriptorUtils.getFqName(first), first,
@@ -75,7 +75,7 @@ object ThrowingLocalRedeclarationChecker : AbstractLocalRedeclarationChecker() {
     }
 }
 
-class TraceBasedLocalRedeclarationChecker(val trace: BindingTrace): AbstractLocalRedeclarationChecker() {
+class TraceBasedLocalRedeclarationChecker(val trace: BindingTrace, overloadChecker: OverloadChecker): AbstractLocalRedeclarationChecker(overloadChecker) {
     override fun handleRedeclaration(first: DeclarationDescriptor, second: DeclarationDescriptor) {
         reportRedeclaration(first)
         reportRedeclaration(second)

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java

@@ -1118,11 +1118,12 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
         KotlinTypeInfo leftTypeInfo = getTypeInfoOrNullType(left, context.replaceExpectedType(booleanType), facade);
         DataFlowInfo dataFlowInfo = leftTypeInfo.getDataFlowInfo();
 
-        LexicalWritableScope leftScope = newWritableScopeImpl(context, LexicalScopeKind.LEFT_BOOLEAN_EXPRESSION);
+        LexicalWritableScope leftScope = newWritableScopeImpl(context, LexicalScopeKind.LEFT_BOOLEAN_EXPRESSION, facade.getComponents().overloadChecker);
         // TODO: This gets computed twice: here and in extractDataFlowInfoFromCondition() for the whole condition
         boolean isAnd = operationType == KtTokens.ANDAND;
         DataFlowInfo flowInfoLeft = components.dataFlowAnalyzer.extractDataFlowInfoFromCondition(left, isAnd, context).and(dataFlowInfo);
-        LexicalWritableScope rightScope = isAnd ? leftScope : newWritableScopeImpl(context, LexicalScopeKind.RIGHT_BOOLEAN_EXPRESSION);
+        LexicalWritableScope rightScope = isAnd ? leftScope : newWritableScopeImpl(context, LexicalScopeKind.RIGHT_BOOLEAN_EXPRESSION,
+                                                                                   facade.getComponents().overloadChecker);
 
         ExpressionTypingContext contextForRightExpr =
                 context.replaceDataFlowInfo(flowInfoLeft).replaceScope(rightScope).replaceExpectedType(booleanType);

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java

@@ -41,7 +41,10 @@ import org.jetbrains.kotlin.resolve.scopes.LexicalScopeKind;
 import org.jetbrains.kotlin.resolve.scopes.LexicalWritableScope;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver;
 import org.jetbrains.kotlin.resolve.scopes.receivers.TransientReceiver;
-import org.jetbrains.kotlin.types.*;
+import org.jetbrains.kotlin.types.CommonSupertypes;
+import org.jetbrains.kotlin.types.ErrorUtils;
+import org.jetbrains.kotlin.types.KotlinType;
+import org.jetbrains.kotlin.types.TypeUtils;
 import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils.ResolveConstruct;
 import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryKt;
@@ -97,8 +100,8 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
         KtExpression elseBranch = ifExpression.getElse();
         KtExpression thenBranch = ifExpression.getThen();
 
-        LexicalWritableScope thenScope = newWritableScopeImpl(context, LexicalScopeKind.THEN);
+        LexicalWritableScope thenScope = newWritableScopeImpl(context, LexicalScopeKind.THEN, components.overloadChecker);
-        LexicalWritableScope elseScope = newWritableScopeImpl(context, LexicalScopeKind.ELSE);
+        LexicalWritableScope elseScope = newWritableScopeImpl(context, LexicalScopeKind.ELSE, components.overloadChecker);
         DataFlowInfo thenInfo = components.dataFlowAnalyzer.extractDataFlowInfoFromCondition(condition, true, context).and(conditionDataFlowInfo);
         DataFlowInfo elseInfo = components.dataFlowAnalyzer.extractDataFlowInfoFromCondition(condition, false, context).and(conditionDataFlowInfo);
 
@@ -234,7 +237,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
         KotlinTypeInfo bodyTypeInfo;
         DataFlowInfo conditionInfo = components.dataFlowAnalyzer.extractDataFlowInfoFromCondition(condition, true, context).and(dataFlowInfo);
         if (body != null) {
-            LexicalWritableScope scopeToExtend = newWritableScopeImpl(context, LexicalScopeKind.WHILE_BODY);
+            LexicalWritableScope scopeToExtend = newWritableScopeImpl(context, LexicalScopeKind.WHILE_BODY, components.overloadChecker);
             bodyTypeInfo = components.expressionTypingServices.getBlockReturnedTypeWithWritableScope(
                     scopeToExtend, Collections.singletonList(body),
                     CoercionStrategy.NO_COERCION, context.replaceDataFlowInfo(conditionInfo));
@@ -330,7 +333,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
             bodyTypeInfo = facade.getTypeInfo(body, context.replaceScope(context.scope));
         }
         else if (body != null) {
-            LexicalWritableScope writableScope = newWritableScopeImpl(context, LexicalScopeKind.DO_WHILE_BODY);
+            LexicalWritableScope writableScope = newWritableScopeImpl(context, LexicalScopeKind.DO_WHILE_BODY, components.overloadChecker);
             conditionScope = writableScope;
             List<KtExpression> block;
             if (body instanceof KtBlockExpression) {
@@ -398,7 +401,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
             loopRangeInfo = TypeInfoFactoryKt.noTypeInfo(context);
         }
 
-        LexicalWritableScope loopScope = newWritableScopeImpl(context, LexicalScopeKind.FOR);
+        LexicalWritableScope loopScope = newWritableScopeImpl(context, LexicalScopeKind.FOR, components.overloadChecker);
 
         KtParameter loopParameter = expression.getLoopParameter();
         if (loopParameter != null) {
@@ -497,7 +500,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
                 KotlinType throwableType = components.builtIns.getThrowable().getDefaultType();
                 components.dataFlowAnalyzer.checkType(catchParameterType, catchParameter, context.replaceExpectedType(throwableType));
                 if (catchBody != null) {
-                    LexicalWritableScope catchScope = newWritableScopeImpl(context, LexicalScopeKind.CATCH);
+                    LexicalWritableScope catchScope = newWritableScopeImpl(context, LexicalScopeKind.CATCH, components.overloadChecker);
                     catchScope.addVariableDescriptor(variableDescriptor);
                     KotlinType type = facade.getTypeInfo(catchBody, context.replaceScope(catchScope)).getType();
                     if (type != null) {

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingComponents.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2015 JetBrains s.r.o.
+ * Copyright 2010-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.
@@ -61,6 +61,7 @@ public class ExpressionTypingComponents {
     /*package*/ LocalVariableResolver localVariableResolver;
     /*package*/ LookupTracker lookupTracker;
     /*package*/ DelegatedPropertyResolver delegatedPropertyResolver;
+    /*package*/ OverloadChecker overloadChecker;
 
     @Inject
     public void setGlobalContext(@NotNull GlobalContext globalContext) {
@@ -206,4 +207,9 @@ public class ExpressionTypingComponents {
     public void setDelegatedPropertyResolver(DelegatedPropertyResolver delegatedPropertyResolver) {
         this.delegatedPropertyResolver = delegatedPropertyResolver;
     }
+
+    @Inject
+    public void setOverloadChecker(OverloadChecker overloadChecker) {
+        this.overloadChecker = overloadChecker;
+    }
 }

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingServices.java

@@ -163,8 +163,10 @@ public class ExpressionTypingServices {
         List<KtExpression> block = StatementFilterKt.filterStatements(statementFilter, expression);
 
         DeclarationDescriptor containingDescriptor = context.scope.getOwnerDescriptor();
-        LexicalWritableScope scope = new LexicalWritableScope(context.scope, containingDescriptor, false, null,
+        TraceBasedLocalRedeclarationChecker redeclarationChecker
-                                                              new TraceBasedLocalRedeclarationChecker(context.trace), LexicalScopeKind.CODE_BLOCK);
+                = new TraceBasedLocalRedeclarationChecker(context.trace, expressionTypingComponents.overloadChecker);
+        LexicalWritableScope scope = new LexicalWritableScope(context.scope, containingDescriptor, false, null, redeclarationChecker,
+                                                              LexicalScopeKind.CODE_BLOCK);
 
         KotlinTypeInfo r;
         if (block.isEmpty()) {
@@ -194,7 +196,8 @@ public class ExpressionTypingServices {
     ) {
         KtExpression bodyExpression = function.getBodyExpression();
         assert bodyExpression != null;
-        LexicalScope functionInnerScope = FunctionDescriptorUtil.getFunctionInnerScope(outerScope, functionDescriptor, trace);
+        LexicalScope functionInnerScope = FunctionDescriptorUtil.getFunctionInnerScope(outerScope, functionDescriptor, trace,
+                                                                                       expressionTypingComponents.overloadChecker);
 
         ExpressionTypingContext context = ExpressionTypingContext.newContext(
                 trace, functionInnerScope, dataFlowInfo, NO_EXPECTED_TYPE

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java

@@ -34,6 +34,7 @@ import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils;
 import org.jetbrains.kotlin.resolve.ObservableBindingTrace;
+import org.jetbrains.kotlin.resolve.OverloadChecker;
 import org.jetbrains.kotlin.resolve.scopes.LexicalScope;
 import org.jetbrains.kotlin.resolve.scopes.LexicalScopeKind;
 import org.jetbrains.kotlin.resolve.scopes.LexicalWritableScope;
@@ -80,9 +81,10 @@ public class ExpressionTypingUtils {
     }
 
     @NotNull
-    public static LexicalWritableScope newWritableScopeImpl(ExpressionTypingContext context, @NotNull LexicalScopeKind scopeKind) {
+    public static LexicalWritableScope newWritableScopeImpl(
+            @NotNull ExpressionTypingContext context, @NotNull LexicalScopeKind scopeKind, @NotNull OverloadChecker overloadChecker) {
         return new LexicalWritableScope(context.scope, context.scope.getOwnerDescriptor(), false, null,
-                                        new TraceBasedLocalRedeclarationChecker(context.trace), scopeKind);
+                                        new TraceBasedLocalRedeclarationChecker(context.trace, overloadChecker), scopeKind);
     }
 
     public static KtExpression createFakeExpressionOfType(

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorDispatcher.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2015 JetBrains s.r.o.
+ * Copyright 2010-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.
@@ -158,7 +158,7 @@ public abstract class ExpressionTypingVisitorDispatcher extends KtVisitor<Kotlin
     
     protected ExpressionTypingVisitorForStatements createStatementVisitor(ExpressionTypingContext context) {
         return new ExpressionTypingVisitorForStatements(this,
-                                                        ExpressionTypingUtils.newWritableScopeImpl(context, LexicalScopeKind.CODE_BLOCK),
+                                                        ExpressionTypingUtils.newWritableScopeImpl(context, LexicalScopeKind.CODE_BLOCK, components.overloadChecker),
                                                         basic, controlStructures, patterns, functions);
     }
 

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2015 JetBrains s.r.o.
+ * Copyright 2010-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.
@@ -100,7 +100,7 @@ internal class FunctionsTypingVisitor(facade: ExpressionTypingInternals) : Expre
             ForceResolveUtil.forceResolveAllContents(functionDescriptor.returnType)
         }
         else {
-            val functionInnerScope = FunctionDescriptorUtil.getFunctionInnerScope(context.scope, functionDescriptor, context.trace)
+            val functionInnerScope = FunctionDescriptorUtil.getFunctionInnerScope(context.scope, functionDescriptor, context.trace, components.overloadChecker)
             components.expressionTypingServices.checkFunctionReturnType(
                     functionInnerScope, function, functionDescriptor, context.dataFlowInfo, null, context.trace
             )
@@ -208,7 +208,7 @@ internal class FunctionsTypingVisitor(facade: ExpressionTypingInternals) : Expre
         val functionLiteral = expression.functionLiteral
 
         val expectedType = expectedReturnType ?: NO_EXPECTED_TYPE
-        val functionInnerScope = FunctionDescriptorUtil.getFunctionInnerScope(context.scope, functionDescriptor, context.trace)
+        val functionInnerScope = FunctionDescriptorUtil.getFunctionInnerScope(context.scope, functionDescriptor, context.trace, components.overloadChecker)
         val newContext = context.replaceScope(functionInnerScope).replaceExpectedType(expectedType)
 
         // This is needed for ControlStructureTypingVisitor#visitReturnExpression() to properly type-check returned expressions

compiler/tests/org/jetbrains/kotlin/types/KotlinOverloadTest.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2015 JetBrains s.r.o.
+ * Copyright 2010-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.
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
 import org.jetbrains.kotlin.psi.KtNamedFunction;
 import org.jetbrains.kotlin.psi.KtPsiFactoryKt;
 import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
-import org.jetbrains.kotlin.resolve.OverloadUtil;
+import org.jetbrains.kotlin.resolve.OverloadChecker;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfoFactory;
 import org.jetbrains.kotlin.resolve.scopes.LexicalScope;
 import org.jetbrains.kotlin.test.ConfigurationKind;
@@ -34,6 +34,7 @@ import org.jetbrains.kotlin.tests.di.InjectionKt;
 public class KotlinOverloadTest extends KotlinTestWithEnvironment {
     private final ModuleDescriptor root = KotlinTestUtils.createEmptyModule("<test_root>");
     private FunctionDescriptorResolver functionDescriptorResolver;
+    private final OverloadChecker overloadChecker = new OverloadChecker();
 
     @Override
     protected KotlinCoreEnvironment createEnvironment() {
@@ -154,10 +155,12 @@ public class KotlinOverloadTest extends KotlinTestWithEnvironment {
         FunctionDescriptor a = makeFunction(funA);
         FunctionDescriptor b = makeFunction(funB);
 
-        boolean aOverloadableWithB = OverloadUtil.isOverloadable(a, b);
+
+
+        boolean aOverloadableWithB = overloadChecker.isOverloadable(a, b);
         assertEquals(expectedIsError, !aOverloadableWithB);
 
-        boolean bOverloadableWithA = OverloadUtil.isOverloadable(b, a);
+        boolean bOverloadableWithA = overloadChecker.isOverloadable(b, a);
         assertEquals(expectedIsError, !bOverloadableWithA);
     }
 

compiler/tests/org/jetbrains/kotlin/types/TypeSubstitutorTest.java

@@ -39,10 +39,7 @@ import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.psi.KtPsiFactoryKt;
 import org.jetbrains.kotlin.psi.KtTypeReference;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
-import org.jetbrains.kotlin.resolve.AnalyzingUtils;
+import org.jetbrains.kotlin.resolve.*;
-import org.jetbrains.kotlin.resolve.BindingContext;
-import org.jetbrains.kotlin.resolve.BindingTrace;
-import org.jetbrains.kotlin.resolve.BindingTraceContext;
 import org.jetbrains.kotlin.resolve.lazy.LazyResolveTestUtil;
 import org.jetbrains.kotlin.resolve.scopes.*;
 import org.jetbrains.kotlin.resolve.scopes.utils.ScopeUtilsKt;
@@ -93,8 +90,9 @@ public class TypeSubstitutorTest extends KotlinTestWithEnvironment {
         LexicalScope topLevelScope = trace.get(BindingContext.LEXICAL_SCOPE, jetFile);
         final ClassifierDescriptor contextClass = ScopeUtilsKt.findClassifier(topLevelScope, Name.identifier("___Context"), NoLookupLocation.FROM_TEST);
         assert contextClass instanceof ClassDescriptor;
+        LocalRedeclarationChecker redeclarationChecker = new ThrowingLocalRedeclarationChecker(new OverloadChecker());
         LexicalScope typeParameters = new LexicalScopeImpl(topLevelScope, module, false, null, LexicalScopeKind.SYNTHETIC,
-                                                           ThrowingLocalRedeclarationChecker.INSTANCE,
+                                                           redeclarationChecker,
                                                            new Function1<LexicalScopeImpl.InitializeHandler, Unit>() {
                                                                @Override
                                                                public Unit invoke(LexicalScopeImpl.InitializeHandler handler) {

idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberInfoStorage.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2015 JetBrains s.r.o.
+ * Copyright 2010-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.
@@ -23,17 +23,19 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
+import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
+import org.jetbrains.kotlin.idea.resolve.frontendService
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.resolve.OverloadUtil
+import org.jetbrains.kotlin.resolve.OverloadChecker
 import org.jetbrains.kotlin.resolve.source.getPsi
 import org.jetbrains.kotlin.types.typeUtil.immediateSupertypes
-import java.util.ArrayList
+import java.util.*
 
 class KotlinMemberInfoStorage(
-        classOrObject: PsiNamedElement,
+        classOrObject: KtClassOrObject,
         filter: (KtNamedDeclaration) -> Boolean = { true }
 ): AbstractMemberInfoStorage<KtNamedDeclaration, PsiNamedElement, KotlinMemberInfo>(classOrObject, filter) {
     override fun memberConflict(member1: KtNamedDeclaration, member: KtNamedDeclaration): Boolean {
@@ -43,7 +45,8 @@ class KotlinMemberInfoStorage(
 
         return when {
             descriptor1 is FunctionDescriptor && descriptor is FunctionDescriptor -> {
-                !OverloadUtil.isOverloadable(descriptor1, descriptor)
+                val overloadUtil = member1.getResolutionFacade().frontendService<OverloadChecker>()
+                !overloadUtil.isOverloadable(descriptor1, descriptor)
             }
             descriptor1 is PropertyDescriptor && descriptor is PropertyDescriptor ||
             descriptor1 is ClassDescriptor && descriptor is ClassDescriptor -> true