Refactor function descriptors copy mechanism

Pull up CopyBuilder to interface and inline some custom usages

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/ErasedOverridabilityCondition.kt

@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.load.java
 
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor
 import org.jetbrains.kotlin.load.java.descriptors.JavaMethodDescriptor
 import org.jetbrains.kotlin.load.java.lazy.types.RawSubstitution
@@ -45,7 +46,7 @@ class ErasedOverridabilityCondition : ExternalOverridabilityCondition {
 
         if (erasedSuper is SimpleFunctionDescriptor && erasedSuper.typeParameters.isNotEmpty()) {
             // Only simple functions are supported now for erased overrides
-            erasedSuper = erasedSuper.createCopyWithNewTypeParameters(emptyList())
+            erasedSuper = erasedSuper.newCopyBuilder().setTypeParameters(emptyList()).build()!!
         }
 
         val overridabilityResult =

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt

@@ -144,6 +144,13 @@ class LazyJavaClassMemberScope(
         }
     }
 
+    private fun SimpleFunctionDescriptor.createRenamedCopy(builtinName: Name): SimpleFunctionDescriptor =
+            this.newCopyBuilder().apply {
+                setName(builtinName)
+                setSignatureChange()
+                setPreserveSourceElement()
+            }.build()!!
+
     private fun isOverridableRenamedDescriptor(superDescriptor: FunctionDescriptor, subDescriptor: FunctionDescriptor): Boolean {
         // if we check 'removeAt', get original sub-descriptor to distinct `remove(int)` and `remove(E)` in Java
         val subDescriptorToCheck = if (superDescriptor.isRemoveAtByIndex) subDescriptor.original else subDescriptor
@@ -222,7 +229,7 @@ class LazyJavaClassMemberScope(
             return
         }
 
-        var specialBuiltinsFromSuperTypes = SmartSet.create<SimpleFunctionDescriptor>()
+        val specialBuiltinsFromSuperTypes = SmartSet.create<SimpleFunctionDescriptor>()
 
         // Merge functions with same signatures
         val mergedFunctionFromSuperTypes = resolveOverridesForNonStaticMembers(
@@ -316,10 +323,11 @@ class LazyJavaClassMemberScope(
     private fun SimpleFunctionDescriptor.createHiddenCopyIfBuiltinAlreadyAccidentallyOverridden(
             specialBuiltin: CallableDescriptor,
             alreadyDeclaredFunctions: Collection<SimpleFunctionDescriptor>
-    ) = if (alreadyDeclaredFunctions.none { this != it && it.doesOverride(specialBuiltin) })
+    ): SimpleFunctionDescriptor =
+        if (alreadyDeclaredFunctions.none { this != it && it.doesOverride(specialBuiltin) })
             this
         else
-            createHiddenCopyToOvercomeSignatureClash()
+            newCopyBuilder().setHiddenToOvercomeSignatureClash().build()!!
 
     private fun createOverrideForBuiltinFunctionWithErasedParameterIfNeeded(
             overridden: FunctionDescriptor,
@@ -329,9 +337,11 @@ class LazyJavaClassMemberScope(
             it.doesOverrideBuiltinFunctionWithErasedValueParameters(overridden)
         }?.let {
             override ->
-            override.createCopyWithNewValueParameters(
+            override.newCopyBuilder().apply {
-                    copyValueParameters(overridden.valueParameters.map { it.type }, override.valueParameters, overridden))
+                setValueParameters(copyValueParameters(overridden.valueParameters.map { it.type }, override.valueParameters, overridden))
-
+                setSignatureChange()
+                setPreserveSourceElement()
+            }.build()
         }
     }
 

core/descriptors/src/org/jetbrains/kotlin/descriptors/FunctionDescriptor.java

@@ -18,9 +18,12 @@ package org.jetbrains.kotlin.descriptors;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.name.Name;
+import org.jetbrains.kotlin.types.KotlinType;
 import org.jetbrains.kotlin.types.TypeSubstitutor;
 
 import java.util.Collection;
+import java.util.List;
 
 public interface FunctionDescriptor extends CallableMemberDescriptor {
     @Override
@@ -71,4 +74,57 @@ public interface FunctionDescriptor extends CallableMemberDescriptor {
     boolean isTailrec();
 
     boolean isExternal();
+
+    @NotNull
+    CopyBuilder<? extends FunctionDescriptor> newCopyBuilder();
+
+    interface CopyBuilder<D extends FunctionDescriptor> {
+        @NotNull
+        CopyBuilder<D> setOwner(@NotNull DeclarationDescriptor owner);
+
+        @NotNull
+        CopyBuilder<D> setModality(@NotNull Modality modality);
+
+        @NotNull
+        CopyBuilder<D> setVisibility(@NotNull Visibility visibility);
+
+        @NotNull
+        CopyBuilder<D> setKind(@NotNull Kind kind);
+
+        @NotNull
+        CopyBuilder<D> setCopyOverrides(boolean copyOverrides);
+
+        @NotNull
+        CopyBuilder<D> setName(@NotNull Name name);
+
+        @NotNull
+        CopyBuilder<D> setValueParameters(@NotNull List<ValueParameterDescriptor> parameters);
+
+        @NotNull
+        CopyBuilder<D> setTypeParameters(@NotNull List<TypeParameterDescriptor> parameters);
+
+        @NotNull
+        CopyBuilder<D> setReturnType(@NotNull KotlinType type);
+
+        @NotNull
+        CopyBuilder<D> setExtensionReceiverType(@Nullable KotlinType type);
+
+        @NotNull
+        CopyBuilder<D> setOriginal(@NotNull FunctionDescriptor original);
+
+        @NotNull
+        CopyBuilder<D> setSignatureChange();
+
+        @NotNull
+        CopyBuilder<D> setPreserveSourceElement();
+
+        @NotNull
+        CopyBuilder<D> setDropOriginalInContainingParts();
+
+        @NotNull
+        CopyBuilder<D> setHiddenToOvercomeSignatureClash();
+
+        @Nullable
+        D build();
+    }
 }

core/descriptors/src/org/jetbrains/kotlin/descriptors/SimpleFunctionDescriptor.java

@@ -30,18 +30,10 @@ public interface SimpleFunctionDescriptor extends FunctionDescriptor {
     SimpleFunctionDescriptor copy(DeclarationDescriptor newOwner, Modality modality, Visibility visibility, Kind kind, boolean copyOverrides);
 
     @NotNull
-    SimpleFunctionDescriptor createRenamedCopy(@NotNull Name name);
+    @Override
-
+    SimpleFunctionDescriptor getOriginal();
-    @NotNull
-    SimpleFunctionDescriptor createCopyWithNewValueParameters(@NotNull List<ValueParameterDescriptor> valueParameters);
-
-    @NotNull
-    SimpleFunctionDescriptor createCopyWithNewTypeParameters(@NotNull List<TypeParameterDescriptor> typeParameters);
-
-    @NotNull
-    SimpleFunctionDescriptor createHiddenCopyToOvercomeSignatureClash();
 
     @NotNull
     @Override
-    SimpleFunctionDescriptor getOriginal();
+    CopyBuilder<? extends SimpleFunctionDescriptor> newCopyBuilder();
 }

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

@@ -158,7 +158,7 @@ public class ConstructorDescriptorImpl extends FunctionDescriptorImpl implements
     public ConstructorDescriptor copy(DeclarationDescriptor newOwner, Modality modality, Visibility visibility, Kind kind, boolean copyOverrides) {
         //noinspection ConstantConditions
         return (ConstructorDescriptor) doSubstitute(
-                newCopyBuilder()
+                (CopyConfiguration) newCopyBuilder()
                         .setOwner(newOwner)
                         .setModality(modality)
                         .setVisibility(visibility)

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

@@ -293,7 +293,7 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo
         return extensionReceiverParameter.getType();
     }
 
-    public class CopyConfiguration {
+    public class CopyConfiguration implements SimpleFunctionDescriptor.CopyBuilder<FunctionDescriptor> {
         protected @NotNull TypeSubstitutor originalSubstitutor;
         protected @NotNull DeclarationDescriptor newOwner;
         protected @NotNull Modality newModality;
@@ -334,94 +334,112 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo
             this.isHiddenToOvercomeSignatureClash = isHiddenToOvercomeSignatureClash();
         }
 
+        @Override
         @NotNull
-        protected CopyConfiguration setOwner(@NotNull DeclarationDescriptor owner) {
+        public CopyConfiguration setOwner(@NotNull DeclarationDescriptor owner) {
             this.newOwner = owner;
             return this;
         }
 
+        @Override
         @NotNull
         public CopyConfiguration setModality(@NotNull Modality modality) {
             this.newModality = modality;
             return this;
         }
 
+        @Override
         @NotNull
         public CopyConfiguration setVisibility(@NotNull Visibility visibility) {
             this.newVisibility = visibility;
             return this;
         }
 
+        @Override
         @NotNull
         public CopyConfiguration setKind(@NotNull Kind kind) {
             this.kind = kind;
             return this;
         }
 
+        @Override
         @NotNull
         public CopyConfiguration setCopyOverrides(boolean copyOverrides) {
             this.copyOverrides = copyOverrides;
             return this;
         }
 
+        @Override
         @NotNull
         public CopyConfiguration setName(@NotNull Name name) {
             this.name = name;
             return this;
         }
 
+        @Override
         @NotNull
         public CopyConfiguration setValueParameters(@NotNull List<ValueParameterDescriptor> parameters) {
             this.newValueParameterDescriptors = parameters;
             return this;
         }
 
+        @Override
         @NotNull
         public CopyConfiguration setTypeParameters(@NotNull List<TypeParameterDescriptor> parameters) {
             this.newTypeParameters = parameters;
             return this;
         }
 
+        @NotNull
+        @Override
         public CopyConfiguration setReturnType(@NotNull KotlinType type) {
             this.newReturnType = type;
             return this;
         }
 
+        @NotNull
+        @Override
         public CopyConfiguration setExtensionReceiverType(@Nullable KotlinType type) {
             this.newExtensionReceiverParameterType = type;
             return this;
         }
 
+        @Override
         @NotNull
         public CopyConfiguration setOriginal(@NotNull FunctionDescriptor original) {
             this.original = original;
             return this;
         }
 
+        @Override
         @NotNull
         public CopyConfiguration setSignatureChange() {
             this.signatureChange = true;
             return this;
         }
 
+        @Override
         @NotNull
         public CopyConfiguration setPreserveSourceElement() {
             this.preserveSourceElement = true;
             return this;
         }
 
+        @Override
         @NotNull
         public CopyConfiguration setDropOriginalInContainingParts() {
             this.dropOriginalInContainingParts = true;
             return this;
         }
 
+        @Override
         @NotNull
-        public CopyConfiguration setHidden() {
+        public CopyConfiguration setHiddenToOvercomeSignatureClash() {
             isHiddenToOvercomeSignatureClash = true;
             return this;
         }
 
+        @Override
         @Nullable
         public FunctionDescriptor build() {
             return doSubstitute(this);
@@ -438,8 +456,9 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo
         }
     }
 
+    @Override
     @NotNull
-    public CopyConfiguration newCopyBuilder() {
+    public CopyBuilder<? extends FunctionDescriptor> newCopyBuilder() {
         return newCopyBuilder(TypeSubstitutor.EMPTY);
     }
 

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

@@ -150,6 +150,12 @@ public abstract class PropertyAccessorDescriptorImpl extends DeclarationDescript
         return getCorrespondingProperty().getDispatchReceiverParameter();
     }
 
+    @NotNull
+    @Override
+    public CopyBuilder<? extends FunctionDescriptor> newCopyBuilder() {
+        throw new UnsupportedOperationException("Accessors must be copied by the corresponding property");
+    }
+
     @NotNull
     @Override
     public PropertyAccessorDescriptor copy(

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

@@ -100,7 +100,7 @@ public class SimpleFunctionDescriptorImpl extends FunctionDescriptorImpl impleme
             boolean copyOverrides
     ) {
         //noinspection ConstantConditions
-        return (SimpleFunctionDescriptor) newCopyBuilder()
+        return newCopyBuilder()
                     .setOwner(newOwner)
                     .setModality(modality)
                     .setVisibility(visibility)
@@ -111,31 +111,8 @@ public class SimpleFunctionDescriptorImpl extends FunctionDescriptorImpl impleme
 
     @NotNull
     @Override
-    public SimpleFunctionDescriptor createRenamedCopy(@NotNull Name name) {
+    public CopyBuilder<? extends SimpleFunctionDescriptor> newCopyBuilder() {
-        //noinspection ConstantConditions
+        //noinspection unchecked
-        return (SimpleFunctionDescriptor) newCopyBuilder().setName(name).setSignatureChange().setPreserveSourceElement().build();
+        return (CopyBuilder<? extends SimpleFunctionDescriptor>) super.newCopyBuilder();
-    }
-
-    @NotNull
-    @Override
-    public SimpleFunctionDescriptor createCopyWithNewValueParameters(@NotNull List<ValueParameterDescriptor> valueParameters) {
-        //noinspection ConstantConditions
-        return (SimpleFunctionDescriptor) newCopyBuilder()
-                                            .setValueParameters(valueParameters)
-                                            .setSignatureChange().setPreserveSourceElement().build();
-    }
-
-    @NotNull
-    @Override
-    public SimpleFunctionDescriptor createCopyWithNewTypeParameters(@NotNull List<TypeParameterDescriptor> typeParameters) {
-        //noinspection ConstantConditions
-        return (SimpleFunctionDescriptor) newCopyBuilder().setTypeParameters(typeParameters).build();
-    }
-
-    @NotNull
-    @Override
-    public SimpleFunctionDescriptor createHiddenCopyToOvercomeSignatureClash() {
-        //noinspection ConstantConditions
-        return (SimpleFunctionDescriptor) newCopyBuilder().setHidden().build();
     }
 }

core/descriptors/src/org/jetbrains/kotlin/types/error/ErrorSimpleFunctionDescriptorImpl.java

@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.descriptors.impl.FunctionDescriptorImpl;
 import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.types.ErrorUtils;
+import org.jetbrains.kotlin.types.KotlinType;
 
 import java.util.Collection;
 import java.util.List;
@@ -58,26 +59,104 @@ public class ErrorSimpleFunctionDescriptorImpl extends SimpleFunctionDescriptorI
 
     @NotNull
     @Override
-    public SimpleFunctionDescriptor createRenamedCopy(@NotNull Name name) {
+    public CopyBuilder<? extends SimpleFunctionDescriptor> newCopyBuilder() {
-        return this;
+        return new CopyBuilder<SimpleFunctionDescriptor>() {
-    }
+            @NotNull
+            @Override
+            public CopyBuilder<SimpleFunctionDescriptor> setOwner(@NotNull DeclarationDescriptor owner) {
+                return this;
+            }
 
-    @NotNull
+            @NotNull
-    @Override
+            @Override
-    public SimpleFunctionDescriptor createCopyWithNewValueParameters(@NotNull List<ValueParameterDescriptor> valueParameters) {
+            public CopyBuilder<SimpleFunctionDescriptor> setModality(@NotNull Modality modality) {
-        return this;
+                return this;
-    }
+            }
 
-    @NotNull
+            @NotNull
-    @Override
+            @Override
-    public SimpleFunctionDescriptor createCopyWithNewTypeParameters(@NotNull List<TypeParameterDescriptor> typeParameters) {
+            public CopyBuilder<SimpleFunctionDescriptor> setVisibility(@NotNull Visibility visibility) {
-        return this;
+                return this;
-    }
+            }
 
-    @NotNull
+            @NotNull
-    @Override
+            @Override
-    public SimpleFunctionDescriptor createHiddenCopyToOvercomeSignatureClash() {
+            public CopyBuilder<SimpleFunctionDescriptor> setKind(@NotNull Kind kind) {
-        return this;
+                return this;
+            }
+
+            @NotNull
+            @Override
+            public CopyBuilder<SimpleFunctionDescriptor> setCopyOverrides(boolean copyOverrides) {
+                return this;
+            }
+
+            @NotNull
+            @Override
+            public CopyBuilder<SimpleFunctionDescriptor> setName(@NotNull Name name) {
+                return this;
+            }
+
+            @NotNull
+            @Override
+            public CopyBuilder<SimpleFunctionDescriptor> setValueParameters(@NotNull List<ValueParameterDescriptor> parameters) {
+                return this;
+            }
+
+            @NotNull
+            @Override
+            public CopyBuilder<SimpleFunctionDescriptor> setTypeParameters(@NotNull List<TypeParameterDescriptor> parameters) {
+                return this;
+            }
+
+            @NotNull
+            @Override
+            public CopyBuilder<SimpleFunctionDescriptor> setReturnType(@NotNull KotlinType type) {
+                return this;
+            }
+
+            @NotNull
+            @Override
+            public CopyBuilder<SimpleFunctionDescriptor> setExtensionReceiverType(@Nullable KotlinType type) {
+                return this;
+            }
+
+            @NotNull
+            @Override
+            public CopyBuilder<SimpleFunctionDescriptor> setOriginal(@NotNull FunctionDescriptor original) {
+                return this;
+            }
+
+            @NotNull
+            @Override
+            public CopyBuilder<SimpleFunctionDescriptor> setSignatureChange() {
+                return this;
+            }
+
+            @NotNull
+            @Override
+            public CopyBuilder<SimpleFunctionDescriptor> setPreserveSourceElement() {
+                return this;
+            }
+
+            @NotNull
+            @Override
+            public CopyBuilder<SimpleFunctionDescriptor> setDropOriginalInContainingParts() {
+                return this;
+            }
+
+            @NotNull
+            @Override
+            public CopyBuilder<SimpleFunctionDescriptor> setHiddenToOvercomeSignatureClash() {
+                return this;
+            }
+
+            @Nullable
+            @Override
+            public SimpleFunctionDescriptor build() {
+                return ErrorSimpleFunctionDescriptorImpl.this;
+            }
+        };
     }
 
     @Override