Move data class-related functions to DataClassDescriptorResolver

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

@@ -0,0 +1,124 @@
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.resolve
+
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.descriptors.annotations.Annotations
+import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl
+import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
+import org.jetbrains.kotlin.name.Name
+
+object DataClassDescriptorResolver {
+    val COPY_METHOD_NAME = Name.identifier("copy")
+
+    private val COMPONENT_FUNCTION_NAME_PREFIX = "component"
+
+    fun createComponentName(index: Int): Name
+            = Name.identifier(COMPONENT_FUNCTION_NAME_PREFIX + index)
+
+    fun getComponentIndex(componentName: String): Int
+            = componentName.substring(COMPONENT_FUNCTION_NAME_PREFIX.length).toInt()
+
+    fun isComponentLike(name: Name): Boolean
+            = isComponentLike(name.asString())
+
+    private fun isComponentLike(name: String): Boolean {
+        if (!name.startsWith(COMPONENT_FUNCTION_NAME_PREFIX)) return false
+
+        try {
+            getComponentIndex(name)
+        }
+        catch (e: NumberFormatException) {
+            return false
+        }
+
+        return true
+    }
+
+    fun createComponentFunctionDescriptor(
+            parameterIndex: Int,
+            property: PropertyDescriptor,
+            parameter: ValueParameterDescriptor,
+            classDescriptor: ClassDescriptor,
+            trace: BindingTrace
+    ): SimpleFunctionDescriptor {
+        val functionDescriptor = SimpleFunctionDescriptorImpl.create(
+                classDescriptor,
+                Annotations.EMPTY,
+                createComponentName(parameterIndex),
+                CallableMemberDescriptor.Kind.SYNTHESIZED,
+                parameter.source
+        )
+
+        functionDescriptor.initialize(
+                null,
+                classDescriptor.thisAsReceiverParameter,
+                emptyList<TypeParameterDescriptor>(),
+                emptyList<ValueParameterDescriptor>(),
+                property.type,
+                Modality.FINAL,
+                property.visibility
+        )
+        functionDescriptor.isOperator = true
+
+        trace.record(BindingContext.DATA_CLASS_COMPONENT_FUNCTION, parameter, functionDescriptor)
+        return functionDescriptor
+    }
+
+    fun createCopyFunctionDescriptor(
+            constructorParameters: Collection<ValueParameterDescriptor>,
+            classDescriptor: ClassDescriptor,
+            trace: BindingTrace
+    ): SimpleFunctionDescriptor {
+        val functionDescriptor = SimpleFunctionDescriptorImpl.create(
+                classDescriptor,
+                Annotations.EMPTY,
+                COPY_METHOD_NAME,
+                CallableMemberDescriptor.Kind.SYNTHESIZED,
+                classDescriptor.source
+        )
+
+        val parameterDescriptors = arrayListOf<ValueParameterDescriptor>()
+
+        for (parameter in constructorParameters) {
+            val propertyDescriptor = trace.bindingContext.get(BindingContext.VALUE_PARAMETER_AS_PROPERTY, parameter)
+            // If a parameter doesn't have the corresponding property, it must not have a default value in the 'copy' function
+            val declaresDefaultValue = propertyDescriptor != null
+            val parameterDescriptor = ValueParameterDescriptorImpl(
+                    functionDescriptor, null, parameter.index, parameter.annotations, parameter.name, parameter.type, declaresDefaultValue,
+                    parameter.isCrossinline, parameter.isNoinline, parameter.isCoroutine, parameter.varargElementType, parameter.source
+            )
+            parameterDescriptors.add(parameterDescriptor)
+            if (declaresDefaultValue) {
+                trace.record(BindingContext.VALUE_PARAMETER_AS_PROPERTY, parameterDescriptor, propertyDescriptor)
+            }
+        }
+
+        functionDescriptor.initialize(
+                null,
+                classDescriptor.thisAsReceiverParameter,
+                emptyList<TypeParameterDescriptor>(),
+                parameterDescriptors,
+                classDescriptor.defaultType,
+                Modality.FINAL,
+                Visibilities.PUBLIC
+        )
+
+        trace.record(BindingContext.DATA_CLASS_COPY_FUNCTION, classDescriptor, functionDescriptor)
+        return functionDescriptor
+    }
+}

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

@@ -1,43 +0,0 @@
-/*
- * Copyright 2010-2015 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.resolve.dataClassUtils
-
-import org.jetbrains.kotlin.name.Name
-
-private val COMPONENT_FUNCTION_NAME_PREFIX = "component"
-
-fun isComponentLike(name: Name): Boolean
-        = isComponentLike(name.asString())
-
-fun isComponentLike(name: String): Boolean {
-    if (!name.startsWith(COMPONENT_FUNCTION_NAME_PREFIX)) return false
-
-    try {
-        getComponentIndex(name)
-    }
-    catch (e: NumberFormatException) {
-        return false
-    }
-
-    return true
-}
-
-fun getComponentIndex(componentName: String): Int
-        = componentName.substring(COMPONENT_FUNCTION_NAME_PREFIX.length).toInt()
-
-fun createComponentName(index: Int): Name
-        = Name.identifier(COMPONENT_FUNCTION_NAME_PREFIX + index)

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

@@ -46,7 +46,6 @@ import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.psi.psiUtil.PsiUtilsKt;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfoFactory;
-import org.jetbrains.kotlin.resolve.dataClassUtils.DataClassUtilsKt;
 import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil;
 import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyTypeAliasDescriptor;
 import org.jetbrains.kotlin.resolve.scopes.*;
@@ -70,18 +69,16 @@ import static org.jetbrains.kotlin.resolve.ModifiersChecker.resolveMemberModalit
 import static org.jetbrains.kotlin.resolve.ModifiersChecker.resolveVisibilityFromModifiers;
 
 public class DescriptorResolver {
-    public static final Name COPY_METHOD_NAME = Name.identifier("copy");
+    private final TypeResolver typeResolver;
-
+    private final AnnotationResolver annotationResolver;
-    @NotNull private final TypeResolver typeResolver;
+    private final StorageManager storageManager;
-    @NotNull private final AnnotationResolver annotationResolver;
+    private final KotlinBuiltIns builtIns;
-    @NotNull private final StorageManager storageManager;
+    private final SupertypeLoopChecker supertypeLoopsResolver;
-    @NotNull private final KotlinBuiltIns builtIns;
+    private final VariableTypeResolver variableTypeResolver;
-    @NotNull private final SupertypeLoopChecker supertypeLoopsResolver;
+    private final ExpressionTypingServices expressionTypingServices;
-    @NotNull private final VariableTypeResolver variableTypeResolver;
+    private final OverloadChecker overloadChecker;
-    @NotNull private final ExpressionTypingServices expressionTypingServices;
+    private final LanguageFeatureSettings languageFeatureSettings;
-    @NotNull private final OverloadChecker overloadChecker;
+    private final FunctionsTypingVisitor functionsTypingVisitor;
-    @NotNull private final LanguageFeatureSettings languageFeatureSettings;
-    @NotNull private final FunctionsTypingVisitor functionsTypingVisitor;
 
     public DescriptorResolver(
             @NotNull AnnotationResolver annotationResolver,
@@ -227,91 +224,6 @@ public class DescriptorResolver {
         }
     }
 
-    @NotNull
-    public static SimpleFunctionDescriptor createComponentFunctionDescriptor(
-            int parameterIndex,
-            @NotNull PropertyDescriptor property,
-            @NotNull ValueParameterDescriptor parameter,
-            @NotNull ClassDescriptor classDescriptor,
-            @NotNull BindingTrace trace
-    ) {
-        Name functionName = DataClassUtilsKt.createComponentName(parameterIndex);
-        KotlinType returnType = property.getType();
-
-        SimpleFunctionDescriptorImpl functionDescriptor = SimpleFunctionDescriptorImpl.create(
-                classDescriptor,
-                Annotations.Companion.getEMPTY(),
-                functionName,
-                CallableMemberDescriptor.Kind.SYNTHESIZED,
-                parameter.getSource()
-        );
-
-        functionDescriptor.initialize(
-                null,
-                classDescriptor.getThisAsReceiverParameter(),
-                Collections.<TypeParameterDescriptor>emptyList(),
-                Collections.<ValueParameterDescriptor>emptyList(),
-                returnType,
-                Modality.FINAL,
-                property.getVisibility()
-        );
-        functionDescriptor.setOperator(true);
-
-        trace.record(BindingContext.DATA_CLASS_COMPONENT_FUNCTION, parameter, functionDescriptor);
-
-        return functionDescriptor;
-    }
-
-    @NotNull
-    public static SimpleFunctionDescriptor createCopyFunctionDescriptor(
-            @NotNull Collection<ValueParameterDescriptor> constructorParameters,
-            @NotNull ClassDescriptor classDescriptor,
-            @NotNull BindingTrace trace
-    ) {
-        KotlinType returnType = classDescriptor.getDefaultType();
-
-        SimpleFunctionDescriptorImpl functionDescriptor = SimpleFunctionDescriptorImpl.create(
-                classDescriptor,
-                Annotations.Companion.getEMPTY(),
-                COPY_METHOD_NAME,
-                CallableMemberDescriptor.Kind.SYNTHESIZED,
-                classDescriptor.getSource()
-        );
-
-        List<ValueParameterDescriptor> parameterDescriptors = Lists.newArrayList();
-
-        for (ValueParameterDescriptor parameter : constructorParameters) {
-            PropertyDescriptor propertyDescriptor = trace.getBindingContext().get(BindingContext.VALUE_PARAMETER_AS_PROPERTY, parameter);
-            // If parameter hasn't corresponding property, so it mustn't have default value as a parameter in copy function for data class
-            boolean declaresDefaultValue = propertyDescriptor != null;
-            ValueParameterDescriptorImpl parameterDescriptor =
-                    new ValueParameterDescriptorImpl(functionDescriptor, null, parameter.getIndex(), parameter.getAnnotations(),
-                                                     parameter.getName(), parameter.getType(),
-                                                     declaresDefaultValue,
-                                                     parameter.isCrossinline(),
-                                                     parameter.isNoinline(),
-                                                     parameter.isCoroutine(),
-                                                     parameter.getVarargElementType(), parameter.getSource());
-            parameterDescriptors.add(parameterDescriptor);
-            if (declaresDefaultValue) {
-                trace.record(BindingContext.VALUE_PARAMETER_AS_PROPERTY, parameterDescriptor, propertyDescriptor);
-            }
-        }
-
-        functionDescriptor.initialize(
-                null,
-                classDescriptor.getThisAsReceiverParameter(),
-                Collections.<TypeParameterDescriptor>emptyList(),
-                parameterDescriptors,
-                returnType,
-                Modality.FINAL,
-                Visibilities.PUBLIC
-        );
-
-        trace.record(BindingContext.DATA_CLASS_COPY_FUNCTION, classDescriptor, functionDescriptor);
-        return functionDescriptor;
-    }
-
     public static Visibility getDefaultVisibility(KtModifierListOwner modifierListOwner, DeclarationDescriptor containingDescriptor) {
         Visibility defaultVisibility;
         if (containingDescriptor instanceof ClassDescriptor) {

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

@@ -35,7 +35,6 @@ import org.jetbrains.kotlin.incremental.components.NoLookupLocation;
 import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilKt;
-import org.jetbrains.kotlin.resolve.dataClassUtils.DataClassUtilsKt;
 import org.jetbrains.kotlin.types.*;
 import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 
@@ -583,7 +582,7 @@ public class OverrideResolver {
 
     private void checkOverrideForMember(@NotNull final CallableMemberDescriptor declared) {
         if (declared.getKind() == CallableMemberDescriptor.Kind.SYNTHESIZED) {
-            if (DataClassUtilsKt.isComponentLike(declared.getName())) {
+            if (DataClassDescriptorResolver.INSTANCE.isComponentLike(declared.getName())) {
                 checkOverrideForComponentFunction(declared);
             }
             return;

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt

@@ -32,8 +32,6 @@ import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.psi.KtProperty
 import org.jetbrains.kotlin.psi.KtTypeReference
 import org.jetbrains.kotlin.resolve.*
-import org.jetbrains.kotlin.resolve.dataClassUtils.createComponentName
-import org.jetbrains.kotlin.resolve.dataClassUtils.isComponentLike
 import org.jetbrains.kotlin.resolve.lazy.LazyClassContext
 import org.jetbrains.kotlin.resolve.lazy.declarations.ClassMemberDeclarationProvider
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
@@ -148,7 +146,7 @@ open class LazyClassMemberScope(
         val primaryConstructorParameters = declarationProvider.getOwnerInfo().primaryConstructorParameters
         assert(constructor.valueParameters.size == primaryConstructorParameters.size) { "From descriptor: " + constructor.valueParameters.size + " but from PSI: " + primaryConstructorParameters.size }
 
-        if (isComponentLike(name)) {
+        if (DataClassDescriptorResolver.isComponentLike(name)) {
             var componentIndex = 0
 
             for (parameter in constructor.valueParameters) {
@@ -162,22 +160,22 @@ open class LazyClassMemberScope(
 
                 ++componentIndex
 
-                if (name == createComponentName(componentIndex)) {
+                if (name == DataClassDescriptorResolver.createComponentName(componentIndex)) {
-                    val functionDescriptor = DescriptorResolver.createComponentFunctionDescriptor(componentIndex, property, parameter, thisDescriptor, trace)
+                    result.add(DataClassDescriptorResolver.createComponentFunctionDescriptor(
-                    result.add(functionDescriptor)
+                            componentIndex, property, parameter, thisDescriptor, trace
+                    ))
                     break
                 }
             }
         }
 
-        if (name == DescriptorResolver.COPY_METHOD_NAME) {
+        if (name == DataClassDescriptorResolver.COPY_METHOD_NAME) {
             for (parameter in constructor.valueParameters) {
                 // force properties resolution to fill BindingContext.VALUE_PARAMETER_AS_PROPERTY slice
                 getContributedVariables(parameter.name, location)
             }
 
-            val copyFunctionDescriptor = DescriptorResolver.createCopyFunctionDescriptor(constructor.valueParameters, thisDescriptor, trace)
+            result.add(DataClassDescriptorResolver.createCopyFunctionDescriptor(constructor.valueParameters, thisDescriptor, trace))
-            result.add(copyFunctionDescriptor)
         }
     }
 
@@ -257,7 +255,7 @@ open class LazyClassMemberScope(
         // Generate componentN functions until there's no such function for some n
         var n = 1
         while (true) {
-            val componentName = createComponentName(n)
+            val componentName = DataClassDescriptorResolver.createComponentName(n)
             val functions = getContributedFunctions(componentName, location)
             if (functions.isEmpty()) break
 

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

@@ -22,9 +22,9 @@ import org.jetbrains.kotlin.psi.KtDestructuringDeclaration
 import org.jetbrains.kotlin.psi.KtDestructuringDeclarationEntry
 import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.DataClassDescriptorResolver
 import org.jetbrains.kotlin.resolve.LocalVariableResolver
 import org.jetbrains.kotlin.resolve.TypeResolver
-import org.jetbrains.kotlin.resolve.dataClassUtils.createComponentName
 import org.jetbrains.kotlin.resolve.scopes.LexicalWritableScope
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
 import org.jetbrains.kotlin.types.ErrorUtils
@@ -45,7 +45,7 @@ class DestructuringDeclarationResolver(
             context: ExpressionTypingContext
     ) {
         for ((componentIndex, entry) in destructuringDeclaration.entries.withIndex()) {
-            val componentName = createComponentName(componentIndex + 1)
+            val componentName = DataClassDescriptorResolver.createComponentName(componentIndex + 1)
 
             val componentType = resolveComponentFunctionAndGetType(componentName, context, entry, receiver, initializer)
             val variableDescriptor = localVariableResolver.resolveLocalVariableDescriptorWithType(writableScope, entry, componentType, context.trace)

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/CallableClsStubBuilder.kt

@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
 import org.jetbrains.kotlin.psi.stubs.impl.KotlinFunctionStubImpl
 import org.jetbrains.kotlin.psi.stubs.impl.KotlinPlaceHolderStubImpl
 import org.jetbrains.kotlin.psi.stubs.impl.KotlinPropertyStubImpl
-import org.jetbrains.kotlin.resolve.dataClassUtils.isComponentLike
+import org.jetbrains.kotlin.resolve.DataClassDescriptorResolver
 import org.jetbrains.kotlin.serialization.Flags
 import org.jetbrains.kotlin.serialization.ProtoBuf
 import org.jetbrains.kotlin.serialization.ProtoBuf.MemberKind
@@ -78,7 +78,7 @@ private fun shouldSkip(flags: Int, name: Name): Boolean {
     return when (Flags.MEMBER_KIND.get(flags)) {
         MemberKind.FAKE_OVERRIDE, MemberKind.DELEGATION -> true
         //TODO: fix decompiler to use sane criteria
-        MemberKind.SYNTHESIZED -> !isComponentLike(name)
+        MemberKind.SYNTHESIZED -> !DataClassDescriptorResolver.isComponentLike(name)
         else -> false
     }
 }

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/buildDecompiledText.kt

@@ -24,8 +24,8 @@ import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.renderer.DescriptorRendererModifier
 import org.jetbrains.kotlin.renderer.DescriptorRendererOptions
 import org.jetbrains.kotlin.renderer.ExcludedTypeAnnotations
+import org.jetbrains.kotlin.resolve.DataClassDescriptorResolver
 import org.jetbrains.kotlin.resolve.DescriptorUtils.isEnumEntry
-import org.jetbrains.kotlin.resolve.dataClassUtils.isComponentLike
 import org.jetbrains.kotlin.resolve.descriptorUtil.secondaryConstructors
 import org.jetbrains.kotlin.types.isFlexible
 
@@ -139,7 +139,7 @@ fun buildDecompiledText(
                 if (member is CallableMemberDescriptor
                     && member.kind != CallableMemberDescriptor.Kind.DECLARATION
                     //TODO: not synthesized and component like
-                    && !isComponentLike(member.name)) {
+                    && !DataClassDescriptorResolver.isComponentLike(member.name)) {
                     continue
                 }
                 newlineExceptFirst()

idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KtSimpleNameReference.kt

@@ -40,9 +40,8 @@ import org.jetbrains.kotlin.psi.psiUtil.getParentOfTypeAndBranch
 import org.jetbrains.kotlin.psi.psiUtil.getQualifiedElement
 import org.jetbrains.kotlin.psi.psiUtil.getQualifiedElementSelector
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
-import org.jetbrains.kotlin.renderer.render
 import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.dataClassUtils.isComponentLike
+import org.jetbrains.kotlin.resolve.DataClassDescriptorResolver
 import org.jetbrains.kotlin.types.expressions.OperatorConventions
 
 class KtSimpleNameReference(expression: KtSimpleNameExpression) : KtSimpleReference<KtSimpleNameExpression>(expression) {
@@ -106,7 +105,7 @@ class KtSimpleNameReference(expression: KtSimpleNameExpression) : KtSimpleRefere
         // Do not rename if the reference corresponds to synthesized component function
         val expressionText = expression.text
         if (expressionText != null && Name.isValidIdentifier(expressionText)) {
-            if (isComponentLike(Name.identifier(expressionText)) && resolve() is KtParameter) {
+            if (DataClassDescriptorResolver.isComponentLike(Name.identifier(expressionText)) && resolve() is KtParameter) {
                 return expression
             }
         }

idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/OperatorReferenceSearcher.kt

@@ -39,8 +39,7 @@ import org.jetbrains.kotlin.idea.util.fuzzyExtensionReceiverType
 import org.jetbrains.kotlin.idea.util.toFuzzyType
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.resolve.dataClassUtils.getComponentIndex
+import org.jetbrains.kotlin.resolve.DataClassDescriptorResolver
-import org.jetbrains.kotlin.resolve.dataClassUtils.isComponentLike
 import org.jetbrains.kotlin.resolve.descriptorUtil.isExtension
 import org.jetbrains.kotlin.types.expressions.OperatorConventions
 import org.jetbrains.kotlin.util.OperatorNameConventions
@@ -125,9 +124,9 @@ abstract class OperatorReferenceSearcher<TReferenceElement : KtElement>(
                 options: KotlinReferencesSearchOptions,
                 searchScope: SearchScope
         ): OperatorReferenceSearcher<*>? {
-            if (isComponentLike(name)) {
+            if (DataClassDescriptorResolver.isComponentLike(name)) {
                 if (!options.searchForComponentConventions) return null
-                val componentIndex = getComponentIndex(name.asString())
+                val componentIndex = DataClassDescriptorResolver.getComponentIndex(name.asString())
                 return DestructuringDeclarationReferenceSearcher(declaration, componentIndex, searchScope, consumer, optimizer)
             }
 

idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionReturnTypeFix.kt

@@ -35,9 +35,9 @@ import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getElementTextWithContext
 import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.DataClassDescriptorResolver
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
-import org.jetbrains.kotlin.resolve.dataClassUtils.getComponentIndex
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.types.ErrorUtils
@@ -199,7 +199,7 @@ class ChangeFunctionReturnTypeFix(element: KtFunction, type: KotlinType) : Kotli
     companion object {
         fun getDestructuringDeclarationEntryThatTypeMismatchComponentFunction(diagnostic: Diagnostic): KtDestructuringDeclarationEntry {
             val componentName = COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH.cast(diagnostic).a
-            val componentIndex = getComponentIndex(componentName.asString())
+            val componentIndex = DataClassDescriptorResolver.getComponentIndex(componentName.asString())
             val multiDeclaration = QuickFixUtil.getParentElementOfType(diagnostic, KtDestructuringDeclaration::class.java) ?: error("COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH reported on expression that is not within any multi declaration")
             return multiDeclaration.entries[componentIndex - 1]
         }

idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateComponentFunctionActionFactory.kt

@@ -24,8 +24,7 @@ import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.Functi
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.TypeInfo
 import org.jetbrains.kotlin.psi.KtDestructuringDeclaration
 import org.jetbrains.kotlin.psi.KtForExpression
-import org.jetbrains.kotlin.resolve.dataClassUtils.getComponentIndex
+import org.jetbrains.kotlin.resolve.DataClassDescriptorResolver
-import org.jetbrains.kotlin.resolve.dataClassUtils.isComponentLike
 import org.jetbrains.kotlin.types.Variance
 
 object CreateComponentFunctionActionFactory : CreateCallableMemberFromUsageFactory<KtDestructuringDeclaration>() {
@@ -38,9 +37,9 @@ object CreateComponentFunctionActionFactory : CreateCallableMemberFromUsageFacto
         val diagnosticWithParameters = Errors.COMPONENT_FUNCTION_MISSING.cast(diagnostic)
 
         val name = diagnosticWithParameters.a
-        if (!isComponentLike(name)) return null
+        if (!DataClassDescriptorResolver.isComponentLike(name)) return null
 
-        val componentNumber = getComponentIndex(name.asString()) - 1
+        val componentNumber = DataClassDescriptorResolver.getComponentIndex(name.asString()) - 1
 
         val ownerType = element.initializer?.let { TypeInfo(it, Variance.IN_VARIANCE) }
                         ?: TypeInfo(diagnosticWithParameters.b, Variance.IN_VARIANCE)

idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinPropertyProcessor.kt

@@ -55,9 +55,9 @@ import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.containingClassOrObject
 import org.jetbrains.kotlin.psi.psiUtil.findPropertyByName
 import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.DataClassDescriptorResolver
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.resolve.dataClassUtils.isComponentLike
 import org.jetbrains.kotlin.resolve.source.getPsi
 import org.jetbrains.kotlin.util.findCallableMemberBySignature
 import org.jetbrains.kotlin.utils.DFS
@@ -349,7 +349,7 @@ class RenameKotlinPropertyProcessor : RenameKotlinPsiProcessor() {
 
         val adjustedUsages = if (element is KtParameter) usages.filterNot {
             val refTarget = it.reference?.resolve()
-            refTarget is KtLightMethod && isComponentLike(Name.guessByFirstCharacter(refTarget.name))
+            refTarget is KtLightMethod && DataClassDescriptorResolver.isComponentLike(Name.guessByFirstCharacter(refTarget.name))
         } else usages.toList()
 
         val refKindUsages = adjustedUsages.groupBy { usage: UsageInfo ->