From 8e595f015e6b137c198685790f6a07a15594b449 Mon Sep 17 00:00:00 2001 From: Simon Ogorodnik Date: Wed, 3 Apr 2019 16:20:57 +0300 Subject: [PATCH] Initial OverloadingConflictResolver abstraction from KotlinTypes --- .../jvm/JvmTypeSpecificityComparator.kt | 19 ++++++----- .../jvm/platform/JvmPlatformConfigurator.kt | 2 +- .../kotlin/resolve/OverloadChecker.kt | 3 +- .../inference/ConstraintSystemBuilderImpl.kt | 17 ++++++++-- .../components/SimpleConstraintSystemImpl.kt | 20 +++++++++--- .../resolve/calls/results/FlatSignature.kt | 32 +++++++++++-------- .../results/OverloadingConflictResolver.kt | 7 +++- .../types/checker/ClassicTypeSystemContext.kt | 22 +++++++++++++ .../kotlin/types/model/TypeSystemContext.kt | 4 +++ .../rename/RenameKotlinClassifierProcessor.kt | 4 +-- .../rename/RenameKotlinFunctionProcessor.kt | 4 +-- .../rename/RenameKotlinParameterProcessor.kt | 4 +-- .../rename/RenameKotlinPropertyProcessor.kt | 6 ++-- .../RenameKotlinTypeParameterProcessor.kt | 4 +-- .../refactoring/rename/renameConflictUtils.kt | 18 +++++------ .../js/resolve/JsPlatformConfigurator.kt | 2 +- .../js/resolve/JsTypeSpecificityComparator.kt | 11 ++++--- 17 files changed, 122 insertions(+), 57 deletions(-) diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmTypeSpecificityComparator.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmTypeSpecificityComparator.kt index 3b7c93c74e3..3c5e357df2b 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmTypeSpecificityComparator.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmTypeSpecificityComparator.kt @@ -16,30 +16,29 @@ package org.jetbrains.kotlin.resolve.jvm -import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.resolve.calls.results.TypeSpecificityComparator -import org.jetbrains.kotlin.types.KotlinType -import org.jetbrains.kotlin.types.asFlexibleType -import org.jetbrains.kotlin.types.isFlexible +import org.jetbrains.kotlin.types.model.KotlinTypeMarker +import org.jetbrains.kotlin.types.model.TypeSystemInferenceExtensionContextDelegate -object JvmTypeSpecificityComparator : TypeSpecificityComparator { +class JvmTypeSpecificityComparator(val context: TypeSystemInferenceExtensionContextDelegate) : TypeSpecificityComparator { - override fun isDefinitelyLessSpecific(specific: KotlinType, general: KotlinType): Boolean { - if (!specific.isFlexible() || general.isFlexible()) return false + override fun isDefinitelyLessSpecific(specific: KotlinTypeMarker, general: KotlinTypeMarker): Boolean = with(context) { + val simpleGeneral = general.asSimpleType() + if (!specific.isFlexible() || simpleGeneral == null) return false // general is inflexible - val flexibility = specific.asFlexibleType() + val flexibility = specific.asFlexibleType()!! // For primitive types we have to take care of the case when there are two overloaded methods like // foo(int) and foo(Integer) // if we do not discriminate one of them, any call to foo(kotlin.Int) will result in overload resolution ambiguity // so, for such cases, we discriminate Integer in favour of int - if (!KotlinBuiltIns.isPrimitiveType(general) || !KotlinBuiltIns.isPrimitiveType(flexibility.lowerBound)) { + if (!simpleGeneral.isPrimitiveType() || !flexibility.lowerBound().isPrimitiveType()) { return false } // Int? >< Int! - if (general.isMarkedNullable) return false + if (simpleGeneral.isMarkedNullable()) return false // Int! lessSpecific Int return true } diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmPlatformConfigurator.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmPlatformConfigurator.kt index 552b00ddfa0..1753e43bc6e 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmPlatformConfigurator.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmPlatformConfigurator.kt @@ -96,7 +96,7 @@ object JvmPlatformConfigurator : PlatformConfiguratorBase( container.useImpl() container.useImpl() container.useImpl() - container.useInstance(JvmTypeSpecificityComparator) + container.useImpl() container.useImpl() container.useImpl() container.useInstance(FunctionWithBigAritySupport.LANGUAGE_VERSION_DEPENDENT) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadChecker.kt index d6671e13bdc..5eefdf8e03b 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadChecker.kt @@ -27,9 +27,10 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.isExtensionProperty import org.jetbrains.kotlin.resolve.descriptorUtil.varargParameterPosition import org.jetbrains.kotlin.types.ErrorUtils import org.jetbrains.kotlin.types.KotlinType +import org.jetbrains.kotlin.types.model.KotlinTypeMarker object OverloadabilitySpecificityCallbacks : SpecificityComparisonCallbacks { - override fun isNonSubtypeNotLessSpecific(specific: KotlinType, general: KotlinType): Boolean = + override fun isNonSubtypeNotLessSpecific(specific: KotlinTypeMarker, general: KotlinTypeMarker): Boolean = false } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintSystemBuilderImpl.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintSystemBuilderImpl.kt index 99ac54beabb..154fc6d8b9f 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintSystemBuilderImpl.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintSystemBuilderImpl.kt @@ -34,11 +34,17 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.hasExactAnnotation import org.jetbrains.kotlin.resolve.descriptorUtil.hasNoInferAnnotation import org.jetbrains.kotlin.types.* import org.jetbrains.kotlin.types.TypeUtils.DONT_CARE +import org.jetbrains.kotlin.types.checker.SimpleClassicTypeSystemContext import org.jetbrains.kotlin.types.checker.TypeCheckingProcedure import org.jetbrains.kotlin.types.checker.TypeCheckingProcedureCallbacks +import org.jetbrains.kotlin.types.checker.requireOrDescribe +import org.jetbrains.kotlin.types.model.KotlinTypeMarker +import org.jetbrains.kotlin.types.model.TypeParameterMarker +import org.jetbrains.kotlin.types.model.TypeSystemInferenceExtensionContext import org.jetbrains.kotlin.types.typeUtil.builtIns import org.jetbrains.kotlin.types.typeUtil.defaultProjections import org.jetbrains.kotlin.types.typeUtil.isDefaultBound +import org.jetbrains.kotlin.utils.addToStdlib.cast import java.lang.IllegalArgumentException import java.lang.IllegalStateException import java.util.* @@ -426,13 +432,18 @@ open class ConstraintSystemBuilderImpl(private val mode: Mode = ConstraintSystem companion object { fun forSpecificity(): SimpleConstraintSystem = object : ConstraintSystemBuilderImpl(Mode.SPECIFICITY), SimpleConstraintSystem { + override val context: TypeSystemInferenceExtensionContext + get() = SimpleClassicTypeSystemContext var counter = 0 - override fun registerTypeVariables(typeParameters: Collection) = - registerTypeVariables(CallHandle.NONE, typeParameters) + override fun registerTypeVariables(typeParameters: Collection) = + registerTypeVariables(CallHandle.NONE, typeParameters.cast()) - override fun addSubtypeConstraint(subType: UnwrappedType, superType: UnwrappedType) = + override fun addSubtypeConstraint(subType: KotlinTypeMarker, superType: KotlinTypeMarker) { + requireOrDescribe(subType is UnwrappedType, subType) + requireOrDescribe(superType is UnwrappedType, superType) addSubtypeConstraint(subType, superType, ConstraintPositionKind.VALUE_PARAMETER_POSITION.position(counter++)) + } override fun hasContradiction(): Boolean { fixVariables() diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/components/SimpleConstraintSystemImpl.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/components/SimpleConstraintSystemImpl.kt index 93c0627ff7a..05da08a5a43 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/components/SimpleConstraintSystemImpl.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/components/SimpleConstraintSystemImpl.kt @@ -25,17 +25,23 @@ import org.jetbrains.kotlin.resolve.calls.inference.model.TypeVariableFromCallab import org.jetbrains.kotlin.resolve.calls.inference.substitute import org.jetbrains.kotlin.resolve.calls.results.SimpleConstraintSystem import org.jetbrains.kotlin.types.TypeConstructorSubstitution +import org.jetbrains.kotlin.types.checker.requireOrDescribe import org.jetbrains.kotlin.types.TypeSubstitutor import org.jetbrains.kotlin.types.UnwrappedType +import org.jetbrains.kotlin.types.model.KotlinTypeMarker +import org.jetbrains.kotlin.types.model.TypeParameterMarker +import org.jetbrains.kotlin.types.model.TypeSystemInferenceExtensionContext import org.jetbrains.kotlin.types.typeUtil.asTypeProjection - class SimpleConstraintSystemImpl(constraintInjector: ConstraintInjector, builtIns: KotlinBuiltIns) : SimpleConstraintSystem { + val system = NewConstraintSystemImpl(constraintInjector, ClassicTypeSystemContextForCS(builtIns)) val csBuilder: ConstraintSystemBuilder = - NewConstraintSystemImpl(constraintInjector, ClassicTypeSystemContextForCS(builtIns)).getBuilder() + system.getBuilder() + + override fun registerTypeVariables(typeParameters: Collection): TypeSubstitutor { - override fun registerTypeVariables(typeParameters: Collection): TypeSubstitutor { val substitutionMap = typeParameters.associate { + requireOrDescribe(it is TypeParameterDescriptor, it) val variable = TypeVariableFromCallableDescriptor(it) csBuilder.registerVariable(variable) @@ -43,6 +49,7 @@ class SimpleConstraintSystemImpl(constraintInjector: ConstraintInjector, builtIn } val substitutor = TypeConstructorSubstitution.createByConstructorsMap(substitutionMap).buildSubstitutor() for (typeParameter in typeParameters) { + requireOrDescribe(typeParameter is TypeParameterDescriptor, typeParameter) for (upperBound in typeParameter.upperBounds) { addSubtypeConstraint(substitutor.substitute(typeParameter.defaultType), substitutor.substitute(upperBound.unwrap())) } @@ -50,7 +57,9 @@ class SimpleConstraintSystemImpl(constraintInjector: ConstraintInjector, builtIn return substitutor } - override fun addSubtypeConstraint(subType: UnwrappedType, superType: UnwrappedType) { + override fun addSubtypeConstraint(subType: KotlinTypeMarker, superType: KotlinTypeMarker) { + require(subType is UnwrappedType) + require(superType is UnwrappedType) csBuilder.addSubtypeConstraint( subType, superType, @@ -61,4 +70,7 @@ class SimpleConstraintSystemImpl(constraintInjector: ConstraintInjector, builtIn override fun hasContradiction() = csBuilder.hasContradiction override val captureFromArgument get() = true + + override val context: TypeSystemInferenceExtensionContext + get() = system } \ No newline at end of file diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/results/FlatSignature.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/results/FlatSignature.kt index a78565f0e6f..c6f7276d24e 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/results/FlatSignature.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/results/FlatSignature.kt @@ -18,30 +18,31 @@ package org.jetbrains.kotlin.resolve.calls.results import org.jetbrains.kotlin.descriptors.CallableDescriptor import org.jetbrains.kotlin.descriptors.MemberDescriptor -import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor import org.jetbrains.kotlin.descriptors.synthetic.SyntheticMemberDescriptor import org.jetbrains.kotlin.resolve.calls.components.hasDefaultValue import org.jetbrains.kotlin.types.* -import org.jetbrains.kotlin.types.checker.KotlinTypeChecker import org.jetbrains.kotlin.types.checker.captureFromExpression +import org.jetbrains.kotlin.types.model.KotlinTypeMarker +import org.jetbrains.kotlin.types.model.TypeParameterMarker +import org.jetbrains.kotlin.types.model.TypeSystemInferenceExtensionContext interface SpecificityComparisonCallbacks { - fun isNonSubtypeNotLessSpecific(specific: KotlinType, general: KotlinType): Boolean + fun isNonSubtypeNotLessSpecific(specific: KotlinTypeMarker, general: KotlinTypeMarker): Boolean } interface TypeSpecificityComparator { - fun isDefinitelyLessSpecific(specific: KotlinType, general: KotlinType): Boolean + fun isDefinitelyLessSpecific(specific: KotlinTypeMarker, general: KotlinTypeMarker): Boolean object NONE : TypeSpecificityComparator { - override fun isDefinitelyLessSpecific(specific: KotlinType, general: KotlinType) = false + override fun isDefinitelyLessSpecific(specific: KotlinTypeMarker, general: KotlinTypeMarker) = false } } -class FlatSignature private constructor( +class FlatSignature constructor( val origin: T, - val typeParameters: Collection, - val valueParameterTypes: List, + val typeParameters: Collection, + val valueParameterTypes: List, val hasExtensionReceiver: Boolean, val hasVarargs: Boolean, val numDefaults: Int, @@ -113,12 +114,14 @@ class FlatSignature private constructor( interface SimpleConstraintSystem { - fun registerTypeVariables(typeParameters: Collection): TypeSubstitutor - fun addSubtypeConstraint(subType: UnwrappedType, superType: UnwrappedType) + fun registerTypeVariables(typeParameters: Collection): TypeSubstitutor + fun addSubtypeConstraint(subType: KotlinTypeMarker, superType: KotlinTypeMarker) fun hasContradiction(): Boolean // todo hack for migration val captureFromArgument get() = false + + val context: TypeSystemInferenceExtensionContext } fun SimpleConstraintSystem.isSignatureNotLessSpecific( @@ -131,7 +134,6 @@ fun SimpleConstraintSystem.isSignatureNotLessSpecific( if (specific.valueParameterTypes.size != general.valueParameterTypes.size) return false val typeParameters = general.typeParameters - val typeSubstitutor = registerTypeVariables(typeParameters) for ((specificType, generalType) in specific.valueParameterTypes.zip(general.valueParameterTypes)) { if (specificType == null || generalType == null) continue @@ -140,13 +142,17 @@ fun SimpleConstraintSystem.isSignatureNotLessSpecific( return false } - if (typeParameters.isEmpty() || !TypeUtils.dependsOnTypeParameters(generalType, typeParameters)) { - if (!KotlinTypeChecker.DEFAULT.isSubtypeOf(specificType, generalType)) { + if (typeParameters.isEmpty() /*|| !TypeUtils.dependsOnTypeParameters(generalType, typeParameters)*/) { + if (!AbstractTypeChecker.isSubtypeOf(context, specificType, generalType)) { if (!callbacks.isNonSubtypeNotLessSpecific(specificType, generalType)) { return false } } } else { + val typeSubstitutor = registerTypeVariables(typeParameters) + require(generalType is KotlinType) { TODO("not supported") } + require(specificType is KotlinType) { TODO("not supported") } + val substitutedGeneralType = typeSubstitutor.safeSubstitute(generalType, Variance.INVARIANT) /** diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/results/OverloadingConflictResolver.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/results/OverloadingConflictResolver.kt index 962d5b04cd5..2b6a3323172 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/results/OverloadingConflictResolver.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/results/OverloadingConflictResolver.kt @@ -28,6 +28,8 @@ import org.jetbrains.kotlin.resolve.calls.context.CheckArgumentTypesMode import org.jetbrains.kotlin.resolve.descriptorUtil.varargParameterPosition import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.types.TypeUtils +import org.jetbrains.kotlin.types.checker.requireOrDescribe +import org.jetbrains.kotlin.types.model.KotlinTypeMarker import java.util.* open class OverloadingConflictResolver( @@ -284,7 +286,10 @@ open class OverloadingConflictResolver( } private val SpecificityComparisonWithNumerics = object : SpecificityComparisonCallbacks { - override fun isNonSubtypeNotLessSpecific(specific: KotlinType, general: KotlinType): Boolean { + override fun isNonSubtypeNotLessSpecific(specific: KotlinTypeMarker, general: KotlinTypeMarker): Boolean { + requireOrDescribe(specific is KotlinType, specific) + requireOrDescribe(general is KotlinType, general) + val _double = builtIns.doubleType val _float = builtIns.floatType diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/checker/ClassicTypeSystemContext.kt b/core/descriptors/src/org/jetbrains/kotlin/types/checker/ClassicTypeSystemContext.kt index 5bbd893ee37..3341a6187d0 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/types/checker/ClassicTypeSystemContext.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/types/checker/ClassicTypeSystemContext.kt @@ -21,6 +21,8 @@ import org.jetbrains.kotlin.types.model.CaptureStatus import org.jetbrains.kotlin.types.typeUtil.asTypeProjection import org.jetbrains.kotlin.types.typeUtil.contains import kotlin.math.max +import kotlin.contracts.ExperimentalContracts +import kotlin.contracts.contract interface ClassicTypeSystemContext : TypeSystemInferenceExtensionContext { override fun TypeConstructorMarker.isDenotable(): Boolean { @@ -463,6 +465,11 @@ interface ClassicTypeSystemContext : TypeSystemInferenceExtensionContext { require(this is IntegerLiteralTypeConstructor, this::errorMessage) return this.getApproximatedType().unwrap() } + + override fun SimpleTypeMarker.isPrimitiveType(): Boolean { + require(this is KotlinType, this::errorMessage) + return KotlinBuiltIns.isPrimitiveType(this) + } } private fun hasNoInferInternal(type: UnwrappedType): Boolean { @@ -520,3 +527,18 @@ fun Variance.convertVariance(): TypeVariance { Variance.OUT_VARIANCE -> TypeVariance.OUT } } + + +@Suppress("EXPERIMENTAL_IS_NOT_ENABLED") +@UseExperimental(ExperimentalContracts::class) +fun requireOrDescribe(condition: Boolean, value: Any?) { + contract { + returns() implies condition + } + require(condition) { + val typeInfo = if (value != null) { + ", type = '${value::class}'" + } else "" + "Unexpected: value = '$value'$typeInfo" + } +} \ No newline at end of file diff --git a/core/type-system/src/org/jetbrains/kotlin/types/model/TypeSystemContext.kt b/core/type-system/src/org/jetbrains/kotlin/types/model/TypeSystemContext.kt index 4c68611eefb..9475d4e4740 100644 --- a/core/type-system/src/org/jetbrains/kotlin/types/model/TypeSystemContext.kt +++ b/core/type-system/src/org/jetbrains/kotlin/types/model/TypeSystemContext.kt @@ -199,6 +199,8 @@ interface TypeSystemContext : TypeSystemOptimizationContext { fun KotlinTypeMarker.lowerBoundIfFlexible(): SimpleTypeMarker = this.asFlexibleType()?.lowerBound() ?: this.asSimpleType()!! fun KotlinTypeMarker.upperBoundIfFlexible(): SimpleTypeMarker = this.asFlexibleType()?.upperBound() ?: this.asSimpleType()!! + fun KotlinTypeMarker.isFlexible(): Boolean = asFlexibleType() != null + fun KotlinTypeMarker.isDynamic(): Boolean = asFlexibleType()?.asDynamicType() != null fun KotlinTypeMarker.isDefinitelyNotNullType(): Boolean = asSimpleType()?.asDefinitelyNotNullType() != null @@ -261,6 +263,8 @@ interface TypeSystemContext : TypeSystemOptimizationContext { fun KotlinTypeMarker.isSimpleType() = asSimpleType() != null fun prepareType(type: KotlinTypeMarker): KotlinTypeMarker + + fun SimpleTypeMarker.isPrimitiveType(): Boolean } enum class CaptureStatus { diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinClassifierProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinClassifierProcessor.kt index 77b382838d7..20de93ca465 100644 --- a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinClassifierProcessor.kt +++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinClassifierProcessor.kt @@ -29,6 +29,7 @@ import org.jetbrains.kotlin.asJava.classes.KtLightClassForSourceDeclaration import org.jetbrains.kotlin.asJava.namedUnwrappedElement import org.jetbrains.kotlin.descriptors.ClassifierDescriptor import org.jetbrains.kotlin.idea.caches.resolve.analyze +import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade import org.jetbrains.kotlin.idea.caches.resolve.unsafeResolveToDescriptor import org.jetbrains.kotlin.idea.refactoring.withExpectedActuals import org.jetbrains.kotlin.idea.references.KtSimpleNameReference @@ -98,10 +99,9 @@ class RenameKotlinClassifierProcessor : RenameKotlinPsiProcessor() { result: MutableList ) { val declaration = element.namedUnwrappedElement as? KtNamedDeclaration ?: return - val descriptor = declaration.unsafeResolveToDescriptor() as ClassifierDescriptor val collisions = SmartList() - checkRedeclarations(descriptor, newName, collisions) + checkRedeclarations(declaration, newName, collisions) checkOriginalUsagesRetargeting(declaration, newName, result, collisions) checkNewNameUsagesRetargeting(declaration, newName, collisions) result += collisions diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinFunctionProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinFunctionProcessor.kt index 405d53cf815..3540e8350d1 100644 --- a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinFunctionProcessor.kt +++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinFunctionProcessor.kt @@ -39,6 +39,7 @@ import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper.InternalNameMapper.de import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper.InternalNameMapper.getModuleNameSuffix import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper.InternalNameMapper.mangleInternalName import org.jetbrains.kotlin.descriptors.FunctionDescriptor +import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade import org.jetbrains.kotlin.idea.caches.resolve.unsafeResolveToDescriptor import org.jetbrains.kotlin.idea.refactoring.Pass import org.jetbrains.kotlin.idea.refactoring.checkSuperMethods @@ -96,10 +97,9 @@ class RenameKotlinFunctionProcessor : RenameKotlinPsiProcessor() { result: MutableList ) { val declaration = element.unwrapped as? KtNamedFunction ?: return - val descriptor = declaration.unsafeResolveToDescriptor() checkConflictsAndReplaceUsageInfos(element, allRenames, result) result += SmartList().also { collisions -> - checkRedeclarations(descriptor, newName, collisions) + checkRedeclarations(declaration, newName, collisions) checkOriginalUsagesRetargeting(declaration, newName, result, collisions) checkNewNameUsagesRetargeting(declaration, newName, collisions) } diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinParameterProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinParameterProcessor.kt index 9dcfe817b15..038f7ea5b4b 100644 --- a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinParameterProcessor.kt +++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinParameterProcessor.kt @@ -22,6 +22,7 @@ import com.intellij.refactoring.listeners.RefactoringElementListener import com.intellij.usageView.UsageInfo import org.jetbrains.kotlin.asJava.namedUnwrappedElement import org.jetbrains.kotlin.descriptors.VariableDescriptor +import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade import org.jetbrains.kotlin.idea.caches.resolve.unsafeResolveToDescriptor import org.jetbrains.kotlin.psi.KtFunction import org.jetbrains.kotlin.psi.KtNamedDeclaration @@ -44,10 +45,9 @@ class RenameKotlinParameterProcessor : RenameKotlinPsiProcessor() { result: MutableList ) { val declaration = element.namedUnwrappedElement as? KtNamedDeclaration ?: return - val descriptor = declaration.unsafeResolveToDescriptor() as VariableDescriptor val collisions = SmartList() - checkRedeclarations(descriptor, newName, collisions) + checkRedeclarations(declaration, newName, collisions) checkOriginalUsagesRetargeting(declaration, newName, result, collisions) checkNewNameUsagesRetargeting(declaration, newName, collisions) result += collisions diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinPropertyProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinPropertyProcessor.kt index c1838b062e8..d3490978a19 100644 --- a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinPropertyProcessor.kt +++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinPropertyProcessor.kt @@ -44,6 +44,7 @@ import org.jetbrains.kotlin.descriptors.PropertyDescriptor import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor import org.jetbrains.kotlin.descriptors.VariableDescriptor import org.jetbrains.kotlin.idea.caches.resolve.analyze +import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade import org.jetbrains.kotlin.idea.caches.resolve.unsafeResolveToDescriptor import org.jetbrains.kotlin.idea.core.getDeepestSuperDeclarations import org.jetbrains.kotlin.idea.core.isEnumCompanionPropertyWithEntryConflict @@ -204,10 +205,11 @@ class RenameKotlinPropertyProcessor : RenameKotlinPsiProcessor() { result: MutableList ) { val declaration = element.namedUnwrappedElement as? KtNamedDeclaration ?: return - val descriptor = declaration.unsafeResolveToDescriptor() as VariableDescriptor + val resolutionFacade = declaration.getResolutionFacade() + val descriptor = declaration.unsafeResolveToDescriptor(resolutionFacade) as VariableDescriptor val collisions = SmartList() - checkRedeclarations(descriptor, newName, collisions) + checkRedeclarations(declaration, newName, collisions, resolutionFacade, descriptor) checkAccidentalOverrides(declaration, newName, descriptor, collisions) checkOriginalUsagesRetargeting(declaration, newName, result, collisions) checkNewNameUsagesRetargeting(declaration, newName, collisions) diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinTypeParameterProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinTypeParameterProcessor.kt index 86ef29c83a1..4c077fb9bff 100644 --- a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinTypeParameterProcessor.kt +++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinTypeParameterProcessor.kt @@ -18,6 +18,7 @@ package org.jetbrains.kotlin.idea.refactoring.rename import com.intellij.psi.PsiElement import com.intellij.usageView.UsageInfo +import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade import org.jetbrains.kotlin.idea.caches.resolve.unsafeResolveToDescriptor import org.jetbrains.kotlin.psi.KtTypeParameter @@ -31,7 +32,6 @@ class RenameKotlinTypeParameterProcessor : RenameKotlinPsiProcessor() { result: MutableList ) { val declaration = element as? KtTypeParameter ?: return - val descriptor = declaration.unsafeResolveToDescriptor() - checkRedeclarations(descriptor, newName, result) + checkRedeclarations(declaration, newName, result) } } \ No newline at end of file diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/renameConflictUtils.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/renameConflictUtils.kt index f8c7b6e961f..1749932fa9a 100644 --- a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/renameConflictUtils.kt +++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/renameConflictUtils.kt @@ -24,6 +24,7 @@ import com.intellij.usageView.UsageViewUtil import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.idea.analysis.analyzeInContext import org.jetbrains.kotlin.idea.caches.resolve.analyze +import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade import org.jetbrains.kotlin.idea.caches.resolve.unsafeResolveToDescriptor import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde import org.jetbrains.kotlin.idea.core.NewDeclarationNameValidator @@ -33,6 +34,7 @@ import org.jetbrains.kotlin.idea.project.TargetPlatformDetector import org.jetbrains.kotlin.idea.refactoring.explicateAsText import org.jetbrains.kotlin.idea.refactoring.getThisLabelName import org.jetbrains.kotlin.idea.references.mainReference +import org.jetbrains.kotlin.idea.resolve.ResolutionFacade import org.jetbrains.kotlin.idea.search.and import org.jetbrains.kotlin.idea.search.restrictToKotlinSources import org.jetbrains.kotlin.idea.util.* @@ -53,6 +55,7 @@ import org.jetbrains.kotlin.resolve.calls.resolvedCallUtil.getExplicitReceiverVa import org.jetbrains.kotlin.resolve.calls.resolvedCallUtil.getImplicitReceiverValue import org.jetbrains.kotlin.resolve.calls.results.TypeSpecificityComparator import org.jetbrains.kotlin.resolve.descriptorUtil.getImportableDescriptor +import org.jetbrains.kotlin.resolve.descriptorUtil.module import org.jetbrains.kotlin.resolve.jvm.JvmTypeSpecificityComparator import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode @@ -88,9 +91,11 @@ internal fun PsiElement.representativeContainer(): PsiNamedElement? = internal fun DeclarationDescriptor.canonicalRender(): String = DescriptorRenderer.FQ_NAMES_IN_TYPES.render(this) internal fun checkRedeclarations( - descriptor: DeclarationDescriptor, - newName: String, - result: MutableList + declaration: KtNamedDeclaration, + newName: String, + result: MutableList, + resolutionFacade: ResolutionFacade = declaration.getResolutionFacade(), + descriptor: DeclarationDescriptor = declaration.unsafeResolveToDescriptor(resolutionFacade) ) { fun DeclarationDescriptor.isTopLevelPrivate(): Boolean { return this is DeclarationDescriptorWithVisibility @@ -165,12 +170,7 @@ internal fun checkRedeclarations( is PropertyDescriptor, is FunctionDescriptor, is ClassifierDescriptor -> { - val psi = (descriptor as? DeclarationDescriptorWithSource)?.source?.getPsi() as? KtElement ?: return - val typeSpecificityComparator = when (TargetPlatformDetector.getPlatform(psi.containingKtFile)) { - is JvmPlatform -> JvmTypeSpecificityComparator - is JsPlatform -> JsTypeSpecificityComparator - else -> TypeSpecificityComparator.NONE - } + val typeSpecificityComparator = resolutionFacade.getFrontendService(descriptor.module, TypeSpecificityComparator::class.java) OverloadChecker(typeSpecificityComparator) } else -> null diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/JsPlatformConfigurator.kt b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/JsPlatformConfigurator.kt index 7a39184cc66..e339dce9da3 100644 --- a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/JsPlatformConfigurator.kt +++ b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/JsPlatformConfigurator.kt @@ -64,7 +64,7 @@ object JsPlatformConfigurator : PlatformConfiguratorBase( container.useImpl() container.useInstance(SyntheticScopes.Empty) container.useInstance(SamConversionTransformer.Empty) - container.useInstance(JsTypeSpecificityComparator) + container.useImpl() container.useImpl() container.useImpl() container.useImpl() diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/JsTypeSpecificityComparator.kt b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/JsTypeSpecificityComparator.kt index e70c3663237..f0affe5f169 100644 --- a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/JsTypeSpecificityComparator.kt +++ b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/JsTypeSpecificityComparator.kt @@ -20,18 +20,21 @@ import org.jetbrains.kotlin.resolve.calls.results.TypeSpecificityComparator import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.types.isDynamic import org.jetbrains.kotlin.types.isFlexible +import org.jetbrains.kotlin.types.model.KotlinTypeMarker +import org.jetbrains.kotlin.types.model.TypeSystemInferenceExtensionContext +import org.jetbrains.kotlin.types.model.TypeSystemInferenceExtensionContextDelegate -object JsTypeSpecificityComparator: TypeSpecificityComparator { +class JsTypeSpecificityComparator(val context: TypeSystemInferenceExtensionContextDelegate) : TypeSpecificityComparator { - private fun checkOnlyDynamicFlexibleType(type: KotlinType) { - if (type.isFlexible()) { + private fun TypeSystemInferenceExtensionContext.checkOnlyDynamicFlexibleType(type: KotlinTypeMarker) { + if (type.asFlexibleType() != null) { assert(type.isDynamic()) { "Unexpected flexible type in Js: $type" } } } - override fun isDefinitelyLessSpecific(specific: KotlinType, general: KotlinType): Boolean { + override fun isDefinitelyLessSpecific(specific: KotlinTypeMarker, general: KotlinTypeMarker): Boolean = with(context) { checkOnlyDynamicFlexibleType(specific) checkOnlyDynamicFlexibleType(general)