From 921eb8402ce556f2f07374806aabbc668f2c10d6 Mon Sep 17 00:00:00 2001 From: Stanislav Erokhin Date: Thu, 28 Apr 2016 14:25:53 +0300 Subject: [PATCH] Transform OverloadUtil into OverloadChecker component. --- .../jetbrains/kotlin/resolve/BodyResolver.java | 9 ++++++--- .../kotlin/resolve/DescriptorResolver.java | 7 +++++-- .../resolve/FunctionDescriptorResolver.kt | 7 ++++--- .../kotlin/resolve/FunctionDescriptorUtil.java | 5 +++-- .../{OverloadUtil.kt => OverloadChecker.kt} | 10 +++++----- .../kotlin/resolve/OverloadResolver.kt | 12 +++++++----- .../resolve/scopes/LocalRedeclarationChecker.kt | 10 +++++----- .../BasicExpressionTypingVisitor.java | 5 +++-- .../ControlStructureTypingVisitor.java | 17 ++++++++++------- .../expressions/ExpressionTypingComponents.java | 8 +++++++- .../expressions/ExpressionTypingServices.java | 9 ++++++--- .../expressions/ExpressionTypingUtils.java | 6 ++++-- .../ExpressionTypingVisitorDispatcher.java | 4 ++-- .../types/expressions/FunctionsTypingVisitor.kt | 6 +++--- .../kotlin/types/KotlinOverloadTest.java | 11 +++++++---- .../kotlin/types/TypeSubstitutorTest.java | 8 +++----- .../memberInfo/KotlinMemberInfoStorage.kt | 13 ++++++++----- 17 files changed, 88 insertions(+), 59 deletions(-) rename compiler/frontend/src/org/jetbrains/kotlin/resolve/{OverloadUtil.kt => OverloadChecker.kt} (97%) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java index 8b24914b3af..12843dd8a6e 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java +++ b/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 supertypes = Maps.newLinkedHashMap(); @@ -778,7 +781,7 @@ public class BodyResolver { @Nullable Function1 headerScopeFactory ) { PreliminaryDeclarationVisitor.Companion.createForDeclaration(function, trace); - LexicalScope innerScope = FunctionDescriptorUtil.getFunctionInnerScope(scope, functionDescriptor, trace); + LexicalScope innerScope = FunctionDescriptorUtil.getFunctionInnerScope(scope, functionDescriptor, trace, overloadChecker); List valueParameters = function.getValueParameters(); List valueParameterDescriptors = functionDescriptor.getValueParameters(); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java index e752831c26c..635f2075b1e 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java +++ b/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 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); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt index 8b80e0bf626..0950955213c 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt +++ b/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( diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorUtil.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorUtil.java index 7a73cfd1325..ed75d8a6318 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorUtil.java +++ b/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 diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadChecker.kt similarity index 97% rename from compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadUtil.kt rename to compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadChecker.kt index 7c5e2c53934..8656d331661 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadUtil.kt +++ b/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 { @@ -172,7 +172,7 @@ object OverloadUtil { this is DeclarationDescriptorWithVisibility && Visibilities.isPrivate(this.visibility) - @JvmStatic fun getPossibleRedeclarationGroups( + fun getPossibleRedeclarationGroups( members: Collection ): Collection> { val result = arrayListOf>() diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadResolver.kt index d6d09cb5f68..5b4f1275958 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadResolver.kt +++ b/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) { 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) } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/LocalRedeclarationChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/LocalRedeclarationChecker.kt index c448cb0e7a7..1d008ac3ec2 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/LocalRedeclarationChecker.kt +++ b/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) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java index 881c52253f0..d6716d9e8d6 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java +++ b/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); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java index 4d1a6fe9ab6..df0c33c6063 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java +++ b/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 elseScope = newWritableScopeImpl(context, LexicalScopeKind.ELSE); + LexicalWritableScope thenScope = newWritableScopeImpl(context, LexicalScopeKind.THEN, components.overloadChecker); + 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 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) { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingComponents.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingComponents.java index 5cb2eb7f76f..b5a4eb8bc2f 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingComponents.java +++ b/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; + } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingServices.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingServices.java index f09cf372dce..34d63ce3aad 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingServices.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingServices.java @@ -163,8 +163,10 @@ public class ExpressionTypingServices { List block = StatementFilterKt.filterStatements(statementFilter, expression); DeclarationDescriptor containingDescriptor = context.scope.getOwnerDescriptor(); - LexicalWritableScope scope = new LexicalWritableScope(context.scope, containingDescriptor, false, null, - new TraceBasedLocalRedeclarationChecker(context.trace), LexicalScopeKind.CODE_BLOCK); + TraceBasedLocalRedeclarationChecker redeclarationChecker + = 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 diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java index 4e8366d0038..a4d3b446a34 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java +++ b/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( diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorDispatcher.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorDispatcher.java index 8444ba3ae20..9932e2ed948 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorDispatcher.java +++ b/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"); 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); } diff --git a/compiler/tests/org/jetbrains/kotlin/types/TypeSubstitutorTest.java b/compiler/tests/org/jetbrains/kotlin/types/TypeSubstitutorTest.java index cad636de6b1..a8f41293cbc 100644 --- a/compiler/tests/org/jetbrains/kotlin/types/TypeSubstitutorTest.java +++ b/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.BindingContext; -import org.jetbrains.kotlin.resolve.BindingTrace; -import org.jetbrains.kotlin.resolve.BindingTraceContext; +import org.jetbrains.kotlin.resolve.*; 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() { @Override public Unit invoke(LexicalScopeImpl.InitializeHandler handler) { diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberInfoStorage.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberInfoStorage.kt index 11ee1d57a49..79cc507e518 100644 --- a/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberInfoStorage.kt +++ b/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(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() + !overloadUtil.isOverloadable(descriptor1, descriptor) } descriptor1 is PropertyDescriptor && descriptor is PropertyDescriptor || descriptor1 is ClassDescriptor && descriptor is ClassDescriptor -> true