More correct way of replacing parameter names to preserve overrides

core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionInvokeDescriptor.kt

@@ -23,14 +23,14 @@ import org.jetbrains.kotlin.descriptors.impl.FunctionDescriptorImpl
 import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl
 import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.types.TypeSubstitutor
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.util.OperatorNameConventions
 
 class FunctionInvokeDescriptor private constructor(
         container: DeclarationDescriptor,
         original: FunctionInvokeDescriptor?,
-        callableKind: CallableMemberDescriptor.Kind,
+        callableKind: CallableMemberDescriptor.Kind
-        private val hasSynthesizedParameterNames: Boolean
 ) : SimpleFunctionDescriptorImpl(
         container,
         original,
@@ -41,13 +41,9 @@ class FunctionInvokeDescriptor private constructor(
 ) {
     init {
         this.isOperator = true
+        this.setHasStableParameterNames(false)
     }
 
-    // "p0", "p1", etc. should not be baked into the language
-    override fun hasStableParameterNames(): Boolean = false
-
-    override fun hasSynthesizedParameterNames(): Boolean = hasSynthesizedParameterNames
-
     override fun doSubstitute(configuration: CopyConfiguration): FunctionDescriptor? {
         val substituted = super.doSubstitute(configuration) as FunctionInvokeDescriptor? ?: return null
         if (substituted.valueParameters.none { it.type.extractParameterNameFromFunctionTypeArgument() != null }) return substituted
@@ -63,7 +59,7 @@ class FunctionInvokeDescriptor private constructor(
             annotations: Annotations,
             source: SourceElement
     ): FunctionDescriptorImpl {
-        return FunctionInvokeDescriptor(newOwner, original as FunctionInvokeDescriptor?, kind, hasSynthesizedParameterNames)
+        return FunctionInvokeDescriptor(newOwner, original as FunctionInvokeDescriptor?, kind)
     }
 
     override fun isExternal(): Boolean = false
@@ -72,12 +68,10 @@ class FunctionInvokeDescriptor private constructor(
 
     override fun isTailrec(): Boolean = false
 
-    private fun replaceParameterNames(parameterNames: List<Name?>): FunctionInvokeDescriptor {
+    private fun replaceParameterNames(parameterNames: List<Name?>): FunctionDescriptor {
         val indexShift = valueParameters.size - parameterNames.size
         assert(indexShift == 0 || indexShift == 1) // indexShift == 1 for extension function type
 
-        val hasSynthesizedParameterNames = parameterNames.any { it == null }
-        val newDescriptor = FunctionInvokeDescriptor(containingDeclaration, this, kind, hasSynthesizedParameterNames)
         val newValueParameters = valueParameters.map {
             var newName = it.name
             val parameterIndex = it.index
@@ -88,17 +82,22 @@ class FunctionInvokeDescriptor private constructor(
                     newName = parameterName
                 }
             }
-            it.copy(newDescriptor, newName, parameterIndex)
+            it.copy(this, newName, parameterIndex)
         }
-        newDescriptor.initialize(extensionReceiverParameterType, dispatchReceiverParameter, typeParameters, newValueParameters, returnType, modality, visibility)
+
-        return newDescriptor
+        val copyConfiguration = newCopyBuilder(TypeSubstitutor.EMPTY)
+                .setHasSynthesizedParameterNames(parameterNames.any { it == null })
+                .setValueParameters(newValueParameters)
+                .setOriginal(original)
+
+        return super.doSubstitute(copyConfiguration)!!
     }
 
     companion object Factory {
         fun create(functionClass: FunctionClassDescriptor): FunctionInvokeDescriptor {
             val typeParameters = functionClass.declaredTypeParameters
 
-            val result = FunctionInvokeDescriptor(functionClass, null, CallableMemberDescriptor.Kind.DECLARATION, hasSynthesizedParameterNames = true)
+            val result = FunctionInvokeDescriptor(functionClass, null, CallableMemberDescriptor.Kind.DECLARATION)
             result.initialize(
                     null,
                     functionClass.thisAsReceiverParameter,
@@ -110,6 +109,7 @@ class FunctionInvokeDescriptor private constructor(
                     Modality.ABSTRACT,
                     Visibilities.PUBLIC
             )
+            result.setHasSynthesizedParameterNames(true)
             return result
         }
 

core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/FunctionDescriptorImpl.java

@@ -351,6 +351,7 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo
         private boolean isHiddenForResolutionEverywhereBesideSupercalls = isHiddenForResolutionEverywhereBesideSupercalls();
         private SourceElement sourceElement;
         private Map<UserDataKey<?>, Object> userDataMap = new LinkedHashMap<UserDataKey<?>, Object>();
+        private Boolean newHasSynthesizedParameterNames = null;
 
         public CopyConfiguration(
                 @NotNull TypeSubstitution substitution,
@@ -507,6 +508,11 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo
             return this;
         }
 
+        public CopyConfiguration setHasSynthesizedParameterNames(boolean value) {
+            this.newHasSynthesizedParameterNames = value;
+            return this;
+        }
+
         @NotNull
         @Override
         public CopyConfiguration setSubstitution(@NotNull TypeSubstitution substitution) {
@@ -626,10 +632,13 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo
         substitutedDescriptor.setTailrec(isTailrec);
         substitutedDescriptor.setSuspend(isSuspend);
         substitutedDescriptor.setHasStableParameterNames(hasStableParameterNames);
-        substitutedDescriptor.setHasSynthesizedParameterNames(hasSynthesizedParameterNames);
         substitutedDescriptor.setHiddenToOvercomeSignatureClash(configuration.isHiddenToOvercomeSignatureClash);
         substitutedDescriptor.setHiddenForResolutionEverywhereBesideSupercalls(configuration.isHiddenForResolutionEverywhereBesideSupercalls);
 
+        substitutedDescriptor.setHasSynthesizedParameterNames(
+                configuration.newHasSynthesizedParameterNames != null ? configuration.newHasSynthesizedParameterNames : hasSynthesizedParameterNames
+        );
+
         if (!configuration.userDataMap.isEmpty() || userDataMap != null) {
             Map<UserDataKey<?>, Object> newMap = configuration.userDataMap;