diff --git a/generators/org/jetbrains/jet/generators/tests/GenerateTests.java b/generators/org/jetbrains/jet/generators/tests/GenerateTests.java
index 16022e193a3..412f6d1111b 100644
--- a/generators/org/jetbrains/jet/generators/tests/GenerateTests.java
+++ b/generators/org/jetbrains/jet/generators/tests/GenerateTests.java
@@ -419,7 +419,9 @@ public class GenerateTests {
                 testModel("idea/testData/safeDelete/deleteProperty/kotlinPropertyWithJava", "doPropertyTestWithJava"),
                 testModel("idea/testData/safeDelete/deleteProperty/javaPropertyWithKotlin", "doJavaPropertyTest"),
                 testModel("idea/testData/safeDelete/deleteTypeParameter/kotlinTypeParameter", "doTypeParameterTest"),
-                testModel("idea/testData/safeDelete/deleteTypeParameter/kotlinTypeParameterWithJava", "doTypeParameterTestWithJava")
+                testModel("idea/testData/safeDelete/deleteTypeParameter/kotlinTypeParameterWithJava", "doTypeParameterTestWithJava"),
+                testModel("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter", "doValueParameterTest"),
+                testModel("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava", "doValueParameterTestWithJava")
         );
 
         generateTest(
diff --git a/idea/src/org/jetbrains/jet/plugin/JetBundle.properties b/idea/src/org/jetbrains/jet/plugin/JetBundle.properties
index 3bb8c7b1f74..1b9d7c92bb0 100644
--- a/idea/src/org/jetbrains/jet/plugin/JetBundle.properties
+++ b/idea/src/org/jetbrains/jet/plugin/JetBundle.properties
@@ -261,4 +261,5 @@ x.overrides.y.in.class.list={0} in {1} overrides functions in the following clas
 unused.overriding.methods.title=Unused Overriding Members
 there.are.unused.methods.that.override.methods.you.delete=There are unused members that override methods you delete.
 choose.the.ones.you.want.to.be.deleted=Choose the ones you want to be deleted.
-method.column=Member
\ No newline at end of file
+method.column=Member
+delete.param.in.method.hierarchy={0} is a part of method hierarchy. Do you want to delete multiple parameters?
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/safeDelete/KotlinSafeDeleteProcessor.java b/idea/src/org/jetbrains/jet/plugin/refactoring/safeDelete/KotlinSafeDeleteProcessor.java
index f47e28a34b3..918d5564e7a 100644
--- a/idea/src/org/jetbrains/jet/plugin/refactoring/safeDelete/KotlinSafeDeleteProcessor.java
+++ b/idea/src/org/jetbrains/jet/plugin/refactoring/safeDelete/KotlinSafeDeleteProcessor.java
@@ -26,7 +26,10 @@ import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.*;
 import com.intellij.psi.search.searches.OverridingMethodsSearch;
 import com.intellij.psi.search.searches.ReferencesSearch;
-import com.intellij.psi.util.*;
+import com.intellij.psi.util.MethodSignatureUtil;
+import com.intellij.psi.util.PsiFormatUtil;
+import com.intellij.psi.util.PsiFormatUtilBase;
+import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.refactoring.safeDelete.JavaSafeDeleteProcessor;
 import com.intellij.refactoring.safeDelete.NonCodeUsageSearchInfo;
 import com.intellij.refactoring.safeDelete.usageInfo.SafeDeleteOverrideAnnotation;
@@ -34,12 +37,17 @@ import com.intellij.refactoring.safeDelete.usageInfo.SafeDeleteOverridingMethodU
 import com.intellij.refactoring.safeDelete.usageInfo.SafeDeleteReferenceJavaDeleteUsageInfo;
 import com.intellij.refactoring.safeDelete.usageInfo.SafeDeleteReferenceSimpleDeleteUsageInfo;
 import com.intellij.usageView.UsageInfo;
-import com.intellij.util.*;
+import com.intellij.util.ArrayUtilRt;
+import com.intellij.util.Function;
+import com.intellij.util.IncorrectOperationException;
+import com.intellij.util.Processor;
 import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.asJava.LightClassUtil;
-import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.Modality;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingContextUtils;
@@ -58,7 +66,8 @@ public class KotlinSafeDeleteProcessor extends JavaSafeDeleteProcessor {
                || element instanceof JetNamedFunction
                || element instanceof PsiMethod
                || element instanceof JetProperty
-               || element instanceof JetTypeParameter;
+               || element instanceof JetTypeParameter
+               || element instanceof JetParameter;
     }
 
     @Override
@@ -113,6 +122,17 @@ public class KotlinSafeDeleteProcessor extends JavaSafeDeleteProcessor {
         if (element instanceof JetTypeParameter) {
             return findTypeParameterUsages((JetTypeParameter) element, allElementsToDelete, result);
         }
+        if (element instanceof JetParameter) {
+            JetParameter jetParameter = (JetParameter) element;
+
+            PsiParameter psiParameter = getPsiParameter(jetParameter);
+            if (psiParameter != null) {
+                super.findUsages(psiParameter, allElementsToDelete, result);
+            }
+
+            return findParameterUsages(jetParameter, allElementsToDelete, result);
+        }
+
         return getSearchInfo(element, allElementsToDelete);
     }
 
@@ -314,6 +334,84 @@ public class KotlinSafeDeleteProcessor extends JavaSafeDeleteProcessor {
         return getSearchInfo(property, allElementsToDelete);
     }
 
+    protected static NonCodeUsageSearchInfo findParameterUsages(
+            final JetParameter parameter,
+            final PsiElement[] allElementsToDelete,
+            final List<UsageInfo> result
+    ) {
+        NonCodeUsageSearchInfo searchInfo = getSearchInfo(parameter, allElementsToDelete);
+
+        final JetNamedFunction function = PsiTreeUtil.getParentOfType(parameter, JetNamedFunction.class);
+        if (function == null || parameter.getParent() != function.getValueParameterList()) return searchInfo;
+
+        final int parameterIndex = function.getValueParameters().indexOf(parameter);
+
+        ReferencesSearch.search(parameter, parameter.getUseScope()).forEach(new Processor<PsiReference>() {
+            @Override
+            public boolean process(PsiReference reference) {
+                PsiElement element = reference.getElement();
+                if (!isInside(element, allElementsToDelete)) {
+                    result.add(new SafeDeleteReferenceSimpleDeleteUsageInfo(element, parameter, false));
+                }
+                return true;
+            }
+        });
+
+        ReferencesSearch.search(function).forEach(
+                new Processor<PsiReference>() {
+                    @Override
+                    public boolean process(PsiReference reference) {
+                        processParameterUsageInCall(reference, function, parameterIndex, result, parameter);
+                        return true;
+                    }
+                }
+        );
+
+        return searchInfo;
+    }
+
+    static void processParameterUsageInCall(
+            PsiReference reference,
+            PsiElement originalDeclaration,
+            int parameterIndex,
+            List<UsageInfo> result,
+            PsiElement parameter
+    ) {
+        PsiElement element = reference.getElement();
+
+        JetCallExpression callExpression =
+                PsiTreeUtil.getParentOfType(reference.getElement(), JetCallExpression.class, false);
+        if (callExpression == null) return;
+
+        JetExpression calleeExpression = callExpression.getCalleeExpression();
+        if (!(calleeExpression instanceof JetReferenceExpression
+              && PsiTreeUtil.isAncestor(calleeExpression, element, false))) return;
+
+        BindingContext bindingContext =
+                AnalyzerFacadeWithCache.analyzeFileWithCache((JetFile) element.getContainingFile()).getBindingContext();
+        DeclarationDescriptor descriptor =
+                bindingContext.get(BindingContext.REFERENCE_TARGET, (JetReferenceExpression) calleeExpression);
+        if (descriptor == null) return;
+
+        PsiElement declaration = BindingContextUtils.descriptorToDeclaration(bindingContext, descriptor);
+        if (originalDeclaration.equals(declaration)) {
+            List<? extends ValueArgument> args = callExpression.getValueArguments();
+            int argCount = args.size();
+            if (parameterIndex < argCount) {
+                result.add(
+                        new SafeDeleteValueArgumentListUsageInfo((JetValueArgument) args.get(parameterIndex), parameter)
+                );
+            }
+            else {
+                List<JetExpression> lambdaArgs = callExpression.getFunctionLiteralArguments();
+                int lambdaIndex = parameterIndex - argCount;
+                if (lambdaIndex < lambdaArgs.size()) {
+                    result.add(new SafeDeleteReferenceSimpleDeleteUsageInfo(lambdaArgs.get(lambdaIndex), parameter, true));
+                }
+            }
+        }
+    }
+
     protected static NonCodeUsageSearchInfo findTypeParameterUsages(
             final JetTypeParameter parameter,
             final PsiElement[] allElementsToDelete,
@@ -635,6 +733,17 @@ public class KotlinSafeDeleteProcessor extends JavaSafeDeleteProcessor {
         }
     }
 
+    private static PsiParameter getPsiParameter(JetParameter parameter) {
+        JetNamedFunction function = PsiTreeUtil.getParentOfType(parameter, JetNamedFunction.class);
+        if (function == null || parameter.getParent() != function.getValueParameterList()) return null;
+
+        PsiMethod lightMethod = LightClassUtil.getLightClassMethod(function);
+        if (lightMethod == null) return null;
+
+        int parameterIndex = function.getValueParameters().indexOf(parameter);
+        return lightMethod.getParameterList().getParameters()[parameterIndex];
+    }
+
     @Override
     public void prepareForDeletion(PsiElement element) throws IncorrectOperationException {
         if (element instanceof PsiMethod) {
@@ -664,6 +773,9 @@ public class KotlinSafeDeleteProcessor extends JavaSafeDeleteProcessor {
         else if (element instanceof JetTypeParameter) {
             deleteElementAndCleanParent(element);
         }
+        else if (element instanceof JetParameter) {
+            JetPsiUtil.deleteElementWithDelimiters(element);
+        }
     }
 
     public static void deleteElementAndCleanParent(PsiElement element) {
@@ -728,7 +840,6 @@ public class KotlinSafeDeleteProcessor extends JavaSafeDeleteProcessor {
         if (superMethods.isEmpty()) return Collections.singletonList(declaration);
 
         List<String> superClasses = getClassDescriptions(bindingContext, superMethods);
-
         return askUserForMethodsToSearch(declaration, callableDescriptor, superMethods, superClasses);
     }
 
@@ -797,6 +908,11 @@ public class KotlinSafeDeleteProcessor extends JavaSafeDeleteProcessor {
     public Collection<? extends PsiElement> getElementsToSearch(
             PsiElement element, @Nullable Module module, Collection<PsiElement> allElementsToDelete
     ) {
+        if (element instanceof JetParameter) {
+            PsiParameter psiParameter = getPsiParameter((JetParameter) element);
+            if (psiParameter != null) return checkParametersInMethodHierarchy(psiParameter);
+        }
+
         if (ApplicationManager.getApplication().isUnitTestMode()) {
             return Collections.singletonList(element);
         }
@@ -804,9 +920,87 @@ public class KotlinSafeDeleteProcessor extends JavaSafeDeleteProcessor {
         if (element instanceof JetNamedFunction || element instanceof JetProperty) {
             return checkSuperMethods((JetDeclaration) element, allElementsToDelete);
         }
+
         return super.getElementsToSearch(element, module, allElementsToDelete);
     }
 
+    private static Collection<? extends PsiElement> checkParametersInMethodHierarchy(PsiParameter parameter) {
+        PsiMethod method = (PsiMethod)parameter.getDeclarationScope();
+        int parameterIndex = method.getParameterList().getParameterIndex(parameter);
+
+        Set<PsiElement> parametersToDelete = collectParametersToDelete(method, parameterIndex);
+        if (parametersToDelete.size() > 1) {
+            if (ApplicationManager.getApplication().isUnitTestMode()) {
+                return parametersToDelete;
+            }
+
+            String message =
+                    JetBundle.message("delete.param.in.method.hierarchy", formatJavaOrLightMethod(method));
+            int exitCode = Messages.showOkCancelDialog(
+                    parameter.getProject(), message, IdeBundle.message("title.warning"), Messages.getQuestionIcon()
+            );
+            if (exitCode == Messages.OK) {
+                return parametersToDelete;
+            }
+            else {
+                return null;
+            }
+        }
+
+        return parametersToDelete;
+    }
+
+    // TODO: generalize breadth-first search
+    private static Set<PsiElement> collectParametersToDelete(PsiMethod method, int parameterIndex) {
+        Deque<PsiMethod> queue = new ArrayDeque<PsiMethod>();
+        Set<PsiMethod> visited = new HashSet<PsiMethod>();
+        Set<PsiElement> parametersToDelete = new HashSet<PsiElement>();
+
+        queue.add(method);
+        while (!queue.isEmpty()) {
+            PsiMethod currentMethod = queue.poll();
+
+            visited.add(currentMethod);
+            addParameter(currentMethod, parametersToDelete, parameterIndex);
+
+            for (PsiMethod superMethod : currentMethod.findSuperMethods(true)) {
+                if (!visited.contains(superMethod)) {
+                    queue.offer(superMethod);
+                }
+            }
+            for (PsiMethod overrider : OverridingMethodsSearch.search(currentMethod)) {
+                if (!visited.contains(overrider)) {
+                    queue.offer(overrider);
+                }
+            }
+        }
+        return parametersToDelete;
+    }
+
+    private static String formatJavaOrLightMethod(PsiMethod method) {
+        if (method instanceof JetClsMethod) {
+            JetDeclaration declaration = ((JetClsMethod) method).getOrigin();
+            BindingContext bindingContext =
+                    AnalyzerFacadeWithCache.analyzeFileWithCache((JetFile) declaration.getContainingFile()).getBindingContext();
+            DeclarationDescriptor descriptor =
+                    bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, declaration);
+            if (descriptor != null) return formatFunctionDescriptor(descriptor);
+        }
+        return formatPsiMethod(method, false, false);
+    }
+
+    private static void addParameter(PsiMethod method, Set<PsiElement> result, int parameterIndex) {
+        if (method instanceof JetClsMethod) {
+            JetDeclaration declaration = ((JetClsMethod) method).getOrigin();
+            if (declaration instanceof JetNamedFunction) {
+                result.add(((JetNamedFunction) declaration).getValueParameters().get(parameterIndex));
+            }
+        }
+        else {
+            result.add(method.getParameterList().getParameters()[parameterIndex]);
+        }
+    }
+
     @Override
     public Collection<PsiElement> getAdditionalElementsToDelete(
             PsiElement element, Collection<PsiElement> allElementsToDelete, boolean askUser
diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/safeDelete/SafeDeleteValueArgumentListUsageInfo.java b/idea/src/org/jetbrains/jet/plugin/refactoring/safeDelete/SafeDeleteValueArgumentListUsageInfo.java
new file mode 100644
index 00000000000..cd0e18468d8
--- /dev/null
+++ b/idea/src/org/jetbrains/jet/plugin/refactoring/safeDelete/SafeDeleteValueArgumentListUsageInfo.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2010-2013 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.plugin.refactoring.safeDelete;
+
+import com.intellij.psi.PsiElement;
+import com.intellij.refactoring.safeDelete.usageInfo.SafeDeleteReferenceSimpleDeleteUsageInfo;
+import com.intellij.util.IncorrectOperationException;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.psi.JetParameter;
+import org.jetbrains.jet.lang.psi.JetPsiUtil;
+import org.jetbrains.jet.lang.psi.JetValueArgument;
+
+public class SafeDeleteValueArgumentListUsageInfo extends SafeDeleteReferenceSimpleDeleteUsageInfo {
+    public SafeDeleteValueArgumentListUsageInfo(@NotNull JetValueArgument valueArgument, @NotNull PsiElement parameter) {
+        super(valueArgument, parameter, true);
+    }
+
+    @Override
+    public void deleteElement() throws IncorrectOperationException {
+        PsiElement element = getElement();
+        if (element != null) {
+            JetPsiUtil.deleteElementWithDelimiters(element);
+        }
+    }
+}
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages1.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages1.kt
new file mode 100644
index 00000000000..5e88adeccfb
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages1.kt
@@ -0,0 +1,49 @@
+trait Z {
+    open fun foo(<caret>a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(1, 2)
+    }
+
+    fun bar(b: B) {
+        b.foo(3, 4)
+    }
+
+    fun bar(c: C) {
+        c.foo(5, 6)
+    }
+
+    fun bar(d: D) {
+        d.foo(7, 8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(9, 10)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages1.kt.after b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages1.kt.after
new file mode 100644
index 00000000000..c64de4d25bf
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages1.kt.after
@@ -0,0 +1,49 @@
+trait Z {
+    open fun foo(b: Int)
+}
+
+open class A {
+    open fun foo(b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(2)
+    }
+
+    fun bar(b: B) {
+        b.foo(4)
+    }
+
+    fun bar(c: C) {
+        c.foo(6)
+    }
+
+    fun bar(d: D) {
+        d.foo(8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(10)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages2.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages2.kt
new file mode 100644
index 00000000000..8a6ea9cb59f
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages2.kt
@@ -0,0 +1,49 @@
+trait Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(<caret>a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(1, 2)
+    }
+
+    fun bar(b: B) {
+        b.foo(3, 4)
+    }
+
+    fun bar(c: C) {
+        c.foo(5, 6)
+    }
+
+    fun bar(d: D) {
+        d.foo(7, 8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(9, 10)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages2.kt.after b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages2.kt.after
new file mode 100644
index 00000000000..c64de4d25bf
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages2.kt.after
@@ -0,0 +1,49 @@
+trait Z {
+    open fun foo(b: Int)
+}
+
+open class A {
+    open fun foo(b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(2)
+    }
+
+    fun bar(b: B) {
+        b.foo(4)
+    }
+
+    fun bar(c: C) {
+        c.foo(6)
+    }
+
+    fun bar(d: D) {
+        d.foo(8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(10)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages3.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages3.kt
new file mode 100644
index 00000000000..f746ce99bb7
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages3.kt
@@ -0,0 +1,49 @@
+trait Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(<caret>a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(1, 2)
+    }
+
+    fun bar(b: B) {
+        b.foo(3, 4)
+    }
+
+    fun bar(c: C) {
+        c.foo(5, 6)
+    }
+
+    fun bar(d: D) {
+        d.foo(7, 8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(9, 10)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages3.kt.after b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages3.kt.after
new file mode 100644
index 00000000000..c64de4d25bf
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages3.kt.after
@@ -0,0 +1,49 @@
+trait Z {
+    open fun foo(b: Int)
+}
+
+open class A {
+    open fun foo(b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(2)
+    }
+
+    fun bar(b: B) {
+        b.foo(4)
+    }
+
+    fun bar(c: C) {
+        c.foo(6)
+    }
+
+    fun bar(d: D) {
+        d.foo(8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(10)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages4.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages4.kt
new file mode 100644
index 00000000000..5916d06f5a2
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages4.kt
@@ -0,0 +1,49 @@
+trait Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(<caret>a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(1, 2)
+    }
+
+    fun bar(b: B) {
+        b.foo(3, 4)
+    }
+
+    fun bar(c: C) {
+        c.foo(5, 6)
+    }
+
+    fun bar(d: D) {
+        d.foo(7, 8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(9, 10)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages4.kt.after b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages4.kt.after
new file mode 100644
index 00000000000..c64de4d25bf
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages4.kt.after
@@ -0,0 +1,49 @@
+trait Z {
+    open fun foo(b: Int)
+}
+
+open class A {
+    open fun foo(b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(2)
+    }
+
+    fun bar(b: B) {
+        b.foo(4)
+    }
+
+    fun bar(c: C) {
+        c.foo(6)
+    }
+
+    fun bar(d: D) {
+        d.foo(8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(10)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages5.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages5.kt
new file mode 100644
index 00000000000..ea5179d3b18
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages5.kt
@@ -0,0 +1,49 @@
+trait Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(<caret>a: Int, b: Int) {
+
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(1, 2)
+    }
+
+    fun bar(b: B) {
+        b.foo(3, 4)
+    }
+
+    fun bar(c: C) {
+        c.foo(5, 6)
+    }
+
+    fun bar(d: D) {
+        d.foo(7, 8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(9, 10)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages5.kt.after b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages5.kt.after
new file mode 100644
index 00000000000..c64de4d25bf
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages5.kt.after
@@ -0,0 +1,49 @@
+trait Z {
+    open fun foo(b: Int)
+}
+
+open class A {
+    open fun foo(b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(2)
+    }
+
+    fun bar(b: B) {
+        b.foo(4)
+    }
+
+    fun bar(c: C) {
+        c.foo(6)
+    }
+
+    fun bar(d: D) {
+        d.foo(8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(10)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages1.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages1.kt
new file mode 100644
index 00000000000..62cb424a473
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages1.kt
@@ -0,0 +1,51 @@
+trait Z {
+    open fun foo(<caret>a: Int, b: Int) {
+        println(a)
+    }
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(1, 2)
+    }
+
+    fun bar(b: B) {
+        b.foo(3, 4)
+    }
+
+    fun bar(c: C) {
+        c.foo(5, 6)
+    }
+
+    fun bar(d: D) {
+        d.foo(7, 8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(9, 10)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages1.kt.messages b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages1.kt.messages
new file mode 100644
index 00000000000..423d0873447
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages1.kt.messages
@@ -0,0 +1,2 @@
+parameter a has 1 usage that is not safe to delete.
+Of those 0 usages are in strings, comments, or non-code files.
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages2.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages2.kt
new file mode 100644
index 00000000000..cfa0d433f9c
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages2.kt
@@ -0,0 +1,49 @@
+trait Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(<caret>a: Int, b: Int) {
+        println(a)
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(1, 2)
+    }
+
+    fun bar(b: B) {
+        b.foo(3, 4)
+    }
+
+    fun bar(c: C) {
+        c.foo(5, 6)
+    }
+
+    fun bar(d: D) {
+        d.foo(7, 8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(9, 10)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages2.kt.messages b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages2.kt.messages
new file mode 100644
index 00000000000..423d0873447
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages2.kt.messages
@@ -0,0 +1,2 @@
+parameter a has 1 usage that is not safe to delete.
+Of those 0 usages are in strings, comments, or non-code files.
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages3.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages3.kt
new file mode 100644
index 00000000000..49b8f5316d4
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages3.kt
@@ -0,0 +1,49 @@
+trait Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(<caret>a: Int, b: Int) {
+        println(a)
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(1, 2)
+    }
+
+    fun bar(b: B) {
+        b.foo(3, 4)
+    }
+
+    fun bar(c: C) {
+        c.foo(5, 6)
+    }
+
+    fun bar(d: D) {
+        d.foo(7, 8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(9, 10)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages3.kt.messages b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages3.kt.messages
new file mode 100644
index 00000000000..423d0873447
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages3.kt.messages
@@ -0,0 +1,2 @@
+parameter a has 1 usage that is not safe to delete.
+Of those 0 usages are in strings, comments, or non-code files.
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages4.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages4.kt
new file mode 100644
index 00000000000..c044d5e4be6
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages4.kt
@@ -0,0 +1,49 @@
+trait Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(<caret>a: Int, b: Int) {
+        println(a)
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(1, 2)
+    }
+
+    fun bar(b: B) {
+        b.foo(3, 4)
+    }
+
+    fun bar(c: C) {
+        c.foo(5, 6)
+    }
+
+    fun bar(d: D) {
+        d.foo(7, 8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(9, 10)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages4.kt.messages b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages4.kt.messages
new file mode 100644
index 00000000000..423d0873447
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages4.kt.messages
@@ -0,0 +1,2 @@
+parameter a has 1 usage that is not safe to delete.
+Of those 0 usages are in strings, comments, or non-code files.
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages5.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages5.kt
new file mode 100644
index 00000000000..d74c754a634
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages5.kt
@@ -0,0 +1,49 @@
+trait Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(<caret>a: Int, b: Int) {
+        println(a)
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(1, 2)
+    }
+
+    fun bar(b: B) {
+        b.foo(3, 4)
+    }
+
+    fun bar(c: C) {
+        c.foo(5, 6)
+    }
+
+    fun bar(d: D) {
+        d.foo(7, 8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(9, 10)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages5.kt.messages b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages5.kt.messages
new file mode 100644
index 00000000000..423d0873447
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages5.kt.messages
@@ -0,0 +1,2 @@
+parameter a has 1 usage that is not safe to delete.
+Of those 0 usages are in strings, comments, or non-code files.
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages6.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages6.kt
new file mode 100644
index 00000000000..c39d67c27b5
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages6.kt
@@ -0,0 +1,51 @@
+trait Z {
+    open fun foo(a: Int, b: Int) {
+        println(a)
+    }
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(<caret>a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(1, 2)
+    }
+
+    fun bar(b: B) {
+        b.foo(3, 4)
+    }
+
+    fun bar(c: C) {
+        c.foo(5, 6)
+    }
+
+    fun bar(d: D) {
+        d.foo(7, 8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(9, 10)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages6.kt.messages b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages6.kt.messages
new file mode 100644
index 00000000000..423d0873447
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages6.kt.messages
@@ -0,0 +1,2 @@
+parameter a has 1 usage that is not safe to delete.
+Of those 0 usages are in strings, comments, or non-code files.
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages7.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages7.kt
new file mode 100644
index 00000000000..eb103648295
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages7.kt
@@ -0,0 +1,49 @@
+trait Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+        println(a)
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(<caret>a: Int, b: Int) {
+
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(1, 2)
+    }
+
+    fun bar(b: B) {
+        b.foo(3, 4)
+    }
+
+    fun bar(c: C) {
+        c.foo(5, 6)
+    }
+
+    fun bar(d: D) {
+        d.foo(7, 8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(9, 10)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages7.kt.messages b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages7.kt.messages
new file mode 100644
index 00000000000..423d0873447
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages7.kt.messages
@@ -0,0 +1,2 @@
+parameter a has 1 usage that is not safe to delete.
+Of those 0 usages are in strings, comments, or non-code files.
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages8.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages8.kt
new file mode 100644
index 00000000000..460454a40b7
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages8.kt
@@ -0,0 +1,49 @@
+trait Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(<caret>a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+        println(a)
+    }
+}
+
+class U {
+    fun bar(a: A) {
+        a.foo(1, 2)
+    }
+
+    fun bar(b: B) {
+        b.foo(3, 4)
+    }
+
+    fun bar(c: C) {
+        c.foo(5, 6)
+    }
+
+    fun bar(d: D) {
+        d.foo(7, 8)
+    }
+
+    fun bar(z: Z) {
+        z.foo(9, 10)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages8.kt.messages b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages8.kt.messages
new file mode 100644
index 00000000000..423d0873447
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages8.kt.messages
@@ -0,0 +1,2 @@
+parameter a has 1 usage that is not safe to delete.
+Of those 0 usages are in strings, comments, or non-code files.
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/internalUsage1.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/internalUsage1.kt
new file mode 100644
index 00000000000..33fe868967d
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/internalUsage1.kt
@@ -0,0 +1,11 @@
+class A {
+    fun foo(<caret>a: Int, b: String, c: Any) {
+        println(a)
+    }
+}
+
+class B {
+    fun bar(a: A) {
+        a.foo(1, "1", "!")
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/internalUsage1.kt.messages b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/internalUsage1.kt.messages
new file mode 100644
index 00000000000..423d0873447
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/internalUsage1.kt.messages
@@ -0,0 +1,2 @@
+parameter a has 1 usage that is not safe to delete.
+Of those 0 usages are in strings, comments, or non-code files.
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/internalUsage2.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/internalUsage2.kt
new file mode 100644
index 00000000000..ef8cb5e00d0
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/internalUsage2.kt
@@ -0,0 +1,11 @@
+class A {
+    fun foo(<caret>a: Int, b: String, c: Any) {
+        println(b)
+    }
+}
+
+class B {
+    fun bar(a: A) {
+        a.foo(1, "1", "!")
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/internalUsage2.kt.after b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/internalUsage2.kt.after
new file mode 100644
index 00000000000..aa3c24b41a5
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/internalUsage2.kt.after
@@ -0,0 +1,11 @@
+class A {
+    fun foo(b: String, c: Any) {
+        println(b)
+    }
+}
+
+class B {
+    fun bar(a: A) {
+        a.foo("1", "!")
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/safeUsages1.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/safeUsages1.kt
new file mode 100644
index 00000000000..d3bbfd09e8a
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/safeUsages1.kt
@@ -0,0 +1,11 @@
+class A {
+    fun foo(<caret>a: Int, b: String, c: Any) {
+
+    }
+}
+
+class B {
+    fun bar(a: A) {
+        a.foo(1, "1", "!")
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/safeUsages1.kt.after b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/safeUsages1.kt.after
new file mode 100644
index 00000000000..eec030ae57f
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/safeUsages1.kt.after
@@ -0,0 +1,11 @@
+class A {
+    fun foo(b: String, c: Any) {
+
+    }
+}
+
+class B {
+    fun bar(a: A) {
+        a.foo("1", "!")
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/safeUsages2.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/safeUsages2.kt
new file mode 100644
index 00000000000..f994b940b44
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/safeUsages2.kt
@@ -0,0 +1,11 @@
+class A {
+    fun foo(a: Int, <caret>b: String, c: Any) {
+
+    }
+}
+
+class B {
+    fun bar(a: A) {
+        a.foo(1, "1", "!")
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/safeUsages2.kt.after b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/safeUsages2.kt.after
new file mode 100644
index 00000000000..7228b1fffb2
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/safeUsages2.kt.after
@@ -0,0 +1,11 @@
+class A {
+    fun foo(a: Int, c: Any) {
+
+    }
+}
+
+class B {
+    fun bar(a: A) {
+        a.foo(1, "!")
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/safeUsages3.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/safeUsages3.kt
new file mode 100644
index 00000000000..19575b0c287
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/safeUsages3.kt
@@ -0,0 +1,11 @@
+class A {
+    fun foo(a: Int, b: String, <caret>c: Any) {
+
+    }
+}
+
+class B {
+    fun bar(a: A) {
+        a.foo(1, "1", "!")
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/safeUsages3.kt.after b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/safeUsages3.kt.after
new file mode 100644
index 00000000000..b8fae8e2f68
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/safeUsages3.kt.after
@@ -0,0 +1,11 @@
+class A {
+    fun foo(a: Int, b: String) {
+
+    }
+}
+
+class B {
+    fun bar(a: A) {
+        a.foo(1, "1")
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages1.java b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages1.java
new file mode 100644
index 00000000000..63b477668e8
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages1.java
@@ -0,0 +1,21 @@
+class U {
+    void bar(A a) {
+        a.foo(1, 2)
+    }
+
+    void bar(B b) {
+        b.foo(1, 2)
+    }
+
+    void bar(C c) {
+        c.foo(1, 2)
+    }
+
+    void bar(D d) {
+        d.foo(1, 2)
+    }
+
+    void bar(Z z) {
+        z.foo(1, 2)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages1.java.after b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages1.java.after
new file mode 100644
index 00000000000..6b9d634dfed
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages1.java.after
@@ -0,0 +1,21 @@
+class U {
+    void bar(A a) {
+        a.foo(2)
+    }
+
+    void bar(B b) {
+        b.foo(2)
+    }
+
+    void bar(C c) {
+        c.foo(2)
+    }
+
+    void bar(D d) {
+        d.foo(2)
+    }
+
+    void bar(Z z) {
+        z.foo(2)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages1.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages1.kt
new file mode 100644
index 00000000000..9cbcb20bcca
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages1.kt
@@ -0,0 +1,27 @@
+trait Z {
+    open fun foo(<caret>a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages1.kt.after b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages1.kt.after
new file mode 100644
index 00000000000..e93267cb7bf
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages1.kt.after
@@ -0,0 +1,27 @@
+trait Z {
+    open fun foo(b: Int)
+}
+
+open class A {
+    open fun foo(b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages2.java b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages2.java
new file mode 100644
index 00000000000..63b477668e8
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages2.java
@@ -0,0 +1,21 @@
+class U {
+    void bar(A a) {
+        a.foo(1, 2)
+    }
+
+    void bar(B b) {
+        b.foo(1, 2)
+    }
+
+    void bar(C c) {
+        c.foo(1, 2)
+    }
+
+    void bar(D d) {
+        d.foo(1, 2)
+    }
+
+    void bar(Z z) {
+        z.foo(1, 2)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages2.java.after b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages2.java.after
new file mode 100644
index 00000000000..6b9d634dfed
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages2.java.after
@@ -0,0 +1,21 @@
+class U {
+    void bar(A a) {
+        a.foo(2)
+    }
+
+    void bar(B b) {
+        b.foo(2)
+    }
+
+    void bar(C c) {
+        c.foo(2)
+    }
+
+    void bar(D d) {
+        d.foo(2)
+    }
+
+    void bar(Z z) {
+        z.foo(2)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages2.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages2.kt
new file mode 100644
index 00000000000..22d113a72d4
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages2.kt
@@ -0,0 +1,27 @@
+trait Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(<caret>a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages2.kt.after b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages2.kt.after
new file mode 100644
index 00000000000..e93267cb7bf
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages2.kt.after
@@ -0,0 +1,27 @@
+trait Z {
+    open fun foo(b: Int)
+}
+
+open class A {
+    open fun foo(b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages3.java b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages3.java
new file mode 100644
index 00000000000..63b477668e8
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages3.java
@@ -0,0 +1,21 @@
+class U {
+    void bar(A a) {
+        a.foo(1, 2)
+    }
+
+    void bar(B b) {
+        b.foo(1, 2)
+    }
+
+    void bar(C c) {
+        c.foo(1, 2)
+    }
+
+    void bar(D d) {
+        d.foo(1, 2)
+    }
+
+    void bar(Z z) {
+        z.foo(1, 2)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages3.java.after b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages3.java.after
new file mode 100644
index 00000000000..6b9d634dfed
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages3.java.after
@@ -0,0 +1,21 @@
+class U {
+    void bar(A a) {
+        a.foo(2)
+    }
+
+    void bar(B b) {
+        b.foo(2)
+    }
+
+    void bar(C c) {
+        c.foo(2)
+    }
+
+    void bar(D d) {
+        d.foo(2)
+    }
+
+    void bar(Z z) {
+        z.foo(2)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages3.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages3.kt
new file mode 100644
index 00000000000..6a87fd84d1d
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages3.kt
@@ -0,0 +1,27 @@
+trait Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(<caret>a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages3.kt.after b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages3.kt.after
new file mode 100644
index 00000000000..e93267cb7bf
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages3.kt.after
@@ -0,0 +1,27 @@
+trait Z {
+    open fun foo(b: Int)
+}
+
+open class A {
+    open fun foo(b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages4.java b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages4.java
new file mode 100644
index 00000000000..63b477668e8
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages4.java
@@ -0,0 +1,21 @@
+class U {
+    void bar(A a) {
+        a.foo(1, 2)
+    }
+
+    void bar(B b) {
+        b.foo(1, 2)
+    }
+
+    void bar(C c) {
+        c.foo(1, 2)
+    }
+
+    void bar(D d) {
+        d.foo(1, 2)
+    }
+
+    void bar(Z z) {
+        z.foo(1, 2)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages4.java.after b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages4.java.after
new file mode 100644
index 00000000000..6b9d634dfed
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages4.java.after
@@ -0,0 +1,21 @@
+class U {
+    void bar(A a) {
+        a.foo(2)
+    }
+
+    void bar(B b) {
+        b.foo(2)
+    }
+
+    void bar(C c) {
+        c.foo(2)
+    }
+
+    void bar(D d) {
+        d.foo(2)
+    }
+
+    void bar(Z z) {
+        z.foo(2)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages4.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages4.kt
new file mode 100644
index 00000000000..35426fea66d
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages4.kt
@@ -0,0 +1,27 @@
+trait Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(<caret>a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages4.kt.after b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages4.kt.after
new file mode 100644
index 00000000000..e93267cb7bf
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages4.kt.after
@@ -0,0 +1,27 @@
+trait Z {
+    open fun foo(b: Int)
+}
+
+open class A {
+    open fun foo(b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages5.java b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages5.java
new file mode 100644
index 00000000000..63b477668e8
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages5.java
@@ -0,0 +1,21 @@
+class U {
+    void bar(A a) {
+        a.foo(1, 2)
+    }
+
+    void bar(B b) {
+        b.foo(1, 2)
+    }
+
+    void bar(C c) {
+        c.foo(1, 2)
+    }
+
+    void bar(D d) {
+        d.foo(1, 2)
+    }
+
+    void bar(Z z) {
+        z.foo(1, 2)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages5.java.after b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages5.java.after
new file mode 100644
index 00000000000..6b9d634dfed
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages5.java.after
@@ -0,0 +1,21 @@
+class U {
+    void bar(A a) {
+        a.foo(2)
+    }
+
+    void bar(B b) {
+        b.foo(2)
+    }
+
+    void bar(C c) {
+        c.foo(2)
+    }
+
+    void bar(D d) {
+        d.foo(2)
+    }
+
+    void bar(Z z) {
+        z.foo(2)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages5.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages5.kt
new file mode 100644
index 00000000000..9210500ac90
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages5.kt
@@ -0,0 +1,27 @@
+trait Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(<caret>a: Int, b: Int) {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages5.kt.after b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages5.kt.after
new file mode 100644
index 00000000000..e93267cb7bf
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages5.kt.after
@@ -0,0 +1,27 @@
+trait Z {
+    open fun foo(b: Int)
+}
+
+open class A {
+    open fun foo(b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages1.java b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages1.java
new file mode 100644
index 00000000000..524af87a028
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages1.java
@@ -0,0 +1,21 @@
+class U {
+    void bar(A a) {
+        a.foo(1, 2)
+    }
+
+    void bar(B b) {
+        b.foo(3, 4)
+    }
+
+    void bar(C c) {
+        c.foo(5, 6)
+    }
+
+    void bar(D d) {
+        d.foo(7, 8)
+    }
+
+    void bar(Z z) {
+        z.foo(9, 10)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages1.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages1.kt
new file mode 100644
index 00000000000..c6e1ea2a8e5
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages1.kt
@@ -0,0 +1,29 @@
+trait Z {
+    open fun foo(<caret>a: Int, b: Int) {
+        println(a)
+    }
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages1.kt.messages b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages1.kt.messages
new file mode 100644
index 00000000000..423d0873447
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages1.kt.messages
@@ -0,0 +1,2 @@
+parameter a has 1 usage that is not safe to delete.
+Of those 0 usages are in strings, comments, or non-code files.
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages2.java b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages2.java
new file mode 100644
index 00000000000..524af87a028
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages2.java
@@ -0,0 +1,21 @@
+class U {
+    void bar(A a) {
+        a.foo(1, 2)
+    }
+
+    void bar(B b) {
+        b.foo(3, 4)
+    }
+
+    void bar(C c) {
+        c.foo(5, 6)
+    }
+
+    void bar(D d) {
+        d.foo(7, 8)
+    }
+
+    void bar(Z z) {
+        z.foo(9, 10)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages2.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages2.kt
new file mode 100644
index 00000000000..d667451af44
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages2.kt
@@ -0,0 +1,27 @@
+trait Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(<caret>a: Int, b: Int) {
+        println(a)
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages2.kt.messages b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages2.kt.messages
new file mode 100644
index 00000000000..423d0873447
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages2.kt.messages
@@ -0,0 +1,2 @@
+parameter a has 1 usage that is not safe to delete.
+Of those 0 usages are in strings, comments, or non-code files.
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages3.java b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages3.java
new file mode 100644
index 00000000000..524af87a028
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages3.java
@@ -0,0 +1,21 @@
+class U {
+    void bar(A a) {
+        a.foo(1, 2)
+    }
+
+    void bar(B b) {
+        b.foo(3, 4)
+    }
+
+    void bar(C c) {
+        c.foo(5, 6)
+    }
+
+    void bar(D d) {
+        d.foo(7, 8)
+    }
+
+    void bar(Z z) {
+        z.foo(9, 10)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages3.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages3.kt
new file mode 100644
index 00000000000..9d9cb9186ce
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages3.kt
@@ -0,0 +1,27 @@
+trait Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(<caret>a: Int, b: Int) {
+        println(a)
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages3.kt.messages b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages3.kt.messages
new file mode 100644
index 00000000000..423d0873447
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages3.kt.messages
@@ -0,0 +1,2 @@
+parameter a has 1 usage that is not safe to delete.
+Of those 0 usages are in strings, comments, or non-code files.
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages4.java b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages4.java
new file mode 100644
index 00000000000..524af87a028
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages4.java
@@ -0,0 +1,21 @@
+class U {
+    void bar(A a) {
+        a.foo(1, 2)
+    }
+
+    void bar(B b) {
+        b.foo(3, 4)
+    }
+
+    void bar(C c) {
+        c.foo(5, 6)
+    }
+
+    void bar(D d) {
+        d.foo(7, 8)
+    }
+
+    void bar(Z z) {
+        z.foo(9, 10)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages4.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages4.kt
new file mode 100644
index 00000000000..7fd34f1033c
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages4.kt
@@ -0,0 +1,27 @@
+trait Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(<caret>a: Int, b: Int) {
+        println(a)
+    }
+}
+
+class D: B(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages4.kt.messages b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages4.kt.messages
new file mode 100644
index 00000000000..423d0873447
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages4.kt.messages
@@ -0,0 +1,2 @@
+parameter a has 1 usage that is not safe to delete.
+Of those 0 usages are in strings, comments, or non-code files.
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages5.java b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages5.java
new file mode 100644
index 00000000000..524af87a028
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages5.java
@@ -0,0 +1,21 @@
+class U {
+    void bar(A a) {
+        a.foo(1, 2)
+    }
+
+    void bar(B b) {
+        b.foo(3, 4)
+    }
+
+    void bar(C c) {
+        c.foo(5, 6)
+    }
+
+    void bar(D d) {
+        d.foo(7, 8)
+    }
+
+    void bar(Z z) {
+        z.foo(9, 10)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages5.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages5.kt
new file mode 100644
index 00000000000..031e52a7eb6
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages5.kt
@@ -0,0 +1,27 @@
+trait Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class A {
+    open fun foo(a: Int, b: Int) {
+
+    }
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class D: B(), Z {
+    override fun foo(<caret>a: Int, b: Int) {
+        println(a)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages5.kt.messages b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages5.kt.messages
new file mode 100644
index 00000000000..423d0873447
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages5.kt.messages
@@ -0,0 +1,2 @@
+parameter a has 1 usage that is not safe to delete.
+Of those 0 usages are in strings, comments, or non-code files.
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/internalUsage1.java b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/internalUsage1.java
new file mode 100644
index 00000000000..620cf416d86
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/internalUsage1.java
@@ -0,0 +1,5 @@
+class B {
+    void bar(A a) {
+        a.foo(1, "1", "!")
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/internalUsage1.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/internalUsage1.kt
new file mode 100644
index 00000000000..8ba1da62309
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/internalUsage1.kt
@@ -0,0 +1,5 @@
+class A {
+    fun foo(<caret>a: Int, b: String, c: Any) {
+        println(a)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/internalUsage1.kt.messages b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/internalUsage1.kt.messages
new file mode 100644
index 00000000000..423d0873447
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/internalUsage1.kt.messages
@@ -0,0 +1,2 @@
+parameter a has 1 usage that is not safe to delete.
+Of those 0 usages are in strings, comments, or non-code files.
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/internalUsage2.java b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/internalUsage2.java
new file mode 100644
index 00000000000..620cf416d86
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/internalUsage2.java
@@ -0,0 +1,5 @@
+class B {
+    void bar(A a) {
+        a.foo(1, "1", "!")
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/internalUsage2.java.after b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/internalUsage2.java.after
new file mode 100644
index 00000000000..203124bdf38
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/internalUsage2.java.after
@@ -0,0 +1,5 @@
+class B {
+    void bar(A a) {
+        a.foo("1", "!")
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/internalUsage2.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/internalUsage2.kt
new file mode 100644
index 00000000000..4483ab8c18c
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/internalUsage2.kt
@@ -0,0 +1,5 @@
+class A {
+    fun foo(<caret>a: Int, b: String, c: Any) {
+        println(b)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/internalUsage2.kt.after b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/internalUsage2.kt.after
new file mode 100644
index 00000000000..132b01c5ae9
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/internalUsage2.kt.after
@@ -0,0 +1,5 @@
+class A {
+    fun foo(b: String, c: Any) {
+        println(b)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy1.java b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy1.java
new file mode 100644
index 00000000000..d43d57f0a6c
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy1.java
@@ -0,0 +1,33 @@
+class A {
+    public void foo(int a, int b) {
+
+    }
+}
+
+class D extends B implements Z {
+    public void foo(int a, int b) {
+
+    }
+}
+
+class U {
+    void bar(A a) {
+        a.foo(1, 2)
+    }
+
+    void bar(B b) {
+        b.foo(3, 4)
+    }
+
+    void bar(C c) {
+        c.foo(5, 6)
+    }
+
+    void bar(D d) {
+        d.foo(7, 8)
+    }
+
+    void bar(Z z) {
+        z.foo(9, 10)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy1.java.after b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy1.java.after
new file mode 100644
index 00000000000..ea230565000
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy1.java.after
@@ -0,0 +1,33 @@
+class A {
+    public void foo(int b) {
+
+    }
+}
+
+class D extends B implements Z {
+    public void foo(int b) {
+
+    }
+}
+
+class U {
+    void bar(A a) {
+        a.foo(2)
+    }
+
+    void bar(B b) {
+        b.foo(4)
+    }
+
+    void bar(C c) {
+        c.foo(6)
+    }
+
+    void bar(D d) {
+        d.foo(8)
+    }
+
+    void bar(Z z) {
+        z.foo(10)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy1.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy1.kt
new file mode 100644
index 00000000000..031e83ea45d
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy1.kt
@@ -0,0 +1,15 @@
+trait Z {
+    open fun foo(<caret>a: Int, b: Int)
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy1.kt.after b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy1.kt.after
new file mode 100644
index 00000000000..dab76e81407
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy1.kt.after
@@ -0,0 +1,15 @@
+trait Z {
+    open fun foo(b: Int)
+}
+
+open class B: A(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(b: Int) {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy2.java b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy2.java
new file mode 100644
index 00000000000..d43d57f0a6c
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy2.java
@@ -0,0 +1,33 @@
+class A {
+    public void foo(int a, int b) {
+
+    }
+}
+
+class D extends B implements Z {
+    public void foo(int a, int b) {
+
+    }
+}
+
+class U {
+    void bar(A a) {
+        a.foo(1, 2)
+    }
+
+    void bar(B b) {
+        b.foo(3, 4)
+    }
+
+    void bar(C c) {
+        c.foo(5, 6)
+    }
+
+    void bar(D d) {
+        d.foo(7, 8)
+    }
+
+    void bar(Z z) {
+        z.foo(9, 10)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy2.java.after b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy2.java.after
new file mode 100644
index 00000000000..ea230565000
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy2.java.after
@@ -0,0 +1,33 @@
+class A {
+    public void foo(int b) {
+
+    }
+}
+
+class D extends B implements Z {
+    public void foo(int b) {
+
+    }
+}
+
+class U {
+    void bar(A a) {
+        a.foo(2)
+    }
+
+    void bar(B b) {
+        b.foo(4)
+    }
+
+    void bar(C c) {
+        c.foo(6)
+    }
+
+    void bar(D d) {
+        d.foo(8)
+    }
+
+    void bar(Z z) {
+        z.foo(10)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy2.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy2.kt
new file mode 100644
index 00000000000..2f77474192d
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy2.kt
@@ -0,0 +1,15 @@
+trait Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class B: A(), Z {
+    override fun foo(<caret>a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy2.kt.after b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy2.kt.after
new file mode 100644
index 00000000000..dab76e81407
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy2.kt.after
@@ -0,0 +1,15 @@
+trait Z {
+    open fun foo(b: Int)
+}
+
+open class B: A(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(b: Int) {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy3.java b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy3.java
new file mode 100644
index 00000000000..d43d57f0a6c
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy3.java
@@ -0,0 +1,33 @@
+class A {
+    public void foo(int a, int b) {
+
+    }
+}
+
+class D extends B implements Z {
+    public void foo(int a, int b) {
+
+    }
+}
+
+class U {
+    void bar(A a) {
+        a.foo(1, 2)
+    }
+
+    void bar(B b) {
+        b.foo(3, 4)
+    }
+
+    void bar(C c) {
+        c.foo(5, 6)
+    }
+
+    void bar(D d) {
+        d.foo(7, 8)
+    }
+
+    void bar(Z z) {
+        z.foo(9, 10)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy3.java.after b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy3.java.after
new file mode 100644
index 00000000000..ea230565000
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy3.java.after
@@ -0,0 +1,33 @@
+class A {
+    public void foo(int b) {
+
+    }
+}
+
+class D extends B implements Z {
+    public void foo(int b) {
+
+    }
+}
+
+class U {
+    void bar(A a) {
+        a.foo(2)
+    }
+
+    void bar(B b) {
+        b.foo(4)
+    }
+
+    void bar(C c) {
+        c.foo(6)
+    }
+
+    void bar(D d) {
+        d.foo(8)
+    }
+
+    void bar(Z z) {
+        z.foo(10)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy3.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy3.kt
new file mode 100644
index 00000000000..7eb4f3b1495
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy3.kt
@@ -0,0 +1,15 @@
+trait Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(<caret>a: Int, b: Int) {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy3.kt.after b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy3.kt.after
new file mode 100644
index 00000000000..dab76e81407
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy3.kt.after
@@ -0,0 +1,15 @@
+trait Z {
+    open fun foo(b: Int)
+}
+
+open class B: A(), Z {
+    override fun foo(b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(b: Int) {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages1.java b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages1.java
new file mode 100644
index 00000000000..daf74bf98fc
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages1.java
@@ -0,0 +1,33 @@
+class A {
+    public void foo(int a, int b) {
+        System.out.println(a);
+    }
+}
+
+class D extends B implements Z {
+    public void foo(int a, int b) {
+
+    }
+}
+
+class U {
+    void bar(A a) {
+        a.foo(1, 2)
+    }
+
+    void bar(B b) {
+        b.foo(3, 4)
+    }
+
+    void bar(C c) {
+        c.foo(5, 6)
+    }
+
+    void bar(D d) {
+        d.foo(7, 8)
+    }
+
+    void bar(Z z) {
+        z.foo(9, 10)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages1.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages1.kt
new file mode 100644
index 00000000000..031e83ea45d
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages1.kt
@@ -0,0 +1,15 @@
+trait Z {
+    open fun foo(<caret>a: Int, b: Int)
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages1.kt.messages b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages1.kt.messages
new file mode 100644
index 00000000000..423d0873447
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages1.kt.messages
@@ -0,0 +1,2 @@
+parameter a has 1 usage that is not safe to delete.
+Of those 0 usages are in strings, comments, or non-code files.
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages2.java b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages2.java
new file mode 100644
index 00000000000..d43d57f0a6c
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages2.java
@@ -0,0 +1,33 @@
+class A {
+    public void foo(int a, int b) {
+
+    }
+}
+
+class D extends B implements Z {
+    public void foo(int a, int b) {
+
+    }
+}
+
+class U {
+    void bar(A a) {
+        a.foo(1, 2)
+    }
+
+    void bar(B b) {
+        b.foo(3, 4)
+    }
+
+    void bar(C c) {
+        c.foo(5, 6)
+    }
+
+    void bar(D d) {
+        d.foo(7, 8)
+    }
+
+    void bar(Z z) {
+        z.foo(9, 10)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages2.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages2.kt
new file mode 100644
index 00000000000..2c98a5a1966
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages2.kt
@@ -0,0 +1,15 @@
+trait Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class B: A(), Z {
+    override fun foo(<caret>a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(a: Int, b: Int) {
+        println(a)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages2.kt.messages b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages2.kt.messages
new file mode 100644
index 00000000000..423d0873447
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages2.kt.messages
@@ -0,0 +1,2 @@
+parameter a has 1 usage that is not safe to delete.
+Of those 0 usages are in strings, comments, or non-code files.
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages3.java b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages3.java
new file mode 100644
index 00000000000..86f33785ebf
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages3.java
@@ -0,0 +1,33 @@
+class A {
+    public void foo(int a, int b) {
+
+    }
+}
+
+class D extends B implements Z {
+    public void foo(int a, int b) {
+        System.out.println(a);
+    }
+}
+
+class U {
+    void bar(A a) {
+        a.foo(1, 2)
+    }
+
+    void bar(B b) {
+        b.foo(3, 4)
+    }
+
+    void bar(C c) {
+        c.foo(5, 6)
+    }
+
+    void bar(D d) {
+        d.foo(7, 8)
+    }
+
+    void bar(Z z) {
+        z.foo(9, 10)
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages3.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages3.kt
new file mode 100644
index 00000000000..7eb4f3b1495
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages3.kt
@@ -0,0 +1,15 @@
+trait Z {
+    open fun foo(a: Int, b: Int)
+}
+
+open class B: A(), Z {
+    override fun foo(a: Int, b: Int) {
+
+    }
+}
+
+class C: A() {
+    override fun foo(<caret>a: Int, b: Int) {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages3.kt.messages b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages3.kt.messages
new file mode 100644
index 00000000000..423d0873447
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages3.kt.messages
@@ -0,0 +1,2 @@
+parameter a has 1 usage that is not safe to delete.
+Of those 0 usages are in strings, comments, or non-code files.
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages1.java b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages1.java
new file mode 100644
index 00000000000..620cf416d86
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages1.java
@@ -0,0 +1,5 @@
+class B {
+    void bar(A a) {
+        a.foo(1, "1", "!")
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages1.java.after b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages1.java.after
new file mode 100644
index 00000000000..203124bdf38
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages1.java.after
@@ -0,0 +1,5 @@
+class B {
+    void bar(A a) {
+        a.foo("1", "!")
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages1.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages1.kt
new file mode 100644
index 00000000000..808c76f7701
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages1.kt
@@ -0,0 +1,5 @@
+class A {
+    fun foo(<caret>a: Int, b: String, c: Any) {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages1.kt.after b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages1.kt.after
new file mode 100644
index 00000000000..5f7c1ec73fa
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages1.kt.after
@@ -0,0 +1,5 @@
+class A {
+    fun foo(b: String, c: Any) {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages2.java b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages2.java
new file mode 100644
index 00000000000..620cf416d86
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages2.java
@@ -0,0 +1,5 @@
+class B {
+    void bar(A a) {
+        a.foo(1, "1", "!")
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages2.java.after b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages2.java.after
new file mode 100644
index 00000000000..5b32c7e946e
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages2.java.after
@@ -0,0 +1,5 @@
+class B {
+    void bar(A a) {
+        a.foo(1, "!")
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages2.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages2.kt
new file mode 100644
index 00000000000..901b76ccab0
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages2.kt
@@ -0,0 +1,5 @@
+class A {
+    fun foo(a: Int, <caret>b: String, c: Any) {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages2.kt.after b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages2.kt.after
new file mode 100644
index 00000000000..787e2a2a297
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages2.kt.after
@@ -0,0 +1,5 @@
+class A {
+    fun foo(a: Int, c: Any) {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages3.java b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages3.java
new file mode 100644
index 00000000000..620cf416d86
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages3.java
@@ -0,0 +1,5 @@
+class B {
+    void bar(A a) {
+        a.foo(1, "1", "!")
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages3.java.after b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages3.java.after
new file mode 100644
index 00000000000..66e1d90b9cb
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages3.java.after
@@ -0,0 +1,5 @@
+class B {
+    void bar(A a) {
+        a.foo(1, "1")
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages3.kt b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages3.kt
new file mode 100644
index 00000000000..074c18ff0b1
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages3.kt
@@ -0,0 +1,5 @@
+class A {
+    fun foo(a: Int, b: String, <caret>c: Any) {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages3.kt.after b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages3.kt.after
new file mode 100644
index 00000000000..9f43362d8f2
--- /dev/null
+++ b/idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages3.kt.after
@@ -0,0 +1,5 @@
+class A {
+    fun foo(a: Int, b: String) {
+
+    }
+}
\ No newline at end of file
diff --git a/idea/tests/org/jetbrains/jet/safeDelete/AbstractJetSafeDeleteTest.java b/idea/tests/org/jetbrains/jet/safeDelete/AbstractJetSafeDeleteTest.java
index 28f9304a31a..d0b5fe7c898 100644
--- a/idea/tests/org/jetbrains/jet/safeDelete/AbstractJetSafeDeleteTest.java
+++ b/idea/tests/org/jetbrains/jet/safeDelete/AbstractJetSafeDeleteTest.java
@@ -23,6 +23,7 @@ import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.openapi.vfs.CharsetToolkit;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiMethod;
+import com.intellij.psi.PsiParameter;
 import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.refactoring.BaseRefactoringProcessor;
 import com.intellij.refactoring.safeDelete.SafeDeleteHandler;
@@ -92,6 +93,14 @@ public abstract class AbstractJetSafeDeleteTest extends LightCodeInsightFixtureT
         doTest(path, JetTypeParameter.class, true);
     }
 
+    public void doValueParameterTest(@NotNull String path) throws Exception {
+        doTest(path, JetParameter.class, false);
+    }
+
+    public void doValueParameterTestWithJava(@NotNull String path) throws Exception {
+        doTest(path, JetParameter.class, true);
+    }
+
     private <T extends PsiElement> void doTest(
             @NotNull String path, @NotNull Class<T> elementClass, boolean withJava) throws Exception {
         String[] filePaths;
diff --git a/idea/tests/org/jetbrains/jet/safeDelete/JetSafeDeleteTestGenerated.java b/idea/tests/org/jetbrains/jet/safeDelete/JetSafeDeleteTestGenerated.java
index f7d6a684df6..3045892f2c8 100644
--- a/idea/tests/org/jetbrains/jet/safeDelete/JetSafeDeleteTestGenerated.java
+++ b/idea/tests/org/jetbrains/jet/safeDelete/JetSafeDeleteTestGenerated.java
@@ -30,7 +30,7 @@ import org.jetbrains.jet.safeDelete.AbstractJetSafeDeleteTest;
 
 /** This class is generated by {@link org.jetbrains.jet.generators.tests.GenerateTests}. DO NOT MODIFY MANUALLY */
 @SuppressWarnings("all")
-@InnerTestClasses({JetSafeDeleteTestGenerated.KotlinClass.class, JetSafeDeleteTestGenerated.KotlinObject.class, JetSafeDeleteTestGenerated.KotlinFunction.class, JetSafeDeleteTestGenerated.KotlinFunctionWithJava.class, JetSafeDeleteTestGenerated.JavaFunctionWithKotlin.class, JetSafeDeleteTestGenerated.KotlinProperty.class, JetSafeDeleteTestGenerated.KotlinPropertyWithJava.class, JetSafeDeleteTestGenerated.JavaPropertyWithKotlin.class, JetSafeDeleteTestGenerated.KotlinTypeParameter.class, JetSafeDeleteTestGenerated.KotlinTypeParameterWithJava.class})
+@InnerTestClasses({JetSafeDeleteTestGenerated.KotlinClass.class, JetSafeDeleteTestGenerated.KotlinObject.class, JetSafeDeleteTestGenerated.KotlinFunction.class, JetSafeDeleteTestGenerated.KotlinFunctionWithJava.class, JetSafeDeleteTestGenerated.JavaFunctionWithKotlin.class, JetSafeDeleteTestGenerated.KotlinProperty.class, JetSafeDeleteTestGenerated.KotlinPropertyWithJava.class, JetSafeDeleteTestGenerated.JavaPropertyWithKotlin.class, JetSafeDeleteTestGenerated.KotlinTypeParameter.class, JetSafeDeleteTestGenerated.KotlinTypeParameterWithJava.class, JetSafeDeleteTestGenerated.KotlinValueParameter.class, JetSafeDeleteTestGenerated.KotlinValueParameterWithJava.class})
 public class JetSafeDeleteTestGenerated extends AbstractJetSafeDeleteTest {
     @TestMetadata("idea/testData/safeDelete/deleteClass/kotlinClass")
     public static class KotlinClass extends AbstractJetSafeDeleteTest {
@@ -632,6 +632,217 @@ public class JetSafeDeleteTestGenerated extends AbstractJetSafeDeleteTest {
         
     }
     
+    @TestMetadata("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter")
+    public static class KotlinValueParameter extends AbstractJetSafeDeleteTest {
+        public void testAllFilesPresentInKotlinValueParameter() throws Exception {
+            JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter"), Pattern.compile("^(.+)\\.kt$"), true);
+        }
+        
+        @TestMetadata("hierarchyWithSafeUsages1.kt")
+        public void testHierarchyWithSafeUsages1() throws Exception {
+            doValueParameterTest("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages1.kt");
+        }
+        
+        @TestMetadata("hierarchyWithSafeUsages2.kt")
+        public void testHierarchyWithSafeUsages2() throws Exception {
+            doValueParameterTest("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages2.kt");
+        }
+        
+        @TestMetadata("hierarchyWithSafeUsages3.kt")
+        public void testHierarchyWithSafeUsages3() throws Exception {
+            doValueParameterTest("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages3.kt");
+        }
+        
+        @TestMetadata("hierarchyWithSafeUsages4.kt")
+        public void testHierarchyWithSafeUsages4() throws Exception {
+            doValueParameterTest("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages4.kt");
+        }
+        
+        @TestMetadata("hierarchyWithSafeUsages5.kt")
+        public void testHierarchyWithSafeUsages5() throws Exception {
+            doValueParameterTest("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithSafeUsages5.kt");
+        }
+        
+        @TestMetadata("hierarchyWithUnsafeUsages1.kt")
+        public void testHierarchyWithUnsafeUsages1() throws Exception {
+            doValueParameterTest("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages1.kt");
+        }
+        
+        @TestMetadata("hierarchyWithUnsafeUsages2.kt")
+        public void testHierarchyWithUnsafeUsages2() throws Exception {
+            doValueParameterTest("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages2.kt");
+        }
+        
+        @TestMetadata("hierarchyWithUnsafeUsages3.kt")
+        public void testHierarchyWithUnsafeUsages3() throws Exception {
+            doValueParameterTest("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages3.kt");
+        }
+        
+        @TestMetadata("hierarchyWithUnsafeUsages4.kt")
+        public void testHierarchyWithUnsafeUsages4() throws Exception {
+            doValueParameterTest("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages4.kt");
+        }
+        
+        @TestMetadata("hierarchyWithUnsafeUsages5.kt")
+        public void testHierarchyWithUnsafeUsages5() throws Exception {
+            doValueParameterTest("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages5.kt");
+        }
+        
+        @TestMetadata("hierarchyWithUnsafeUsages6.kt")
+        public void testHierarchyWithUnsafeUsages6() throws Exception {
+            doValueParameterTest("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages6.kt");
+        }
+        
+        @TestMetadata("hierarchyWithUnsafeUsages7.kt")
+        public void testHierarchyWithUnsafeUsages7() throws Exception {
+            doValueParameterTest("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages7.kt");
+        }
+        
+        @TestMetadata("hierarchyWithUnsafeUsages8.kt")
+        public void testHierarchyWithUnsafeUsages8() throws Exception {
+            doValueParameterTest("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/hierarchyWithUnsafeUsages8.kt");
+        }
+        
+        @TestMetadata("internalUsage1.kt")
+        public void testInternalUsage1() throws Exception {
+            doValueParameterTest("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/internalUsage1.kt");
+        }
+        
+        @TestMetadata("internalUsage2.kt")
+        public void testInternalUsage2() throws Exception {
+            doValueParameterTest("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/internalUsage2.kt");
+        }
+        
+        @TestMetadata("safeUsages1.kt")
+        public void testSafeUsages1() throws Exception {
+            doValueParameterTest("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/safeUsages1.kt");
+        }
+        
+        @TestMetadata("safeUsages2.kt")
+        public void testSafeUsages2() throws Exception {
+            doValueParameterTest("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/safeUsages2.kt");
+        }
+        
+        @TestMetadata("safeUsages3.kt")
+        public void testSafeUsages3() throws Exception {
+            doValueParameterTest("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameter/safeUsages3.kt");
+        }
+        
+    }
+    
+    @TestMetadata("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava")
+    public static class KotlinValueParameterWithJava extends AbstractJetSafeDeleteTest {
+        public void testAllFilesPresentInKotlinValueParameterWithJava() throws Exception {
+            JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava"), Pattern.compile("^(.+)\\.kt$"), true);
+        }
+        
+        @TestMetadata("hierarchyWithSafeUsages1.kt")
+        public void testHierarchyWithSafeUsages1() throws Exception {
+            doValueParameterTestWithJava("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages1.kt");
+        }
+        
+        @TestMetadata("hierarchyWithSafeUsages2.kt")
+        public void testHierarchyWithSafeUsages2() throws Exception {
+            doValueParameterTestWithJava("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages2.kt");
+        }
+        
+        @TestMetadata("hierarchyWithSafeUsages3.kt")
+        public void testHierarchyWithSafeUsages3() throws Exception {
+            doValueParameterTestWithJava("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages3.kt");
+        }
+        
+        @TestMetadata("hierarchyWithSafeUsages4.kt")
+        public void testHierarchyWithSafeUsages4() throws Exception {
+            doValueParameterTestWithJava("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages4.kt");
+        }
+        
+        @TestMetadata("hierarchyWithSafeUsages5.kt")
+        public void testHierarchyWithSafeUsages5() throws Exception {
+            doValueParameterTestWithJava("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithSafeUsages5.kt");
+        }
+        
+        @TestMetadata("hierarchyWithUnsafeUsages1.kt")
+        public void testHierarchyWithUnsafeUsages1() throws Exception {
+            doValueParameterTestWithJava("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages1.kt");
+        }
+        
+        @TestMetadata("hierarchyWithUnsafeUsages2.kt")
+        public void testHierarchyWithUnsafeUsages2() throws Exception {
+            doValueParameterTestWithJava("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages2.kt");
+        }
+        
+        @TestMetadata("hierarchyWithUnsafeUsages3.kt")
+        public void testHierarchyWithUnsafeUsages3() throws Exception {
+            doValueParameterTestWithJava("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages3.kt");
+        }
+        
+        @TestMetadata("hierarchyWithUnsafeUsages4.kt")
+        public void testHierarchyWithUnsafeUsages4() throws Exception {
+            doValueParameterTestWithJava("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages4.kt");
+        }
+        
+        @TestMetadata("hierarchyWithUnsafeUsages5.kt")
+        public void testHierarchyWithUnsafeUsages5() throws Exception {
+            doValueParameterTestWithJava("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/hierarchyWithUnsafeUsages5.kt");
+        }
+        
+        @TestMetadata("internalUsage1.kt")
+        public void testInternalUsage1() throws Exception {
+            doValueParameterTestWithJava("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/internalUsage1.kt");
+        }
+        
+        @TestMetadata("internalUsage2.kt")
+        public void testInternalUsage2() throws Exception {
+            doValueParameterTestWithJava("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/internalUsage2.kt");
+        }
+        
+        @TestMetadata("mixedHierarchy1.kt")
+        public void testMixedHierarchy1() throws Exception {
+            doValueParameterTestWithJava("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy1.kt");
+        }
+        
+        @TestMetadata("mixedHierarchy2.kt")
+        public void testMixedHierarchy2() throws Exception {
+            doValueParameterTestWithJava("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy2.kt");
+        }
+        
+        @TestMetadata("mixedHierarchy3.kt")
+        public void testMixedHierarchy3() throws Exception {
+            doValueParameterTestWithJava("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchy3.kt");
+        }
+        
+        @TestMetadata("mixedHierarchyWithUnsafeUsages1.kt")
+        public void testMixedHierarchyWithUnsafeUsages1() throws Exception {
+            doValueParameterTestWithJava("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages1.kt");
+        }
+        
+        @TestMetadata("mixedHierarchyWithUnsafeUsages2.kt")
+        public void testMixedHierarchyWithUnsafeUsages2() throws Exception {
+            doValueParameterTestWithJava("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages2.kt");
+        }
+        
+        @TestMetadata("mixedHierarchyWithUnsafeUsages3.kt")
+        public void testMixedHierarchyWithUnsafeUsages3() throws Exception {
+            doValueParameterTestWithJava("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/mixedHierarchyWithUnsafeUsages3.kt");
+        }
+        
+        @TestMetadata("safeUsages1.kt")
+        public void testSafeUsages1() throws Exception {
+            doValueParameterTestWithJava("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages1.kt");
+        }
+        
+        @TestMetadata("safeUsages2.kt")
+        public void testSafeUsages2() throws Exception {
+            doValueParameterTestWithJava("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages2.kt");
+        }
+        
+        @TestMetadata("safeUsages3.kt")
+        public void testSafeUsages3() throws Exception {
+            doValueParameterTestWithJava("idea/testData/safeDelete/deleteValueParameter/kotlinValueParameterWithJava/safeUsages3.kt");
+        }
+        
+    }
+    
     public static Test suite() {
         TestSuite suite = new TestSuite("JetSafeDeleteTestGenerated");
         suite.addTestSuite(KotlinClass.class);
@@ -644,6 +855,8 @@ public class JetSafeDeleteTestGenerated extends AbstractJetSafeDeleteTest {
         suite.addTestSuite(JavaPropertyWithKotlin.class);
         suite.addTestSuite(KotlinTypeParameter.class);
         suite.addTestSuite(KotlinTypeParameterWithJava.class);
+        suite.addTestSuite(KotlinValueParameter.class);
+        suite.addTestSuite(KotlinValueParameterWithJava.class);
         return suite;
     }
 }