diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeMethodSignatureData.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeMethodSignatureData.java
index 9f41f2a2eb0..a297e4f2b3e 100644
--- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeMethodSignatureData.java
+++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeMethodSignatureData.java
@@ -203,11 +203,13 @@ public class AlternativeMethodSignatureData extends ElementAlternativeSignatureD
                 alternativeType = KotlinBuiltIns.getInstance().getArrayType(alternativeVarargElementType);
             }
 
+            Name altName = annotationValueParameter.getNameAsName();
+
             altParamDescriptors.add(new ValueParameterDescriptorImpl(
                     originalParameterDescriptor.getContainingDeclaration(),
                     originalParameterDescriptor.getIndex(),
                     originalParameterDescriptor.getAnnotations(),
-                    originalParameterDescriptor.getName(),
+                    altName != null ? altName : originalParameterDescriptor.getName(),
                     alternativeType,
                     originalParameterDescriptor.declaresDefaultValue(),
                     alternativeVarargElementType));
diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagationData.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagationData.java
index 78321b6cd54..399f29effbd 100644
--- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagationData.java
+++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagationData.java
@@ -25,6 +25,8 @@ import com.intellij.psi.PsiManager;
 import com.intellij.psi.PsiMethod;
 import com.intellij.util.Function;
 import com.intellij.util.containers.ContainerUtil;
+import kotlin.Function1;
+import kotlin.KotlinPackage;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
@@ -98,6 +100,10 @@ public class SignaturesPropagationData {
         return modifiedValueParameters.descriptors;
     }
 
+    public boolean getModifiedHasStableParameterNames() {
+        return modifiedValueParameters.hasStableParameterNames;
+    }
+
     public JetType getModifiedReturnType() {
         return modifiedReturnType;
     }
@@ -176,35 +182,49 @@ public class SignaturesPropagationData {
 
         boolean shouldBeExtension = checkIfShouldBeExtension();
 
-        for (ValueParameterDescriptor originalParam : parameters) {
+        for (final ValueParameterDescriptor originalParam : parameters) {
             final int originalIndex = originalParam.getIndex();
-            List<TypeAndVariance> typesFromSuperMethods = ContainerUtil.map(superFunctions,
-                    new Function<FunctionDescriptor, TypeAndVariance>() {
+            List<TypeAndName> typesFromSuperMethods = ContainerUtil.map(superFunctions,
+                    new Function<FunctionDescriptor, TypeAndName>() {
                         @Override
-                        public TypeAndVariance fun(FunctionDescriptor superFunction) {
+                        public TypeAndName fun(FunctionDescriptor superFunction) {
                             ReceiverParameterDescriptor receiver = superFunction.getReceiverParameter();
                             int index = receiver != null ? originalIndex - 1 : originalIndex;
                             if (index == -1) {
                                 assert receiver != null : "can't happen: index is -1, while function is not extension";
-                                return new TypeAndVariance(receiver.getType(), INVARIANT);
+                                return new TypeAndName(receiver.getType(), originalParam.getName());
                             }
-                            return new TypeAndVariance(superFunction.getValueParameters().get(index).getType(), INVARIANT);
+                            ValueParameterDescriptor parameter = superFunction.getValueParameters().get(index);
+                            return new TypeAndName(parameter.getType(), parameter.getName());
                         }
                     });
 
             VarargCheckResult varargCheckResult = checkVarargInSuperFunctions(originalParam);
 
-            JetType altType = modifyTypeAccordingToSuperMethods(varargCheckResult.parameterType, typesFromSuperMethods, MEMBER_SIGNATURE_CONTRAVARIANT);
+            JetType altType = modifyTypeAccordingToSuperMethods(varargCheckResult.parameterType,
+                                                                convertToTypeVarianceList(typesFromSuperMethods),
+                                                                MEMBER_SIGNATURE_CONTRAVARIANT);
 
             if (shouldBeExtension && originalIndex == 0) {
                 resultReceiverType = altType;
             }
             else {
+                Name stableName = null;
+                for (int i = 0; i < superFunctions.size(); i++) {
+                    if (superFunctions.get(i).hasStableParameterNames()) {
+                        // When there's more than one stable name in super functions, we pick the first one. This behaviour is similar to
+                        // the compiler front-end, except that it reports a warning in such cases
+                        // TODO: report a warning somewhere if there's more than one stable name in super functions
+                        stableName = typesFromSuperMethods.get(i).name;
+                        break;
+                    }
+                }
+
                 resultParameters.add(new ValueParameterDescriptorImpl(
                         originalParam.getContainingDeclaration(),
                         shouldBeExtension ? originalIndex - 1 : originalIndex,
                         originalParam.getAnnotations(),
-                        originalParam.getName(),
+                        stableName != null ? stableName : originalParam.getName(),
                         altType,
                         originalParam.declaresDefaultValue(),
                         varargCheckResult.isVararg ? KotlinBuiltIns.getInstance().getArrayElementType(altType) : null
@@ -212,7 +232,24 @@ public class SignaturesPropagationData {
             }
         }
 
-        return new ValueParameters(resultReceiverType, resultParameters);
+        boolean hasStableParameterNames = KotlinPackage.any(superFunctions, new Function1<FunctionDescriptor, Boolean>() {
+            @Override
+            public Boolean invoke(FunctionDescriptor descriptor) {
+                return descriptor.hasStableParameterNames();
+            }
+        });
+
+        return new ValueParameters(resultReceiverType, resultParameters, hasStableParameterNames);
+    }
+
+    @NotNull
+    private static List<TypeAndVariance> convertToTypeVarianceList(@NotNull List<TypeAndName> list) {
+        return KotlinPackage.map(list, new Function1<TypeAndName, TypeAndVariance>() {
+            @Override
+            public TypeAndVariance invoke(TypeAndName tvn) {
+                return new TypeAndVariance(tvn.type, INVARIANT);
+            }
+        });
     }
 
     private static List<FunctionDescriptor> getSuperFunctionsForMethod(
@@ -747,13 +784,29 @@ public class SignaturesPropagationData {
         }
     }
 
+    private static class TypeAndName {
+        public final JetType type;
+        public final Name name;
+
+        public TypeAndName(JetType type, Name name) {
+            this.type = type;
+            this.name = name;
+        }
+    }
+
     private static class ValueParameters {
         private final JetType receiverType;
         private final List<ValueParameterDescriptor> descriptors;
+        private final boolean hasStableParameterNames;
 
-        public ValueParameters(@Nullable JetType receiverType, @NotNull List<ValueParameterDescriptor> descriptors) {
+        public ValueParameters(
+                @Nullable JetType receiverType,
+                @NotNull List<ValueParameterDescriptor> descriptors,
+                boolean hasStableParameterNames
+        ) {
             this.receiverType = receiverType;
             this.descriptors = descriptors;
+            this.hasStableParameterNames = hasStableParameterNames;
         }
     }
 }
diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TraceBasedExternalSignatureResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TraceBasedExternalSignatureResolver.java
index 1287251843b..d73f209d764 100644
--- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TraceBasedExternalSignatureResolver.java
+++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TraceBasedExternalSignatureResolver.java
@@ -66,7 +66,7 @@ public class TraceBasedExternalSignatureResolver implements ExternalSignatureRes
                                               trace);
         return new PropagatedMethodSignature(data.getModifiedReturnType(), data.getModifiedReceiverType(),
                                              data.getModifiedValueParameters(), data.getModifiedTypeParameters(), data.getSignatureErrors(),
-                                             data.getSuperFunctions());
+                                             data.getModifiedHasStableParameterNames(), data.getSuperFunctions());
     }
 
     @Override
@@ -77,7 +77,8 @@ public class TraceBasedExternalSignatureResolver implements ExternalSignatureRes
             @Nullable JetType returnType,
             @Nullable JetType receiverType,
             @NotNull List<ValueParameterDescriptor> valueParameters,
-            @NotNull List<TypeParameterDescriptor> typeParameters
+            @NotNull List<TypeParameterDescriptor> typeParameters,
+            boolean hasStableParameterNames
     ) {
         AlternativeMethodSignatureData data =
                 new AlternativeMethodSignatureData(externalAnnotationResolver, (JavaMethodImpl) method, receiverType, valueParameters, returnType,
@@ -85,11 +86,11 @@ public class TraceBasedExternalSignatureResolver implements ExternalSignatureRes
 
         if (data.isAnnotated() && !data.hasErrors()) {
             return new AlternativeMethodSignature(data.getReturnType(), receiverType, data.getValueParameters(), data.getTypeParameters(),
-                                                  Collections.<String>emptyList());
+                                                  Collections.<String>emptyList(), true);
         }
 
         List<String> error = data.hasErrors() ? Collections.singletonList(data.getError()) : Collections.<String>emptyList();
-        return new AlternativeMethodSignature(returnType, receiverType, valueParameters, typeParameters, error);
+        return new AlternativeMethodSignature(returnType, receiverType, valueParameters, typeParameters, error, hasStableParameterNames);
     }
 
     @Override
diff --git a/compiler/testData/diagnostics/tests/override/parameterNames/kjkHierarchy.kt b/compiler/testData/diagnostics/tests/override/parameterNames/kjkHierarchy.kt
new file mode 100644
index 00000000000..3819cf581f9
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/override/parameterNames/kjkHierarchy.kt
@@ -0,0 +1,16 @@
+// FILE: Super.kt
+
+trait Super {
+    fun foo(superName: Int)
+}
+
+// FILE: Sub.java
+
+interface Sub extends Super {
+}
+
+// FILE: SubSub.kt
+
+class SubSub : Sub {
+    override fun foo(<!PARAMETER_NAME_CHANGED_ON_OVERRIDE!>subName<!>: Int) {}
+}
diff --git a/compiler/testData/diagnostics/tests/override/parameterNames/kjkWithSeveralSupers.kt b/compiler/testData/diagnostics/tests/override/parameterNames/kjkWithSeveralSupers.kt
new file mode 100644
index 00000000000..ca04ebc0162
--- /dev/null
+++ b/compiler/testData/diagnostics/tests/override/parameterNames/kjkWithSeveralSupers.kt
@@ -0,0 +1,51 @@
+// FILE: KSuper.kt
+
+trait KSuper {
+    fun foo(ksuperName: Int)
+}
+
+// FILE: JSuper1.java
+
+interface JSuper1 {
+    void foo(int jsuper1Name);
+}
+
+// FILE: JSuper2.java
+
+interface JSuper2 {
+    void foo(int jsuper2Name);
+}
+
+
+// FILE: Sub1.java
+interface Sub1 extends KSuper, JSuper1, JSuper2 {
+    @Override
+    void foo(int sub1Name)
+}
+
+// FILE: Sub2.java
+interface Sub2 extends JSuper1, KSuper, JSuper2 {
+    @Override
+    void foo(int sub2Name)
+}
+
+// FILE: Sub3.java
+interface Sub3 extends JSuper1, JSuper2, KSuper {
+    @Override
+    void foo(int sub3Name)
+}
+
+
+// FILE: SubSub.kt
+
+class SubSub1 : Sub1 {
+    override fun foo(ksuperName: Int) {}
+}
+
+class SubSub2 : Sub2 {
+    override fun foo(ksuperName: Int) {}
+}
+
+class SubSub3 : Sub3 {
+    override fun foo(ksuperName: Int) {}
+}
diff --git a/compiler/testData/diagnostics/testsWithStdLib/kotlinSignature/parameterNames.kt b/compiler/testData/diagnostics/testsWithStdLib/kotlinSignature/parameterNames.kt
new file mode 100644
index 00000000000..58f5de7b74c
--- /dev/null
+++ b/compiler/testData/diagnostics/testsWithStdLib/kotlinSignature/parameterNames.kt
@@ -0,0 +1,18 @@
+// FILE: A.java
+
+import kotlin.jvm.KotlinSignature;
+
+interface A {
+    @KotlinSignature("fun foo(kotlinSignatureName: String): Unit")
+    void foo(String javaName);
+}
+
+// FILE: 1.kt
+
+class B : A {
+    override fun foo(<!PARAMETER_NAME_CHANGED_ON_OVERRIDE!>kotlinName<!>: String) {}
+}
+
+class C : A {
+    override fun foo(kotlinSignatureName: String) {}
+}
diff --git a/compiler/testData/loadJava/compiledJava/signaturePropagation/TwoSuperclassesVarargAndNot.txt b/compiler/testData/loadJava/compiledJava/signaturePropagation/TwoSuperclassesVarargAndNot.txt
index add74b80598..10fedc1970e 100644
--- a/compiler/testData/loadJava/compiledJava/signaturePropagation/TwoSuperclassesVarargAndNot.txt
+++ b/compiler/testData/loadJava/compiledJava/signaturePropagation/TwoSuperclassesVarargAndNot.txt
@@ -4,7 +4,7 @@ public trait TwoSuperclassesVarargAndNot : java.lang.Object {
     
     public trait Sub : test.TwoSuperclassesVarargAndNot.Super1, test.TwoSuperclassesVarargAndNot.Super2 {
         public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ vararg p0: kotlin.String? /*kotlin.Array<kotlin.String?>*/): kotlin.Unit
-        public abstract override /*1*/ fun foo(/*0*/ p0: kotlin.Array<out kotlin.String?>?): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ s: kotlin.Array<out kotlin.String?>?): kotlin.Unit
     }
     
     public trait Super1 : java.lang.Object {
@@ -12,7 +12,7 @@ public trait TwoSuperclassesVarargAndNot : java.lang.Object {
     }
     
     public trait Super2 : java.lang.Object {
-        public abstract fun foo(/*0*/ p0: kotlin.Array<out kotlin.String?>?): kotlin.Unit
+        public abstract fun foo(/*0*/ s: kotlin.Array<out kotlin.String?>?): kotlin.Unit
     }
 }
 
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/ClassDoesNotOverrideMethod.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/ClassDoesNotOverrideMethod.txt
index 4d6e366286b..691a30890d3 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/ClassDoesNotOverrideMethod.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/ClassDoesNotOverrideMethod.txt
@@ -4,7 +4,7 @@ public abstract class ClassDoesNotOverrideMethod : java.util.Date {
     public constructor ClassDoesNotOverrideMethod()
     public open override /*1*/ /*fake_override*/ fun after(/*0*/ p0: java.util.Date): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun before(/*0*/ p0: java.util.Date): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun compareTo(/*0*/ p0: java.util.Date): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: java.util.Date): kotlin.Int
     kotlin.deprecated(value = "Deprecated in Java": kotlin.String) public open override /*1*/ /*fake_override*/ fun getDate(): kotlin.Int
     kotlin.deprecated(value = "Deprecated in Java": kotlin.String) public open override /*1*/ /*fake_override*/ fun getDay(): kotlin.Int
     kotlin.deprecated(value = "Deprecated in Java": kotlin.String) public open override /*1*/ /*fake_override*/ fun getHours(): kotlin.Int
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/ConstructorWithNewTypeParams.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/ConstructorWithNewTypeParams.kt
index 0ebbbeef413..2f06b98bb52 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/ConstructorWithNewTypeParams.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/ConstructorWithNewTypeParams.kt
@@ -1,4 +1,4 @@
 package test
 
-public open class ConstructorWithNewTypeParams<T>(p0 : Any) : java.lang.Object() {
+public open class ConstructorWithNewTypeParams<T>(first : Any) : java.lang.Object() {
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/ConstructorWithNewTypeParams.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/ConstructorWithNewTypeParams.txt
index 89ffb83d344..3c7677c18ba 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/ConstructorWithNewTypeParams.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/ConstructorWithNewTypeParams.txt
@@ -1,5 +1,5 @@
 package test
 
 public open class ConstructorWithNewTypeParams</*0*/ T> : java.lang.Object {
-    public constructor ConstructorWithNewTypeParams</*0*/ T>(/*0*/ p0: kotlin.Any)
+    public constructor ConstructorWithNewTypeParams</*0*/ T>(/*0*/ first: kotlin.Any)
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/ConstructorWithParentTypeParams.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/ConstructorWithParentTypeParams.kt
index 9f5d661a176..1fe4dd5b627 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/ConstructorWithParentTypeParams.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/ConstructorWithParentTypeParams.kt
@@ -1,4 +1,4 @@
 package test
 
-public open class ConstructorWithParentTypeParams<T>(p0 : T) : java.lang.Object() {
+public open class ConstructorWithParentTypeParams<T>(first : T) : java.lang.Object() {
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/ConstructorWithParentTypeParams.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/ConstructorWithParentTypeParams.txt
index 7d80b3a229d..bf5c904b34a 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/ConstructorWithParentTypeParams.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/ConstructorWithParentTypeParams.txt
@@ -1,5 +1,5 @@
 package test
 
 public open class ConstructorWithParentTypeParams</*0*/ T> : java.lang.Object {
-    public constructor ConstructorWithParentTypeParams</*0*/ T>(/*0*/ p0: T)
+    public constructor ConstructorWithParentTypeParams</*0*/ T>(/*0*/ first: T)
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/ConstructorWithSeveralParams.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/ConstructorWithSeveralParams.kt
index 8b71addba0b..fef3d794602 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/ConstructorWithSeveralParams.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/ConstructorWithSeveralParams.kt
@@ -2,5 +2,5 @@ package test
 
 import java.util.*
 
-public open class ConstructorWithSeveralParams(p0: Int, p1 : Int, p2 : ArrayList<String>) : java.lang.Object() {
+public open class ConstructorWithSeveralParams(integer: Int, intField : Int, collection : ArrayList<String>) : java.lang.Object() {
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/ConstructorWithSeveralParams.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/ConstructorWithSeveralParams.txt
index 63344bfc275..5d0d19aef2e 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/ConstructorWithSeveralParams.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/ConstructorWithSeveralParams.txt
@@ -1,5 +1,5 @@
 package test
 
 public open class ConstructorWithSeveralParams : java.lang.Object {
-    public constructor ConstructorWithSeveralParams(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int, /*2*/ p2: java.util.ArrayList<kotlin.String>)
+    public constructor ConstructorWithSeveralParams(/*0*/ integer: kotlin.Int, /*1*/ intField: kotlin.Int, /*2*/ collection: java.util.ArrayList<kotlin.String>)
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithFunctionTypes.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithFunctionTypes.kt
index 96b121f22bd..d210aac1a31 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithFunctionTypes.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithFunctionTypes.kt
@@ -3,7 +3,7 @@ package test
 import java.util.*
 
 public open class MethodWithFunctionTypes : Object() {
-    public open fun foo(p0 : (String?) -> String) : (String.() -> String?)? {
+    public open fun foo(f : (String?) -> String) : (String.() -> String?)? {
         throw UnsupportedOperationException()
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithFunctionTypes.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithFunctionTypes.txt
index 5cc8c0b9d18..e6fe5511522 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithFunctionTypes.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithFunctionTypes.txt
@@ -2,5 +2,5 @@ package test
 
 public open class MethodWithFunctionTypes : java.lang.Object {
     public constructor MethodWithFunctionTypes()
-    public open fun foo(/*0*/ p0: (kotlin.String?) -> kotlin.String): (kotlin.String.() -> kotlin.String?)?
+    public open fun foo(/*0*/ f: (kotlin.String?) -> kotlin.String): (kotlin.String.() -> kotlin.String?)?
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithGenerics.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithGenerics.kt
index 20fe56ff9de..8b2128d8fad 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithGenerics.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithGenerics.kt
@@ -3,5 +3,5 @@ package test
 import java.util.*
 
 public open class MethodWithGenerics : Object() {
-    public open fun foo(p0 : String, p1 : List<Map.Entry<String?, String>?>) : String = ""
+    public open fun foo(a : String, b : List<Map.Entry<String?, String>?>) : String = ""
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithGenerics.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithGenerics.txt
index 79783d95ee1..aa2f4dce103 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithGenerics.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithGenerics.txt
@@ -2,5 +2,5 @@ package test
 
 public open class MethodWithGenerics : java.lang.Object {
     public constructor MethodWithGenerics()
-    public open fun foo(/*0*/ p0: kotlin.String, /*1*/ p1: kotlin.List<kotlin.Map.Entry<kotlin.String?, kotlin.String>?>): kotlin.String
+    public open fun foo(/*0*/ a: kotlin.String, /*1*/ b: kotlin.List<kotlin.Map.Entry<kotlin.String?, kotlin.String>?>): kotlin.String
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithMappedClasses.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithMappedClasses.kt
index 463d7420c17..60565b96e08 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithMappedClasses.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithMappedClasses.kt
@@ -3,5 +3,5 @@ package test
 import java.util.*
 
 public open class MethodWithMappedClasses : Object() {
-    public open fun <T> copy(p0 : MutableList<in T>, p1 : List<T>) {}
+    public open fun <T> copy(dest : MutableList<in T>, src : List<T>) {}
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithMappedClasses.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithMappedClasses.txt
index a39940523ad..92a8bb78a5a 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithMappedClasses.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithMappedClasses.txt
@@ -2,5 +2,5 @@ package test
 
 public open class MethodWithMappedClasses : java.lang.Object {
     public constructor MethodWithMappedClasses()
-    public open fun </*0*/ T> copy(/*0*/ p0: kotlin.MutableList<in T>, /*1*/ p1: kotlin.List<T>): kotlin.Unit
+    public open fun </*0*/ T> copy(/*0*/ dest: kotlin.MutableList<in T>, /*1*/ src: kotlin.List<T>): kotlin.Unit
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithTypeParameters.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithTypeParameters.kt
index 985a9e16d2f..73670c2daff 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithTypeParameters.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithTypeParameters.kt
@@ -3,6 +3,6 @@ package test
 import java.util.*
 
 public open class MethodWithTypeParameters : Object() {
-    public open fun <A, B : Runnable> foo(p0 : A, p1 : List<B>, p2: MutableList<in String?>) where B : List<Cloneable> {
+    public open fun <A, B : Runnable> foo(a : A, b : List<B>, c: MutableList<in String?>) where B : List<Cloneable> {
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithTypeParameters.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithTypeParameters.txt
index 9a6c9a5941b..8c1f93ed7f5 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithTypeParameters.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithTypeParameters.txt
@@ -2,5 +2,5 @@ package test
 
 public open class MethodWithTypeParameters : java.lang.Object {
     public constructor MethodWithTypeParameters()
-    public open fun </*0*/ A, /*1*/ B : java.lang.Runnable> foo(/*0*/ p0: A, /*1*/ p1: kotlin.List<B>, /*2*/ p2: kotlin.MutableList<in kotlin.String?>): kotlin.Unit where B : kotlin.List<java.lang.Cloneable>
+    public open fun </*0*/ A, /*1*/ B : java.lang.Runnable> foo(/*0*/ a: A, /*1*/ b: kotlin.List<B>, /*2*/ c: kotlin.MutableList<in kotlin.String?>): kotlin.Unit where B : kotlin.List<java.lang.Cloneable>
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithVararg.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithVararg.kt
index e341396cbab..e59f8963dcc 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithVararg.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithVararg.kt
@@ -3,7 +3,7 @@ package test
 import java.util.*
 
 public open class MethodWithVararg : Object() {
-    public open fun foo(vararg p0 : String) {
+    public open fun foo(vararg s : String) {
         throw UnsupportedOperationException()
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithVararg.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithVararg.txt
index 0f241025d96..fbd935426ce 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithVararg.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/MethodWithVararg.txt
@@ -2,5 +2,5 @@ package test
 
 public open class MethodWithVararg : java.lang.Object {
     public constructor MethodWithVararg()
-    public open fun foo(/*0*/ vararg p0: kotlin.String /*kotlin.Array<kotlin.String>*/): kotlin.Unit
+    public open fun foo(/*0*/ vararg s: kotlin.String /*kotlin.Array<kotlin.String>*/): kotlin.Unit
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/error/RedundantProjectionKind.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/error/RedundantProjectionKind.kt
index b241e86d29b..187eb4dabab 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/error/RedundantProjectionKind.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/error/RedundantProjectionKind.kt
@@ -1,7 +1,7 @@
 package test
 
 public open class RedundantProjectionKind : Object() {
-    public open fun foo(p0: List<Number>) {
+    public open fun foo(list: List<Number>) {
         throw UnsupportedOperationException()
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/error/RedundantProjectionKind.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/error/RedundantProjectionKind.txt
index 7515df40be1..7c0f7a470e9 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/error/RedundantProjectionKind.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/error/RedundantProjectionKind.txt
@@ -2,5 +2,5 @@ package test
 
 public open class RedundantProjectionKind : java.lang.Object {
     public constructor RedundantProjectionKind()
-    public open fun foo(/*0*/ p0: kotlin.List<kotlin.Number>): kotlin.Unit
+    public open fun foo(/*0*/ list: kotlin.List<kotlin.Number>): kotlin.Unit
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/PropagateTypeArgumentNullable.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/PropagateTypeArgumentNullable.kt
index f0c7ebabe08..6ab722f6a44 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/PropagateTypeArgumentNullable.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/PropagateTypeArgumentNullable.kt
@@ -3,11 +3,11 @@ package test
 public trait PropagateTypeArgumentNullable: Object {
 
     public trait Super: Object {
-        public fun outS(p0: List<String?>)
+        public fun outS(p: List<String?>)
 
-        public fun invOutS(p0 : MutableList<List<String?>>)
+        public fun invOutS(p : MutableList<List<String?>>)
 
-        public fun outOutS(p0 : List<List<String?>>)
+        public fun outOutS(p : List<List<String?>>)
 
         public fun outR() : List<String?>
         public fun invR() : MutableList<String?>
@@ -16,11 +16,11 @@ public trait PropagateTypeArgumentNullable: Object {
     }
 
     public trait Sub: Super {
-        override fun outS(p0: List<String?>)
+        override fun outS(p: List<String?>)
 
-        override fun invOutS(p0 : MutableList<List<String?>>)
+        override fun invOutS(p : MutableList<List<String?>>)
 
-        override fun outOutS(p0 : List<List<String?>>)
+        override fun outOutS(p : List<List<String?>>)
 
         override fun outR() : List<String?>
         override fun invR() : MutableList<String?>
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/PropagateTypeArgumentNullable.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/PropagateTypeArgumentNullable.txt
index 45512238f7e..46fd69d2a2b 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/PropagateTypeArgumentNullable.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/PropagateTypeArgumentNullable.txt
@@ -4,19 +4,19 @@ public trait PropagateTypeArgumentNullable : java.lang.Object {
     
     public trait Sub : test.PropagateTypeArgumentNullable.Super {
         public abstract override /*1*/ fun invOutR(): kotlin.MutableList<kotlin.List<kotlin.String?>>
-        public abstract override /*1*/ fun invOutS(/*0*/ p0: kotlin.MutableList<kotlin.List<kotlin.String?>>): kotlin.Unit
+        public abstract override /*1*/ fun invOutS(/*0*/ p: kotlin.MutableList<kotlin.List<kotlin.String?>>): kotlin.Unit
         public abstract override /*1*/ fun invR(): kotlin.MutableList<kotlin.String?>
-        public abstract override /*1*/ fun outOutS(/*0*/ p0: kotlin.List<kotlin.List<kotlin.String?>>): kotlin.Unit
+        public abstract override /*1*/ fun outOutS(/*0*/ p: kotlin.List<kotlin.List<kotlin.String?>>): kotlin.Unit
         public abstract override /*1*/ fun outR(): kotlin.List<kotlin.String?>
-        public abstract override /*1*/ fun outS(/*0*/ p0: kotlin.List<kotlin.String?>): kotlin.Unit
+        public abstract override /*1*/ fun outS(/*0*/ p: kotlin.List<kotlin.String?>): kotlin.Unit
     }
     
     public trait Super : java.lang.Object {
         public abstract fun invOutR(): kotlin.MutableList<kotlin.List<kotlin.String?>>
-        public abstract fun invOutS(/*0*/ p0: kotlin.MutableList<kotlin.List<kotlin.String?>>): kotlin.Unit
+        public abstract fun invOutS(/*0*/ p: kotlin.MutableList<kotlin.List<kotlin.String?>>): kotlin.Unit
         public abstract fun invR(): kotlin.MutableList<kotlin.String?>
-        public abstract fun outOutS(/*0*/ p0: kotlin.List<kotlin.List<kotlin.String?>>): kotlin.Unit
+        public abstract fun outOutS(/*0*/ p: kotlin.List<kotlin.List<kotlin.String?>>): kotlin.Unit
         public abstract fun outR(): kotlin.List<kotlin.String?>
-        public abstract fun outS(/*0*/ p0: kotlin.List<kotlin.String?>): kotlin.Unit
+        public abstract fun outS(/*0*/ p: kotlin.List<kotlin.String?>): kotlin.Unit
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind1.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind1.kt
index 7a2fd913a52..c612b0f6323 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind1.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind1.kt
@@ -3,12 +3,12 @@ package test
 public trait ChangeProjectionKind1: Object {
 
     public trait Super: Object {
-        public fun foo(p0: MutableList<in String>)
+        public fun foo(p: MutableList<in String>)
 
         public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {
-        override fun foo(p0: MutableList<in String>)
+        override fun foo(p: MutableList<in String>)
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind1.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind1.txt
index c0beec485a6..cc2a1c9f673 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind1.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind1.txt
@@ -4,11 +4,11 @@ public trait ChangeProjectionKind1 : java.lang.Object {
     
     public trait Sub : test.ChangeProjectionKind1.Super {
         public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*1*/ fun foo(/*0*/ p0: kotlin.MutableList<in kotlin.String>): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ p: kotlin.MutableList<in kotlin.String>): kotlin.Unit
     }
     
     public trait Super : java.lang.Object {
         public abstract fun dummy(): kotlin.Unit
-        public abstract fun foo(/*0*/ p0: kotlin.MutableList<in kotlin.String>): kotlin.Unit
+        public abstract fun foo(/*0*/ p: kotlin.MutableList<in kotlin.String>): kotlin.Unit
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind2.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind2.kt
index 0b535f06738..dc23f201720 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind2.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind2.kt
@@ -3,12 +3,12 @@ package test
 public trait ChangeProjectionKind2: Object {
 
     public trait Super: Object {
-        public fun foo(p0: MutableList<String>)
+        public fun foo(p: MutableList<String>)
 
         public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {
-        override fun foo(p0: MutableList<String>)
+        override fun foo(p: MutableList<String>)
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind2.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind2.txt
index 72e40b7ec6c..295e7824712 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind2.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind2.txt
@@ -4,11 +4,11 @@ public trait ChangeProjectionKind2 : java.lang.Object {
     
     public trait Sub : test.ChangeProjectionKind2.Super {
         public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*1*/ fun foo(/*0*/ p0: kotlin.MutableList<kotlin.String>): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ p: kotlin.MutableList<kotlin.String>): kotlin.Unit
     }
     
     public trait Super : java.lang.Object {
         public abstract fun dummy(): kotlin.Unit
-        public abstract fun foo(/*0*/ p0: kotlin.MutableList<kotlin.String>): kotlin.Unit
+        public abstract fun foo(/*0*/ p: kotlin.MutableList<kotlin.String>): kotlin.Unit
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.kt
index c28cd0d11a1..b8a95e4f76b 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.kt
@@ -3,16 +3,16 @@ package test
 public trait DeeplySubstitutedClassParameter: Object {
 
     public trait Super<T>: Object {
-        public fun foo(p0: T)
+        public fun foo(t: T)
 
         public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Middle<E>: Super<E> {
-        override fun foo(p0: E)
+        override fun foo(t: E)
     }
 
     public trait Sub: Middle<String> {
-        override fun foo(p0: String)
+        override fun foo(t: String)
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.txt
index 500cecb6308..ce4fa2194fc 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.txt
@@ -4,16 +4,16 @@ public trait DeeplySubstitutedClassParameter : java.lang.Object {
     
     public trait Middle</*0*/ E> : test.DeeplySubstitutedClassParameter.Super<E> {
         public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*1*/ fun foo(/*0*/ p0: E): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ t: E): kotlin.Unit
     }
     
     public trait Sub : test.DeeplySubstitutedClassParameter.Middle<kotlin.String> {
         public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*1*/ fun foo(/*0*/ p0: kotlin.String): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ t: kotlin.String): kotlin.Unit
     }
     
     public trait Super</*0*/ T> : java.lang.Object {
         public abstract fun dummy(): kotlin.Unit
-        public abstract fun foo(/*0*/ p0: T): kotlin.Unit
+        public abstract fun foo(/*0*/ t: T): kotlin.Unit
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.kt
index 36d131717d7..8eaf0d060da 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.kt
@@ -3,7 +3,7 @@ package test
 public trait DeeplySubstitutedClassParameter2: Object {
 
     public trait Super<T>: Object {
-        public fun foo(p0: T)
+        public fun foo(t: T)
 
         public fun dummy() // to avoid loading as SAM interface
     }
@@ -12,6 +12,6 @@ public trait DeeplySubstitutedClassParameter2: Object {
     }
 
     public trait Sub: Middle<String> {
-        override fun foo(p0: String)
+        override fun foo(t: String)
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.txt
index 0fb389359d7..221e9e4d757 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.txt
@@ -4,16 +4,16 @@ public trait DeeplySubstitutedClassParameter2 : java.lang.Object {
     
     public trait Middle</*0*/ E> : test.DeeplySubstitutedClassParameter2.Super<E> {
         public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ p0: E): kotlin.Unit
+        public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ t: E): kotlin.Unit
     }
     
     public trait Sub : test.DeeplySubstitutedClassParameter2.Middle<kotlin.String> {
         public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*1*/ fun foo(/*0*/ p0: kotlin.String): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ t: kotlin.String): kotlin.Unit
     }
     
     public trait Super</*0*/ T> : java.lang.Object {
         public abstract fun dummy(): kotlin.Unit
-        public abstract fun foo(/*0*/ p0: T): kotlin.Unit
+        public abstract fun foo(/*0*/ t: T): kotlin.Unit
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritMutability.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritMutability.kt
index 4fca651f5b5..23498ea3af3 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritMutability.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritMutability.kt
@@ -3,12 +3,12 @@ package test
 public trait InheritMutability: Object {
 
     public trait Super: Object {
-        public fun foo(p0: MutableList<String>)
+        public fun foo(p: MutableList<String>)
 
         public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {
-        override fun foo(p0: MutableList<String>)
+        override fun foo(p: MutableList<String>)
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritMutability.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritMutability.txt
index 810d6296f4c..956a62c3858 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritMutability.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritMutability.txt
@@ -4,11 +4,11 @@ public trait InheritMutability : java.lang.Object {
     
     public trait Sub : test.InheritMutability.Super {
         public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*1*/ fun foo(/*0*/ p0: kotlin.MutableList<kotlin.String>): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ p: kotlin.MutableList<kotlin.String>): kotlin.Unit
     }
     
     public trait Super : java.lang.Object {
         public abstract fun dummy(): kotlin.Unit
-        public abstract fun foo(/*0*/ p0: kotlin.MutableList<kotlin.String>): kotlin.Unit
+        public abstract fun foo(/*0*/ p: kotlin.MutableList<kotlin.String>): kotlin.Unit
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.kt
index c76e2530216..10cf3c15366 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.kt
@@ -3,12 +3,12 @@ package test
 public trait InheritNotVarargNotNull: Object {
 
     public trait Super: Object {
-        public fun foo(p0: Array<out String>)
+        public fun foo(p: Array<out String>)
 
         public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {
-        override fun foo(p0: Array<out String>)
+        override fun foo(p: Array<out String>)
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.txt
index d296b1e11c8..fc01627957e 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.txt
@@ -4,11 +4,11 @@ public trait InheritNotVarargNotNull : java.lang.Object {
     
     public trait Sub : test.InheritNotVarargNotNull.Super {
         public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*1*/ fun foo(/*0*/ p0: kotlin.Array<out kotlin.String>): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ p: kotlin.Array<out kotlin.String>): kotlin.Unit
     }
     
     public trait Super : java.lang.Object {
         public abstract fun dummy(): kotlin.Unit
-        public abstract fun foo(/*0*/ p0: kotlin.Array<out kotlin.String>): kotlin.Unit
+        public abstract fun foo(/*0*/ p: kotlin.Array<out kotlin.String>): kotlin.Unit
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritProjectionKind.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritProjectionKind.kt
index db89e8ce436..d5f6000485b 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritProjectionKind.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritProjectionKind.kt
@@ -3,12 +3,12 @@ package test
 public trait InheritProjectionKind: Object {
 
     public trait Super: Object {
-        public fun foo(p0: MutableList<in String>)
+        public fun foo(p: MutableList<in String>)
 
         public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {
-        override fun foo(p0: MutableList<in String>)
+        override fun foo(p: MutableList<in String>)
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritProjectionKind.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritProjectionKind.txt
index 9f680138d02..66b18af139e 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritProjectionKind.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritProjectionKind.txt
@@ -4,11 +4,11 @@ public trait InheritProjectionKind : java.lang.Object {
     
     public trait Sub : test.InheritProjectionKind.Super {
         public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*1*/ fun foo(/*0*/ p0: kotlin.MutableList<in kotlin.String>): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ p: kotlin.MutableList<in kotlin.String>): kotlin.Unit
     }
     
     public trait Super : java.lang.Object {
         public abstract fun dummy(): kotlin.Unit
-        public abstract fun foo(/*0*/ p0: kotlin.MutableList<in kotlin.String>): kotlin.Unit
+        public abstract fun foo(/*0*/ p: kotlin.MutableList<in kotlin.String>): kotlin.Unit
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritReadOnliness.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritReadOnliness.kt
index ccc20f8a2ed..c9628028223 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritReadOnliness.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritReadOnliness.kt
@@ -3,12 +3,12 @@ package test
 public trait InheritReadOnliness: Object {
 
     public trait Super: Object {
-        public fun foo(p0: List<String>)
+        public fun foo(p: List<String>)
 
         public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {
-        override fun foo(p0: List<String>)
+        override fun foo(p: List<String>)
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritReadOnliness.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritReadOnliness.txt
index 1f1f7feffb2..64e73080b7b 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritReadOnliness.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritReadOnliness.txt
@@ -4,11 +4,11 @@ public trait InheritReadOnliness : java.lang.Object {
     
     public trait Sub : test.InheritReadOnliness.Super {
         public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*1*/ fun foo(/*0*/ p0: kotlin.List<kotlin.String>): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ p: kotlin.List<kotlin.String>): kotlin.Unit
     }
     
     public trait Super : java.lang.Object {
         public abstract fun dummy(): kotlin.Unit
-        public abstract fun foo(/*0*/ p0: kotlin.List<kotlin.String>): kotlin.Unit
+        public abstract fun foo(/*0*/ p: kotlin.List<kotlin.String>): kotlin.Unit
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargNotNull.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargNotNull.kt
index a7e877d4989..cca9393c949 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargNotNull.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargNotNull.kt
@@ -3,12 +3,12 @@ package test
 public trait InheritVarargNotNull: Object {
 
     public trait Super: Object {
-        public fun foo(vararg p0: String)
+        public fun foo(vararg p: String)
 
         public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {
-        override fun foo(vararg p0: String)
+        override fun foo(vararg p: String)
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargNotNull.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargNotNull.txt
index 8526ea453d8..b24ec6ab7d3 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargNotNull.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargNotNull.txt
@@ -4,11 +4,11 @@ public trait InheritVarargNotNull : java.lang.Object {
     
     public trait Sub : test.InheritVarargNotNull.Super {
         public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*1*/ fun foo(/*0*/ vararg p0: kotlin.String /*kotlin.Array<kotlin.String>*/): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ vararg p: kotlin.String /*kotlin.Array<kotlin.String>*/): kotlin.Unit
     }
     
     public trait Super : java.lang.Object {
         public abstract fun dummy(): kotlin.Unit
-        public abstract fun foo(/*0*/ vararg p0: kotlin.String /*kotlin.Array<kotlin.String>*/): kotlin.Unit
+        public abstract fun foo(/*0*/ vararg p: kotlin.String /*kotlin.Array<kotlin.String>*/): kotlin.Unit
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/Kt3302.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/Kt3302.kt
index ad7dd435cd2..8084f3aae11 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/Kt3302.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/Kt3302.kt
@@ -9,12 +9,12 @@ public trait Kt3302: Object {
     }
 
     public trait LinkedHashMap<K, V> : Object {
-        public fun put(p0: K, p1: V): V?
+        public fun put(key: K, value: V): V?
 
         public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait BasicBSONObject : LinkedHashMap<String, Any>, BSONObject {
-        override fun put(p0: String, p1: Any): Any?
+        override fun put(key: String, value: Any): Any?
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/Kt3302.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/Kt3302.txt
index 22406fa4182..bfaedf58b6c 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/Kt3302.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/Kt3302.txt
@@ -9,11 +9,11 @@ public trait Kt3302 : java.lang.Object {
     
     public trait BasicBSONObject : test.Kt3302.LinkedHashMap<kotlin.String, kotlin.Any>, test.Kt3302.BSONObject {
         public abstract override /*2*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*2*/ fun put(/*0*/ p0: kotlin.String, /*1*/ p1: kotlin.Any): kotlin.Any?
+        public abstract override /*2*/ fun put(/*0*/ key: kotlin.String, /*1*/ value: kotlin.Any): kotlin.Any?
     }
     
     public trait LinkedHashMap</*0*/ K, /*1*/ V> : java.lang.Object {
         public abstract fun dummy(): kotlin.Unit
-        public abstract fun put(/*0*/ p0: K, /*1*/ p1: V): V?
+        public abstract fun put(/*0*/ key: K, /*1*/ value: V): V?
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/MutableToReadOnly.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/MutableToReadOnly.kt
index 60a1e73881e..7c2f31cc7fa 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/MutableToReadOnly.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/MutableToReadOnly.kt
@@ -3,12 +3,12 @@ package test
 public trait MutableToReadOnly: Object {
 
     public trait Super: Object {
-        public fun foo(p0: MutableList<String>)
+        public fun foo(p: MutableList<String>)
 
         public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {
-        override fun foo(p0: MutableList<String>)
+        override fun foo(p: MutableList<String>)
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/MutableToReadOnly.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/MutableToReadOnly.txt
index efed69d4d85..86a64ddfbfb 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/MutableToReadOnly.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/MutableToReadOnly.txt
@@ -4,11 +4,11 @@ public trait MutableToReadOnly : java.lang.Object {
     
     public trait Sub : test.MutableToReadOnly.Super {
         public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*1*/ fun foo(/*0*/ p0: kotlin.MutableList<kotlin.String>): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ p: kotlin.MutableList<kotlin.String>): kotlin.Unit
     }
     
     public trait Super : java.lang.Object {
         public abstract fun dummy(): kotlin.Unit
-        public abstract fun foo(/*0*/ p0: kotlin.MutableList<kotlin.String>): kotlin.Unit
+        public abstract fun foo(/*0*/ p: kotlin.MutableList<kotlin.String>): kotlin.Unit
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NullableToNotNullKotlinSignature.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NullableToNotNullKotlinSignature.kt
index 0b618765175..f4a88716f6c 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NullableToNotNullKotlinSignature.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NullableToNotNullKotlinSignature.kt
@@ -3,12 +3,12 @@ package test
 public trait NullableToNotNullKotlinSignature: Object {
 
     public trait Super: Object {
-        public fun foo(p0: String?)
+        public fun foo(p: String?)
 
         public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {
-        override fun foo(p0: String?)
+        override fun foo(p: String?)
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NullableToNotNullKotlinSignature.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NullableToNotNullKotlinSignature.txt
index f2dfe52b35f..5cd041dfdfc 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NullableToNotNullKotlinSignature.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NullableToNotNullKotlinSignature.txt
@@ -4,11 +4,11 @@ public trait NullableToNotNullKotlinSignature : java.lang.Object {
     
     public trait Sub : test.NullableToNotNullKotlinSignature.Super {
         public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*1*/ fun foo(/*0*/ p0: kotlin.String?): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ p: kotlin.String?): kotlin.Unit
     }
     
     public trait Super : java.lang.Object {
         public abstract fun dummy(): kotlin.Unit
-        public abstract fun foo(/*0*/ p0: kotlin.String?): kotlin.Unit
+        public abstract fun foo(/*0*/ p: kotlin.String?): kotlin.Unit
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ReadOnlyToMutable.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ReadOnlyToMutable.kt
index 3ba6304e4ea..9aedf9585bf 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ReadOnlyToMutable.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ReadOnlyToMutable.kt
@@ -3,12 +3,12 @@ package test
 public trait ReadOnlyToMutable: Object {
 
     public trait Super: Object {
-        public fun foo(p0: List<String>)
+        public fun foo(p: List<String>)
 
         public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {
-        override fun foo(p0: List<String>)
+        override fun foo(p: List<String>)
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ReadOnlyToMutable.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ReadOnlyToMutable.txt
index c94eb178188..c49f11170de 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ReadOnlyToMutable.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ReadOnlyToMutable.txt
@@ -4,11 +4,11 @@ public trait ReadOnlyToMutable : java.lang.Object {
     
     public trait Sub : test.ReadOnlyToMutable.Super {
         public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*1*/ fun foo(/*0*/ p0: kotlin.List<kotlin.String>): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ p: kotlin.List<kotlin.String>): kotlin.Unit
     }
     
     public trait Super : java.lang.Object {
         public abstract fun dummy(): kotlin.Unit
-        public abstract fun foo(/*0*/ p0: kotlin.List<kotlin.String>): kotlin.Unit
+        public abstract fun foo(/*0*/ p: kotlin.List<kotlin.String>): kotlin.Unit
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.kt
index a9a12f69a65..11358dc08a3 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.kt
@@ -10,12 +10,12 @@ public trait SubclassFromGenericAndNot: Object {
     }
 
     public trait Generic<T> : Object {
-        public fun foo(p0: T)
+        public fun foo(key: T)
 
         public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub : NonGeneric, Generic<String> {
-        override fun foo(p0: String)
+        override fun foo(key: String)
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.txt
index 1415a46466f..5defb1a4d55 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.txt
@@ -4,7 +4,7 @@ public trait SubclassFromGenericAndNot : java.lang.Object {
     
     public trait Generic</*0*/ T> : java.lang.Object {
         public abstract fun dummy(): kotlin.Unit
-        public abstract fun foo(/*0*/ p0: T): kotlin.Unit
+        public abstract fun foo(/*0*/ key: T): kotlin.Unit
     }
     
     public trait NonGeneric : java.lang.Object {
@@ -14,6 +14,6 @@ public trait SubclassFromGenericAndNot : java.lang.Object {
     
     public trait Sub : test.SubclassFromGenericAndNot.NonGeneric, test.SubclassFromGenericAndNot.Generic<kotlin.String> {
         public abstract override /*2*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*2*/ fun foo(/*0*/ p0: kotlin.String): kotlin.Unit
+        public abstract override /*2*/ fun foo(/*0*/ key: kotlin.String): kotlin.Unit
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameter.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameter.kt
index 969c7bffc04..a6e7dc13141 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameter.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameter.kt
@@ -3,12 +3,12 @@ package test
 public trait SubstitutedClassParameter: Object {
 
     public trait Super<T>: Object {
-        public fun foo(p0: T)
+        public fun foo(t: T)
 
         public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super<String> {
-        override fun foo(p0: String)
+        override fun foo(t: String)
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameter.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameter.txt
index 944e3229ebc..59e19442acc 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameter.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameter.txt
@@ -4,11 +4,11 @@ public trait SubstitutedClassParameter : java.lang.Object {
     
     public trait Sub : test.SubstitutedClassParameter.Super<kotlin.String> {
         public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*1*/ fun foo(/*0*/ p0: kotlin.String): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ t: kotlin.String): kotlin.Unit
     }
     
     public trait Super</*0*/ T> : java.lang.Object {
         public abstract fun dummy(): kotlin.Unit
-        public abstract fun foo(/*0*/ p0: T): kotlin.Unit
+        public abstract fun foo(/*0*/ t: T): kotlin.Unit
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameters.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameters.kt
index 6cafaf8dc83..cd7dbb30a6f 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameters.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameters.kt
@@ -3,18 +3,18 @@ package test
 public trait SubstitutedClassParameters: Object {
 
     public trait Super1<T>: Object {
-        public fun foo(p0: T)
+        public fun foo(t: T)
 
         public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Super2<E>: Object {
-        public fun foo(p0: E)
+        public fun foo(t: E)
 
         public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super1<String>, Super2<String> {
-        override fun foo(p0: String)
+        override fun foo(t: String)
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameters.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameters.txt
index 759f3e9996a..ce0cb867d4e 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameters.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameters.txt
@@ -4,16 +4,16 @@ public trait SubstitutedClassParameters : java.lang.Object {
     
     public trait Sub : test.SubstitutedClassParameters.Super1<kotlin.String>, test.SubstitutedClassParameters.Super2<kotlin.String> {
         public abstract override /*2*/ /*fake_override*/ fun dummy(): kotlin.Unit
-        public abstract override /*2*/ fun foo(/*0*/ p0: kotlin.String): kotlin.Unit
+        public abstract override /*2*/ fun foo(/*0*/ t: kotlin.String): kotlin.Unit
     }
     
     public trait Super1</*0*/ T> : java.lang.Object {
         public abstract fun dummy(): kotlin.Unit
-        public abstract fun foo(/*0*/ p0: T): kotlin.Unit
+        public abstract fun foo(/*0*/ t: T): kotlin.Unit
     }
     
     public trait Super2</*0*/ E> : java.lang.Object {
         public abstract fun dummy(): kotlin.Unit
-        public abstract fun foo(/*0*/ p0: E): kotlin.Unit
+        public abstract fun foo(/*0*/ t: E): kotlin.Unit
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubclassOfMapEntry.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubclassOfMapEntry.java
index 0924783402a..bd6cd12a691 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubclassOfMapEntry.java
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubclassOfMapEntry.java
@@ -3,5 +3,5 @@ package test;
 import java.util.*;
 
 public interface SubclassOfMapEntry<K, V> extends Map.Entry<K, V> {
-    V setValue(V v);
+    V setValue(V value);
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubclassOfMapEntry.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubclassOfMapEntry.kt
index 73127c5cab8..10c7c39f0e2 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubclassOfMapEntry.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubclassOfMapEntry.kt
@@ -1,5 +1,5 @@
 package test
 
 public trait SubclassOfMapEntry<K, V>: MutableMap.MutableEntry<K, V> {
-    override fun setValue(p0: V) : V
+    override fun setValue(value: V) : V
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubclassOfMapEntry.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubclassOfMapEntry.txt
index 7665a9898b6..a97044fa8be 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubclassOfMapEntry.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubclassOfMapEntry.txt
@@ -3,5 +3,5 @@ package test
 public trait SubclassOfMapEntry</*0*/ K, /*1*/ V> : kotlin.MutableMap.MutableEntry<K, V> {
     public abstract override /*1*/ /*fake_override*/ fun getKey(): K
     public abstract override /*1*/ /*fake_override*/ fun getValue(): V
-    public abstract override /*1*/ fun setValue(/*0*/ p0: V): V
+    public abstract override /*1*/ fun setValue(/*0*/ value: V): V
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/InheritMutability.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/InheritMutability.kt
index 763b57e5284..01fb9db29bf 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/InheritMutability.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/InheritMutability.kt
@@ -3,10 +3,10 @@ package test
 public trait InheritMutability: Object {
 
     public trait Super: Object {
-        public fun <A: MutableList<String>> foo(p0: A)
+        public fun <A: MutableList<String>> foo(a: A)
     }
 
     public trait Sub: Super {
-        override fun <B: MutableList<String>> foo(p0: B)
+        override fun <B: MutableList<String>> foo(a: B)
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/InheritMutability.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/InheritMutability.txt
index 29177548f0f..61ec8789931 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/InheritMutability.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/InheritMutability.txt
@@ -3,10 +3,10 @@ package test
 public trait InheritMutability : java.lang.Object {
     
     public trait Sub : test.InheritMutability.Super {
-        public abstract override /*1*/ fun </*0*/ B : kotlin.MutableList<kotlin.String>> foo(/*0*/ p0: B): kotlin.Unit
+        public abstract override /*1*/ fun </*0*/ B : kotlin.MutableList<kotlin.String>> foo(/*0*/ a: B): kotlin.Unit
     }
     
     public trait Super : java.lang.Object {
-        public abstract fun </*0*/ A : kotlin.MutableList<kotlin.String>> foo(/*0*/ p0: A): kotlin.Unit
+        public abstract fun </*0*/ A : kotlin.MutableList<kotlin.String>> foo(/*0*/ a: A): kotlin.Unit
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/InheritNullability.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/InheritNullability.kt
index 53870399b65..751339f9afd 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/InheritNullability.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/InheritNullability.kt
@@ -3,10 +3,10 @@ package test
 public trait InheritNullability: Object {
 
     public trait Super: Object {
-        public fun <A: CharSequence> foo(p0: A)
+        public fun <A: CharSequence> foo(a: A)
     }
 
     public trait Sub: Super {
-        override fun <B: CharSequence> foo(p0: B)
+        override fun <B: CharSequence> foo(a: B)
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/InheritNullability.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/InheritNullability.txt
index 943df1e7384..2261639d6a9 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/InheritNullability.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/InheritNullability.txt
@@ -3,10 +3,10 @@ package test
 public trait InheritNullability : java.lang.Object {
     
     public trait Sub : test.InheritNullability.Super {
-        public abstract override /*1*/ fun </*0*/ B : kotlin.CharSequence> foo(/*0*/ p0: B): kotlin.Unit
+        public abstract override /*1*/ fun </*0*/ B : kotlin.CharSequence> foo(/*0*/ a: B): kotlin.Unit
     }
     
     public trait Super : java.lang.Object {
-        public abstract fun </*0*/ A : kotlin.CharSequence> foo(/*0*/ p0: A): kotlin.Unit
+        public abstract fun </*0*/ A : kotlin.CharSequence> foo(/*0*/ a: A): kotlin.Unit
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/InheritReadOnliness.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/InheritReadOnliness.kt
index 66143473110..e4bed7b2370 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/InheritReadOnliness.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/InheritReadOnliness.kt
@@ -3,10 +3,10 @@ package test
 public trait InheritReadOnliness: Object {
 
     public trait Super: Object {
-        public fun <A: List<String>> foo(p0: A)
+        public fun <A: List<String>> foo(a: A)
     }
 
     public trait Sub: Super {
-        override fun <B: List<String>> foo(p0: B)
+        override fun <B: List<String>> foo(a: B)
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/InheritReadOnliness.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/InheritReadOnliness.txt
index 821c6cc0fc5..aba77321290 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/InheritReadOnliness.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/InheritReadOnliness.txt
@@ -3,10 +3,10 @@ package test
 public trait InheritReadOnliness : java.lang.Object {
     
     public trait Sub : test.InheritReadOnliness.Super {
-        public abstract override /*1*/ fun </*0*/ B : kotlin.List<kotlin.String>> foo(/*0*/ p0: B): kotlin.Unit
+        public abstract override /*1*/ fun </*0*/ B : kotlin.List<kotlin.String>> foo(/*0*/ a: B): kotlin.Unit
     }
     
     public trait Super : java.lang.Object {
-        public abstract fun </*0*/ A : kotlin.List<kotlin.String>> foo(/*0*/ p0: A): kotlin.Unit
+        public abstract fun </*0*/ A : kotlin.List<kotlin.String>> foo(/*0*/ a: A): kotlin.Unit
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/TwoBounds.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/TwoBounds.kt
index c13948755ca..37f54d4b9d2 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/TwoBounds.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/TwoBounds.kt
@@ -3,10 +3,10 @@ package test
 public trait TwoBounds: Object {
 
     public trait Super: Object {
-        public fun <A: CharSequence> foo(p0: A) where A: Cloneable
+        public fun <A: CharSequence> foo(a: A) where A: Cloneable
     }
 
     public trait Sub: Super {
-        override fun <B: CharSequence> foo(p0: B) where B: Cloneable
+        override fun <B: CharSequence> foo(a: B) where B: Cloneable
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/TwoBounds.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/TwoBounds.txt
index f552703bae5..25ea7d8c0d9 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/TwoBounds.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/TwoBounds.txt
@@ -3,10 +3,10 @@ package test
 public trait TwoBounds : java.lang.Object {
     
     public trait Sub : test.TwoBounds.Super {
-        public abstract override /*1*/ fun </*0*/ B : kotlin.CharSequence> foo(/*0*/ p0: B): kotlin.Unit where B : java.lang.Cloneable
+        public abstract override /*1*/ fun </*0*/ B : kotlin.CharSequence> foo(/*0*/ a: B): kotlin.Unit where B : java.lang.Cloneable
     }
     
     public trait Super : java.lang.Object {
-        public abstract fun </*0*/ A : kotlin.CharSequence> foo(/*0*/ p0: A): kotlin.Unit where A : java.lang.Cloneable
+        public abstract fun </*0*/ A : kotlin.CharSequence> foo(/*0*/ a: A): kotlin.Unit where A : java.lang.Cloneable
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/TwoSuperclasses.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/TwoSuperclasses.kt
index d0390c27464..e5b7a3f6db2 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/TwoSuperclasses.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/TwoSuperclasses.kt
@@ -3,14 +3,14 @@ package test
 public trait TwoSuperclasses: Object {
 
     public trait Super1: Object {
-        public fun <A: CharSequence> foo(p0: A)
+        public fun <A: CharSequence> foo(a: A)
     }
 
     public trait Super2: Object {
-        public fun <B: CharSequence> foo(p0: B)
+        public fun <B: CharSequence> foo(a: B)
     }
 
     public trait Sub: Super1, Super2 {
-        override fun <C: CharSequence> foo(p0: C)
+        override fun <C: CharSequence> foo(a: C)
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/TwoSuperclasses.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/TwoSuperclasses.txt
index fbfe8556170..09cb4a48108 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/TwoSuperclasses.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/TwoSuperclasses.txt
@@ -3,14 +3,14 @@ package test
 public trait TwoSuperclasses : java.lang.Object {
     
     public trait Sub : test.TwoSuperclasses.Super1, test.TwoSuperclasses.Super2 {
-        public abstract override /*2*/ fun </*0*/ C : kotlin.CharSequence> foo(/*0*/ p0: C): kotlin.Unit
+        public abstract override /*2*/ fun </*0*/ C : kotlin.CharSequence> foo(/*0*/ a: C): kotlin.Unit
     }
     
     public trait Super1 : java.lang.Object {
-        public abstract fun </*0*/ A : kotlin.CharSequence> foo(/*0*/ p0: A): kotlin.Unit
+        public abstract fun </*0*/ A : kotlin.CharSequence> foo(/*0*/ a: A): kotlin.Unit
     }
     
     public trait Super2 : java.lang.Object {
-        public abstract fun </*0*/ B : kotlin.CharSequence> foo(/*0*/ p0: B): kotlin.Unit
+        public abstract fun </*0*/ B : kotlin.CharSequence> foo(/*0*/ a: B): kotlin.Unit
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/TwoTypeParameters.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/TwoTypeParameters.kt
index 6d80b9dce81..cb5b249664b 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/TwoTypeParameters.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/TwoTypeParameters.kt
@@ -3,10 +3,10 @@ package test
 public trait TwoTypeParameters: Object {
 
     public trait Super: Object {
-        public fun <A: CharSequence, B: Cloneable> foo(p0: A, p1: B)
+        public fun <A: CharSequence, B: Cloneable> foo(a: A, b: B)
     }
 
     public trait Sub: Super {
-        override fun <B: CharSequence, A: Cloneable> foo(p0: B, p1: A)
+        override fun <B: CharSequence, A: Cloneable> foo(a: B, b: A)
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/TwoTypeParameters.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/TwoTypeParameters.txt
index 81f839fd45f..339c7c6feee 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/TwoTypeParameters.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/TwoTypeParameters.txt
@@ -3,10 +3,10 @@ package test
 public trait TwoTypeParameters : java.lang.Object {
     
     public trait Sub : test.TwoTypeParameters.Super {
-        public abstract override /*1*/ fun </*0*/ B : kotlin.CharSequence, /*1*/ A : java.lang.Cloneable> foo(/*0*/ p0: B, /*1*/ p1: A): kotlin.Unit
+        public abstract override /*1*/ fun </*0*/ B : kotlin.CharSequence, /*1*/ A : java.lang.Cloneable> foo(/*0*/ a: B, /*1*/ b: A): kotlin.Unit
     }
     
     public trait Super : java.lang.Object {
-        public abstract fun </*0*/ A : kotlin.CharSequence, /*1*/ B : java.lang.Cloneable> foo(/*0*/ p0: A, /*1*/ p1: B): kotlin.Unit
+        public abstract fun </*0*/ A : kotlin.CharSequence, /*1*/ B : java.lang.Cloneable> foo(/*0*/ a: A, /*1*/ b: B): kotlin.Unit
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/UseParameterAsUpperBound.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/UseParameterAsUpperBound.kt
index fd4a7be4554..04ef1a2a495 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/UseParameterAsUpperBound.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/UseParameterAsUpperBound.kt
@@ -3,10 +3,10 @@ package test
 public trait UseParameterAsUpperBound: Object {
 
     public trait Super: Object {
-        public fun <A, B: A> foo(p0: A, p1: B)
+        public fun <A, B: A> foo(a: A, b: B)
     }
 
     public trait Sub: Super {
-        override fun <B, A: B> foo(p0: B, p1: A)
+        override fun <B, A: B> foo(a: B, b: A)
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/UseParameterAsUpperBound.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/UseParameterAsUpperBound.txt
index 145abe62b88..12a887fa175 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/UseParameterAsUpperBound.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/UseParameterAsUpperBound.txt
@@ -3,10 +3,10 @@ package test
 public trait UseParameterAsUpperBound : java.lang.Object {
     
     public trait Sub : test.UseParameterAsUpperBound.Super {
-        public abstract override /*1*/ fun </*0*/ B, /*1*/ A : B> foo(/*0*/ p0: B, /*1*/ p1: A): kotlin.Unit
+        public abstract override /*1*/ fun </*0*/ B, /*1*/ A : B> foo(/*0*/ a: B, /*1*/ b: A): kotlin.Unit
     }
     
     public trait Super : java.lang.Object {
-        public abstract fun </*0*/ A, /*1*/ B : A> foo(/*0*/ p0: A, /*1*/ p1: B): kotlin.Unit
+        public abstract fun </*0*/ A, /*1*/ B : A> foo(/*0*/ a: A, /*1*/ b: B): kotlin.Unit
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/UseParameterInUpperBound.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/UseParameterInUpperBound.kt
index af8017ca33f..d2ccdddb76c 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/UseParameterInUpperBound.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/UseParameterInUpperBound.kt
@@ -3,10 +3,10 @@ package test
 public trait UseParameterInUpperBound: Object {
 
     public trait Super: Object {
-        public fun <A, B: List<A>> foo(p0: A, p1: B)
+        public fun <A, B: List<A>> foo(a: A, b: B)
     }
 
     public trait Sub: Super {
-        override fun <B, A: List<B>> foo(p0: B, p1: A)
+        override fun <B, A: List<B>> foo(a: B, b: A)
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/UseParameterInUpperBound.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/UseParameterInUpperBound.txt
index ec63b21f330..6efdd6b972d 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/UseParameterInUpperBound.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/UseParameterInUpperBound.txt
@@ -3,10 +3,10 @@ package test
 public trait UseParameterInUpperBound : java.lang.Object {
     
     public trait Sub : test.UseParameterInUpperBound.Super {
-        public abstract override /*1*/ fun </*0*/ B, /*1*/ A : kotlin.List<B>> foo(/*0*/ p0: B, /*1*/ p1: A): kotlin.Unit
+        public abstract override /*1*/ fun </*0*/ B, /*1*/ A : kotlin.List<B>> foo(/*0*/ a: B, /*1*/ b: A): kotlin.Unit
     }
     
     public trait Super : java.lang.Object {
-        public abstract fun </*0*/ A, /*1*/ B : kotlin.List<A>> foo(/*0*/ p0: A, /*1*/ p1: B): kotlin.Unit
+        public abstract fun </*0*/ A, /*1*/ B : kotlin.List<A>> foo(/*0*/ a: A, /*1*/ b: B): kotlin.Unit
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/UseParameterInUpperBoundWithKotlinSignature.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/UseParameterInUpperBoundWithKotlinSignature.kt
index dfaeab913a8..1a40d3c1814 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/UseParameterInUpperBoundWithKotlinSignature.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/UseParameterInUpperBoundWithKotlinSignature.kt
@@ -3,10 +3,10 @@ package test
 public trait UseParameterInUpperBoundWithKotlinSignature: Object {
 
     public trait Super: Object {
-        public fun <A, B: List<A>> foo(p0: A, p1: B)
+        public fun <A, B: List<A>> foo(a: A, b: B)
     }
 
     public trait Sub: Super {
-        override fun <B, A: List<B>> foo(p0: B, p1: A)
+        override fun <B, A: List<B>> foo(b: B, a: A)
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/UseParameterInUpperBoundWithKotlinSignature.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/UseParameterInUpperBoundWithKotlinSignature.txt
index 57bded1fb5c..a37ba85ebc6 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/UseParameterInUpperBoundWithKotlinSignature.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/typeParameter/UseParameterInUpperBoundWithKotlinSignature.txt
@@ -3,10 +3,10 @@ package test
 public trait UseParameterInUpperBoundWithKotlinSignature : java.lang.Object {
     
     public trait Sub : test.UseParameterInUpperBoundWithKotlinSignature.Super {
-        public abstract override /*1*/ fun </*0*/ B, /*1*/ A : kotlin.List<B>> foo(/*0*/ p0: B, /*1*/ p1: A): kotlin.Unit
+        public abstract override /*1*/ fun </*0*/ B, /*1*/ A : kotlin.List<B>> foo(/*0*/ b: B, /*1*/ a: A): kotlin.Unit
     }
     
     public trait Super : java.lang.Object {
-        public abstract fun </*0*/ A, /*1*/ B : kotlin.List<A>> foo(/*0*/ p0: A, /*1*/ p1: B): kotlin.Unit
+        public abstract fun </*0*/ A, /*1*/ B : kotlin.List<A>> foo(/*0*/ a: A, /*1*/ b: B): kotlin.Unit
     }
 }
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/modality/ModalityOfFakeOverrides.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/modality/ModalityOfFakeOverrides.kt
index 47d144d8c2d..3597ab24a1c 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/modality/ModalityOfFakeOverrides.kt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/modality/ModalityOfFakeOverrides.kt
@@ -3,7 +3,7 @@ package test
 import java.util.AbstractList
 
 public open class ModalityOfFakeOverrides : AbstractList<String>() {
-    override fun get(p0: Int): String {
+    override fun get(index: Int): String {
         return ""
     }
 
diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/modality/ModalityOfFakeOverrides.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/modality/ModalityOfFakeOverrides.txt
index e25e50d2628..9463b8db02f 100644
--- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/modality/ModalityOfFakeOverrides.txt
+++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/modality/ModalityOfFakeOverrides.txt
@@ -3,28 +3,28 @@ package test
 public open class ModalityOfFakeOverrides : java.util.AbstractList<kotlin.String> {
     public constructor ModalityOfFakeOverrides()
     protected/*protected and package*/ final override /*1*/ /*fake_override*/ var modCount: kotlin.Int
-    public open override /*1*/ /*fake_override*/ fun add(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.String): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun add(/*0*/ p0: kotlin.String): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.String): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun add(/*0*/ e: kotlin.String): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ c: kotlin.Collection<kotlin.String>): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Collection<kotlin.String>): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ c: kotlin.Collection<kotlin.String>): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun contains(/*0*/ o: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun containsAll(/*0*/ c: kotlin.Collection<kotlin.Any?>): kotlin.Boolean
-    public open override /*1*/ fun get(/*0*/ p0: kotlin.Int): kotlin.String
-    public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ p0: kotlin.Any?): kotlin.Int
+    public open override /*1*/ fun get(/*0*/ index: kotlin.Int): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ o: kotlin.Any?): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.MutableIterator<kotlin.String>
-    public open override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ p0: kotlin.Any?): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ o: kotlin.Any?): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun listIterator(): kotlin.MutableListIterator<kotlin.String>
-    public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ p0: kotlin.Int): kotlin.MutableListIterator<kotlin.String>
+    public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.MutableListIterator<kotlin.String>
     public open override /*1*/ /*fake_override*/ fun remove(/*0*/ o: kotlin.Any?): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun remove(/*0*/ p0: kotlin.Int): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun remove(/*0*/ index: kotlin.Int): kotlin.String
     public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ c: kotlin.Collection<kotlin.Any?>): kotlin.Boolean
     protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ c: kotlin.Collection<kotlin.Any?>): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun set(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.String): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.String): kotlin.String
     public open override /*1*/ fun size(): kotlin.Int
-    public open override /*1*/ /*fake_override*/ fun subList(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.MutableList<kotlin.String>
+    public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.MutableList<kotlin.String>
     public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<kotlin.Any?>
-    public open override /*1*/ /*fake_override*/ fun </*0*/ T> toArray(/*0*/ p0: kotlin.Array<out T>): kotlin.Array<T>
+    public open override /*1*/ /*fake_override*/ fun </*0*/ T> toArray(/*0*/ a: kotlin.Array<out T>): kotlin.Array<T>
 }
diff --git a/compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/InheritExtensionFunction.txt b/compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/InheritExtensionFunction.txt
index 551c78965c8..aca2de9c103 100644
--- a/compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/InheritExtensionFunction.txt
+++ b/compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/InheritExtensionFunction.txt
@@ -2,7 +2,7 @@ package test
 
 public open class Sub : test.Super {
     public constructor Sub()
-    public open override /*1*/ fun kotlin.String.bar(/*0*/ param: kotlin.String): kotlin.String
+    public open override /*1*/ fun kotlin.String.bar(/*0*/ p: kotlin.String): kotlin.String
     public final override /*1*/ /*fake_override*/ fun kotlin.String.foo(): kotlin.Unit
 }
 
diff --git a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java
index 81d6639dca6..ea5be3549be 100644
--- a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java
+++ b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java
@@ -5356,6 +5356,16 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
                     doTest("compiler/testData/diagnostics/tests/override/parameterNames/jjkHierarchy.kt");
                 }
                 
+                @TestMetadata("kjkHierarchy.kt")
+                public void testKjkHierarchy() throws Exception {
+                    doTest("compiler/testData/diagnostics/tests/override/parameterNames/kjkHierarchy.kt");
+                }
+                
+                @TestMetadata("kjkWithSeveralSupers.kt")
+                public void testKjkWithSeveralSupers() throws Exception {
+                    doTest("compiler/testData/diagnostics/tests/override/parameterNames/kjkWithSeveralSupers.kt");
+                }
+                
                 @TestMetadata("kotlinInheritsBothJavaAndKotlin.kt")
                 public void testKotlinInheritsBothJavaAndKotlin() throws Exception {
                     doTest("compiler/testData/diagnostics/tests/override/parameterNames/kotlinInheritsBothJavaAndKotlin.kt");
diff --git a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestWithStdLibGenerated.java b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestWithStdLibGenerated.java
index 9f0361ad48a..c36559497aa 100644
--- a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestWithStdLibGenerated.java
+++ b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestWithStdLibGenerated.java
@@ -31,7 +31,7 @@ import org.jetbrains.jet.checkers.AbstractJetDiagnosticsTestWithStdLib;
 /** This class is generated by {@link org.jetbrains.jet.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */
 @SuppressWarnings("all")
 @TestMetadata("compiler/testData/diagnostics/testsWithStdLib")
-@InnerTestClasses({JetDiagnosticsTestWithStdLibGenerated.Annotations.class, JetDiagnosticsTestWithStdLibGenerated.FunctionLiterals.class})
+@InnerTestClasses({JetDiagnosticsTestWithStdLibGenerated.Annotations.class, JetDiagnosticsTestWithStdLibGenerated.FunctionLiterals.class, JetDiagnosticsTestWithStdLibGenerated.KotlinSignature.class})
 public class JetDiagnosticsTestWithStdLibGenerated extends AbstractJetDiagnosticsTestWithStdLib {
     public void testAllFilesPresentInTestsWithStdLib() throws Exception {
         JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/diagnostics/testsWithStdLib"), Pattern.compile("^(.+)\\.kt$"), true);
@@ -93,11 +93,25 @@ public class JetDiagnosticsTestWithStdLibGenerated extends AbstractJetDiagnostic
         
     }
     
+    @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/kotlinSignature")
+    public static class KotlinSignature extends AbstractJetDiagnosticsTestWithStdLib {
+        public void testAllFilesPresentInKotlinSignature() throws Exception {
+            JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/diagnostics/testsWithStdLib/kotlinSignature"), Pattern.compile("^(.+)\\.kt$"), true);
+        }
+        
+        @TestMetadata("parameterNames.kt")
+        public void testParameterNames() throws Exception {
+            doTest("compiler/testData/diagnostics/testsWithStdLib/kotlinSignature/parameterNames.kt");
+        }
+        
+    }
+    
     public static Test suite() {
         TestSuite suite = new TestSuite("JetDiagnosticsTestWithStdLibGenerated");
         suite.addTestSuite(JetDiagnosticsTestWithStdLibGenerated.class);
         suite.addTest(Annotations.innerSuite());
         suite.addTestSuite(FunctionLiterals.class);
+        suite.addTestSuite(KotlinSignature.class);
         return suite;
     }
 }
diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/descriptor/JavaMethodDescriptor.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/descriptor/JavaMethodDescriptor.java
index 91d2d76b484..1322d5c28e9 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/descriptor/JavaMethodDescriptor.java
+++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/descriptor/JavaMethodDescriptor.java
@@ -25,6 +25,8 @@ import org.jetbrains.jet.lang.descriptors.impl.SimpleFunctionDescriptorImpl;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
 public class JavaMethodDescriptor extends SimpleFunctionDescriptorImpl implements JavaCallableMemberDescriptor {
+    private Boolean hasStableParameterNames = null;
+
     public JavaMethodDescriptor(
             @NotNull DeclarationDescriptor containingDeclaration,
             @NotNull Annotations annotations,
@@ -54,17 +56,20 @@ public class JavaMethodDescriptor extends SimpleFunctionDescriptorImpl implement
 
     @Override
     public boolean hasStableParameterNames() {
-        // TODO: propagated names should be stable
-        return false;
+        assert hasStableParameterNames != null : "hasStableParameterNames was not set: " + this;
+        return hasStableParameterNames;
+    }
+
+    public void setHasStableParameterNames(boolean hasStableParameterNames) {
+        this.hasStableParameterNames = hasStableParameterNames;
     }
 
     @Override
     protected FunctionDescriptorImpl createSubstitutedCopy(DeclarationDescriptor newOwner, boolean preserveOriginal, Kind kind) {
-        if (preserveOriginal) {
-            return new JavaMethodDescriptor(newOwner, getOriginal(), getAnnotations(), getName(), kind);
-        }
-        else {
-            return new JavaMethodDescriptor(newOwner, getAnnotations(), getName(), kind);
-        }
+        JavaMethodDescriptor result = preserveOriginal
+                                      ? new JavaMethodDescriptor(newOwner, getOriginal(), getAnnotations(), getName(), kind)
+                                      : new JavaMethodDescriptor(newOwner, getAnnotations(), getName(), kind);
+        result.setHasStableParameterNames(hasStableParameterNames());
+        return result;
     }
 }
diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaClassMemberScope.kt b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaClassMemberScope.kt
index 4a80a6a82da..51448e12582 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaClassMemberScope.kt
+++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaClassMemberScope.kt
@@ -77,7 +77,7 @@ public class LazyJavaClassMemberScope(
 
         val valueParameters = resolveValueParameters(c, constructorDescriptor, constructor.getValueParameters())
         val effectiveSignature = c.externalSignatureResolver.resolveAlternativeMethodSignature(
-                constructor, false, null, null, valueParameters, Collections.emptyList())
+                constructor, false, null, null, valueParameters, Collections.emptyList(), false)
 
         constructorDescriptor.initialize(
                 classDescriptor.getTypeConstructor().getParameters(),
diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaMemberScope.kt b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaMemberScope.kt
index f7d325b0bc3..11c152fdc95 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaMemberScope.kt
+++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaMemberScope.kt
@@ -126,7 +126,8 @@ public abstract class LazyJavaMemberScope(
         val effectiveSignature: ExternalSignatureResolver.AlternativeMethodSignature
         if (_containingDeclaration is PackageFragmentDescriptor) {
             superFunctions = Collections.emptyList()
-            effectiveSignature = c.externalSignatureResolver.resolveAlternativeMethodSignature(method, false, returnType, null, valueParameters, methodTypeParameters)
+            effectiveSignature = c.externalSignatureResolver.resolveAlternativeMethodSignature(method, false, returnType, null, valueParameters,
+                                                                                               methodTypeParameters, false)
             signatureErrors = effectiveSignature.getErrors()
         }
         else if (_containingDeclaration is ClassDescriptor) {
@@ -134,7 +135,8 @@ public abstract class LazyJavaMemberScope(
             superFunctions = propagated.getSuperMethods()
             effectiveSignature = c.externalSignatureResolver.resolveAlternativeMethodSignature(
                     method, !superFunctions.isEmpty(), propagated.getReturnType(),
-                    propagated.getReceiverType(), propagated.getValueParameters(), propagated.getTypeParameters())
+                    propagated.getReceiverType(), propagated.getValueParameters(), propagated.getTypeParameters(),
+                    propagated.hasStableParameterNames())
 
             signatureErrors = ArrayList<String>(propagated.getErrors())
             signatureErrors.addAll(effectiveSignature.getErrors())
@@ -153,6 +155,8 @@ public abstract class LazyJavaMemberScope(
                 method.getVisibility()
         )
 
+        functionDescriptorImpl.setHasStableParameterNames(effectiveSignature.hasStableParameterNames())
+
         if (record) {
             c.javaResolverCache.recordMethod(method, functionDescriptorImpl)
         }
diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ExternalSignatureResolver.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ExternalSignatureResolver.java
index ae628c2db21..25e8b37ba77 100644
--- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ExternalSignatureResolver.java
+++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ExternalSignatureResolver.java
@@ -45,19 +45,22 @@ public interface ExternalSignatureResolver {
         private final JetType receiverType;
         private final List<ValueParameterDescriptor> valueParameters;
         private final List<TypeParameterDescriptor> typeParameters;
+        private final boolean hasStableParameterNames;
 
         public AlternativeMethodSignature(
                 @Nullable JetType returnType,
                 @Nullable JetType receiverType,
                 @NotNull List<ValueParameterDescriptor> valueParameters,
                 @NotNull List<TypeParameterDescriptor> typeParameters,
-                @NotNull List<String> signatureErrors
+                @NotNull List<String> signatureErrors,
+                boolean hasStableParameterNames
         ) {
             super(signatureErrors);
             this.returnType = returnType;
             this.receiverType = receiverType;
             this.valueParameters = valueParameters;
             this.typeParameters = typeParameters;
+            this.hasStableParameterNames = hasStableParameterNames;
         }
 
         @Nullable
@@ -79,6 +82,10 @@ public interface ExternalSignatureResolver {
         public List<TypeParameterDescriptor> getTypeParameters() {
             return typeParameters;
         }
+
+        public boolean hasStableParameterNames() {
+            return hasStableParameterNames;
+        }
     }
 
     class AlternativeFieldSignature extends MemberSignature {
@@ -104,9 +111,10 @@ public interface ExternalSignatureResolver {
                 @NotNull List<ValueParameterDescriptor> valueParameters,
                 @NotNull List<TypeParameterDescriptor> typeParameters,
                 @NotNull List<String> signatureErrors,
+                boolean hasStableParameterNames,
                 @NotNull List<FunctionDescriptor> superMethods
         ) {
-            super(returnType, receiverType, valueParameters, typeParameters, signatureErrors);
+            super(returnType, receiverType, valueParameters, typeParameters, signatureErrors, hasStableParameterNames);
             this.superMethods = superMethods;
         }
 
@@ -133,7 +141,8 @@ public interface ExternalSignatureResolver {
             @Nullable JetType returnType,
             @Nullable JetType receiverType,
             @NotNull List<ValueParameterDescriptor> valueParameters,
-            @NotNull List<TypeParameterDescriptor> typeParameters
+            @NotNull List<TypeParameterDescriptor> typeParameters,
+            boolean hasStableParameterNames
     );
 
     @NotNull