diff --git a/idea/resources/META-INF/plugin-common.xml b/idea/resources/META-INF/plugin-common.xml index 1be345b31b2..cd4328259e0 100644 --- a/idea/resources/META-INF/plugin-common.xml +++ b/idea/resources/META-INF/plugin-common.xml @@ -3568,6 +3568,15 @@ language="kotlin" /> + + diff --git a/idea/resources/META-INF/plugin-common.xml.191 b/idea/resources/META-INF/plugin-common.xml.191 index 72cbf42c360..117f26f7f53 100644 --- a/idea/resources/META-INF/plugin-common.xml.191 +++ b/idea/resources/META-INF/plugin-common.xml.191 @@ -3569,6 +3569,15 @@ language="kotlin" /> + + diff --git a/idea/resources/META-INF/plugin-common.xml.192 b/idea/resources/META-INF/plugin-common.xml.192 index 72cbf42c360..117f26f7f53 100644 --- a/idea/resources/META-INF/plugin-common.xml.192 +++ b/idea/resources/META-INF/plugin-common.xml.192 @@ -3569,6 +3569,15 @@ language="kotlin" /> + + diff --git a/idea/resources/inspectionDescriptions/RedundantInnerClassModifier.html b/idea/resources/inspectionDescriptions/RedundantInnerClassModifier.html new file mode 100644 index 00000000000..74edb1c3cb9 --- /dev/null +++ b/idea/resources/inspectionDescriptions/RedundantInnerClassModifier.html @@ -0,0 +1,5 @@ + + +This inspection reports a inner class modifier as redundant if no members of outer class are referenced inside. + + diff --git a/idea/src/org/jetbrains/kotlin/idea/inspections/RedundantInnerClassModifierInspection.kt b/idea/src/org/jetbrains/kotlin/idea/inspections/RedundantInnerClassModifierInspection.kt new file mode 100644 index 00000000000..50fbcd16205 --- /dev/null +++ b/idea/src/org/jetbrains/kotlin/idea/inspections/RedundantInnerClassModifierInspection.kt @@ -0,0 +1,81 @@ +/* + * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.idea.inspections + +import com.intellij.codeInspection.IntentionWrapper +import com.intellij.codeInspection.ProblemHighlightType +import com.intellij.codeInspection.ProblemsHolder +import com.intellij.psi.PsiClass +import com.intellij.psi.util.parentsOfType +import org.jetbrains.kotlin.descriptors.ClassDescriptor +import org.jetbrains.kotlin.idea.caches.resolve.analyze +import org.jetbrains.kotlin.idea.caches.resolve.resolveToCall +import org.jetbrains.kotlin.idea.caches.resolve.util.getJavaClassDescriptor +import org.jetbrains.kotlin.idea.quickfix.RemoveModifierFix +import org.jetbrains.kotlin.idea.references.mainReference +import org.jetbrains.kotlin.idea.search.usagesSearch.descriptor +import org.jetbrains.kotlin.lexer.KtTokens +import org.jetbrains.kotlin.psi.* +import org.jetbrains.kotlin.psi.psiUtil.anyDescendantOfType +import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType +import org.jetbrains.kotlin.resolve.BindingContext +import org.jetbrains.kotlin.resolve.descriptorUtil.isSubclassOf +import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode +import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor + +class RedundantInnerClassModifierInspection : AbstractKotlinInspection() { + override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean) = classVisitor(fun(targetClass) { + val innerModifier = targetClass.modifierList?.getModifier(KtTokens.INNER_KEYWORD) ?: return + val outerClasses = targetClass.parentsOfType().dropWhile { it == targetClass }.toSet() + if (outerClasses.isEmpty() || outerClasses.any { it.isLocal || it.isInner() }) return + if (targetClass.hasOuterClassMemberReference(outerClasses)) return + holder.registerProblem( + innerModifier, + "Redundant 'inner' modifier", + ProblemHighlightType.LIKE_UNUSED_SYMBOL, + IntentionWrapper( + RemoveModifierFix(targetClass, KtTokens.INNER_KEYWORD, isRedundant = true), + targetClass.containingFile + ) + ) + }) + + private fun KtClass.hasOuterClassMemberReference(outerClasses: Set): Boolean { + val targetClass = this + val outerClassDescriptors by lazy { + val context = targetClass.analyze(BodyResolveMode.PARTIAL) + outerClasses.mapNotNull { context[BindingContext.DECLARATION_TO_DESCRIPTOR, it] as? ClassDescriptor } + } + val hasSuperType = outerClasses.any { it.getSuperTypeList() != null } + return anyDescendantOfType { expression -> + when (expression) { + is KtNameReferenceExpression -> { + val reference = expression.mainReference.resolve() + val referenceClass = reference?.getStrictParentOfType() + if (expression.getStrictParentOfType() != null) { + return@anyDescendantOfType reference is KtClass && reference.isInner() + || reference is KtPrimaryConstructor && referenceClass?.isInner() == true + } + if (referenceClass != null) { + if (referenceClass == targetClass) return@anyDescendantOfType false + if (referenceClass in outerClasses) return@anyDescendantOfType true + } + if (!hasSuperType) return@anyDescendantOfType false + val referenceClassDescriptor = referenceClass?.descriptor as? ClassDescriptor + ?: reference?.getStrictParentOfType()?.getJavaClassDescriptor() + ?: (expression.resolveToCall()?.resultingDescriptor as? SyntheticJavaPropertyDescriptor) + ?.getMethod?.containingDeclaration as? ClassDescriptor + ?: return@anyDescendantOfType false + outerClassDescriptors.any { outer -> outer.isSubclassOf(referenceClassDescriptor) } + } + is KtThisExpression -> { + expression.resolveToCall()?.resultingDescriptor?.returnType?.constructor?.declarationDescriptor in outerClassDescriptors + } + else -> false + } + } + } +} diff --git a/idea/testData/inspectionsLocal/redundantInnerClassModifier/.inspection b/idea/testData/inspectionsLocal/redundantInnerClassModifier/.inspection new file mode 100644 index 00000000000..6eaead8b4f3 --- /dev/null +++ b/idea/testData/inspectionsLocal/redundantInnerClassModifier/.inspection @@ -0,0 +1 @@ +org.jetbrains.kotlin.idea.inspections.RedundantInnerClassModifierInspection \ No newline at end of file diff --git a/idea/testData/inspectionsLocal/redundantInnerClassModifier/extendClass.kt b/idea/testData/inspectionsLocal/redundantInnerClassModifier/extendClass.kt new file mode 100644 index 00000000000..20d93ef6ca3 --- /dev/null +++ b/idea/testData/inspectionsLocal/redundantInnerClassModifier/extendClass.kt @@ -0,0 +1,7 @@ +class A { + fun a() {} + + open class B + + inner class C : B() +} \ No newline at end of file diff --git a/idea/testData/inspectionsLocal/redundantInnerClassModifier/extendClass.kt.after b/idea/testData/inspectionsLocal/redundantInnerClassModifier/extendClass.kt.after new file mode 100644 index 00000000000..4a09833d2fa --- /dev/null +++ b/idea/testData/inspectionsLocal/redundantInnerClassModifier/extendClass.kt.after @@ -0,0 +1,7 @@ +class A { + fun a() {} + + open class B + + class C : B() +} \ No newline at end of file diff --git a/idea/testData/inspectionsLocal/redundantInnerClassModifier/extendClass2.kt b/idea/testData/inspectionsLocal/redundantInnerClassModifier/extendClass2.kt new file mode 100644 index 00000000000..81a3bc1b868 --- /dev/null +++ b/idea/testData/inspectionsLocal/redundantInnerClassModifier/extendClass2.kt @@ -0,0 +1,7 @@ +class A { + fun a() {} + + open class B(i: Int) + + inner class C(i: Int) : B(i) +} \ No newline at end of file diff --git a/idea/testData/inspectionsLocal/redundantInnerClassModifier/extendClass2.kt.after b/idea/testData/inspectionsLocal/redundantInnerClassModifier/extendClass2.kt.after new file mode 100644 index 00000000000..65a6471186b --- /dev/null +++ b/idea/testData/inspectionsLocal/redundantInnerClassModifier/extendClass2.kt.after @@ -0,0 +1,7 @@ +class A { + fun a() {} + + open class B(i: Int) + + class C(i: Int) : B(i) +} \ No newline at end of file diff --git a/idea/testData/inspectionsLocal/redundantInnerClassModifier/extendInnerClass.kt b/idea/testData/inspectionsLocal/redundantInnerClassModifier/extendInnerClass.kt new file mode 100644 index 00000000000..6e3d06eff7c --- /dev/null +++ b/idea/testData/inspectionsLocal/redundantInnerClassModifier/extendInnerClass.kt @@ -0,0 +1,8 @@ +// PROBLEM: none +class A { + fun a() {} + + open inner class B + + inner class C : B() +} \ No newline at end of file diff --git a/idea/testData/inspectionsLocal/redundantInnerClassModifier/extendInnerClass2.kt b/idea/testData/inspectionsLocal/redundantInnerClassModifier/extendInnerClass2.kt new file mode 100644 index 00000000000..055b35ea753 --- /dev/null +++ b/idea/testData/inspectionsLocal/redundantInnerClassModifier/extendInnerClass2.kt @@ -0,0 +1,8 @@ +// PROBLEM: none +class A { + fun a() {} + + open inner class B(i: Int) + + inner class C(i: Int) : B(i) +} \ No newline at end of file diff --git a/idea/testData/inspectionsLocal/redundantInnerClassModifier/hasOuterClassMemberReference.kt b/idea/testData/inspectionsLocal/redundantInnerClassModifier/hasOuterClassMemberReference.kt new file mode 100644 index 00000000000..725c191732b --- /dev/null +++ b/idea/testData/inspectionsLocal/redundantInnerClassModifier/hasOuterClassMemberReference.kt @@ -0,0 +1,10 @@ +// PROBLEM: none +class A { + fun a() {} + + inner class B { + fun b() { + a() + } + } +} \ No newline at end of file diff --git a/idea/testData/inspectionsLocal/redundantInnerClassModifier/hasOuterClassMemberReference2.kt b/idea/testData/inspectionsLocal/redundantInnerClassModifier/hasOuterClassMemberReference2.kt new file mode 100644 index 00000000000..f0a68631457 --- /dev/null +++ b/idea/testData/inspectionsLocal/redundantInnerClassModifier/hasOuterClassMemberReference2.kt @@ -0,0 +1,10 @@ +// PROBLEM: none +class A { + val a = 1 + + inner class B { + fun b() { + a + } + } +} \ No newline at end of file diff --git a/idea/testData/inspectionsLocal/redundantInnerClassModifier/hasOuterClassMemberReference3.kt b/idea/testData/inspectionsLocal/redundantInnerClassModifier/hasOuterClassMemberReference3.kt new file mode 100644 index 00000000000..a1947db9966 --- /dev/null +++ b/idea/testData/inspectionsLocal/redundantInnerClassModifier/hasOuterClassMemberReference3.kt @@ -0,0 +1,13 @@ +// PROBLEM: none +class A { + fun a() {} + + inner class B { + + inner class C { + fun c() { + a() + } + } + } +} \ No newline at end of file diff --git a/idea/testData/inspectionsLocal/redundantInnerClassModifier/hasOuterClassMemberReference4.kt b/idea/testData/inspectionsLocal/redundantInnerClassModifier/hasOuterClassMemberReference4.kt new file mode 100644 index 00000000000..f950271c4d2 --- /dev/null +++ b/idea/testData/inspectionsLocal/redundantInnerClassModifier/hasOuterClassMemberReference4.kt @@ -0,0 +1,10 @@ +// PROBLEM: none +class A { + fun a() {} + + inner class B { + fun b() { + this@A.a() + } + } +} \ No newline at end of file diff --git a/idea/testData/inspectionsLocal/redundantInnerClassModifier/hasOuterClassMemberReference5.kt b/idea/testData/inspectionsLocal/redundantInnerClassModifier/hasOuterClassMemberReference5.kt new file mode 100644 index 00000000000..e854feb32b7 --- /dev/null +++ b/idea/testData/inspectionsLocal/redundantInnerClassModifier/hasOuterClassMemberReference5.kt @@ -0,0 +1,10 @@ +// PROBLEM: none +class A { + fun a() {} + + inner class B { + fun b() { + this@A + } + } +} \ No newline at end of file diff --git a/idea/testData/inspectionsLocal/redundantInnerClassModifier/hasOuterClassTypeReference.kt b/idea/testData/inspectionsLocal/redundantInnerClassModifier/hasOuterClassTypeReference.kt new file mode 100644 index 00000000000..8aff5b4b205 --- /dev/null +++ b/idea/testData/inspectionsLocal/redundantInnerClassModifier/hasOuterClassTypeReference.kt @@ -0,0 +1,7 @@ +// PROBLEM: none +class A { + inner class B { + fun b(t: T) { + } + } +} \ No newline at end of file diff --git a/idea/testData/inspectionsLocal/redundantInnerClassModifier/hasSuperClassMemberReference.kt b/idea/testData/inspectionsLocal/redundantInnerClassModifier/hasSuperClassMemberReference.kt new file mode 100644 index 00000000000..decc6875892 --- /dev/null +++ b/idea/testData/inspectionsLocal/redundantInnerClassModifier/hasSuperClassMemberReference.kt @@ -0,0 +1,14 @@ +// PROBLEM: none +open class A { + fun a() {} +} + +open class B : A() + +class C : B() { + inner class D { + fun d() { + a() + } + } +} \ No newline at end of file diff --git a/idea/testData/inspectionsLocal/redundantInnerClassModifier/hasSuperJavaClassMemberReference.1.java b/idea/testData/inspectionsLocal/redundantInnerClassModifier/hasSuperJavaClassMemberReference.1.java new file mode 100644 index 00000000000..816568222eb --- /dev/null +++ b/idea/testData/inspectionsLocal/redundantInnerClassModifier/hasSuperJavaClassMemberReference.1.java @@ -0,0 +1,5 @@ +public class Java { + public String getText() { + return ""; + } +} \ No newline at end of file diff --git a/idea/testData/inspectionsLocal/redundantInnerClassModifier/hasSuperJavaClassMemberReference.kt b/idea/testData/inspectionsLocal/redundantInnerClassModifier/hasSuperJavaClassMemberReference.kt new file mode 100644 index 00000000000..4430f3db212 --- /dev/null +++ b/idea/testData/inspectionsLocal/redundantInnerClassModifier/hasSuperJavaClassMemberReference.kt @@ -0,0 +1,8 @@ +// PROBLEM: none +class A : Java() { + inner class B { + fun b() { + getText() + } + } +} \ No newline at end of file diff --git a/idea/testData/inspectionsLocal/redundantInnerClassModifier/hasSuperJavaClassMemberReference2.1.java b/idea/testData/inspectionsLocal/redundantInnerClassModifier/hasSuperJavaClassMemberReference2.1.java new file mode 100644 index 00000000000..816568222eb --- /dev/null +++ b/idea/testData/inspectionsLocal/redundantInnerClassModifier/hasSuperJavaClassMemberReference2.1.java @@ -0,0 +1,5 @@ +public class Java { + public String getText() { + return ""; + } +} \ No newline at end of file diff --git a/idea/testData/inspectionsLocal/redundantInnerClassModifier/hasSuperJavaClassMemberReference2.kt b/idea/testData/inspectionsLocal/redundantInnerClassModifier/hasSuperJavaClassMemberReference2.kt new file mode 100644 index 00000000000..2eac35edf0f --- /dev/null +++ b/idea/testData/inspectionsLocal/redundantInnerClassModifier/hasSuperJavaClassMemberReference2.kt @@ -0,0 +1,8 @@ +// PROBLEM: none +class A : Java() { + inner class B { + fun b() { + text + } + } +} \ No newline at end of file diff --git a/idea/testData/inspectionsLocal/redundantInnerClassModifier/inInnerClass.kt b/idea/testData/inspectionsLocal/redundantInnerClassModifier/inInnerClass.kt new file mode 100644 index 00000000000..e702a103eba --- /dev/null +++ b/idea/testData/inspectionsLocal/redundantInnerClassModifier/inInnerClass.kt @@ -0,0 +1,6 @@ +// PROBLEM: none +class A { + inner class B { + inner class C + } +} \ No newline at end of file diff --git a/idea/testData/inspectionsLocal/redundantInnerClassModifier/inLocalClass.kt b/idea/testData/inspectionsLocal/redundantInnerClassModifier/inLocalClass.kt new file mode 100644 index 00000000000..191b4b02fbd --- /dev/null +++ b/idea/testData/inspectionsLocal/redundantInnerClassModifier/inLocalClass.kt @@ -0,0 +1,6 @@ +// PROBLEM: none +fun test() { + class A { + inner class B + } +} \ No newline at end of file diff --git a/idea/testData/inspectionsLocal/redundantInnerClassModifier/noOuterClassMemberReference.kt b/idea/testData/inspectionsLocal/redundantInnerClassModifier/noOuterClassMemberReference.kt new file mode 100644 index 00000000000..3be4aae1169 --- /dev/null +++ b/idea/testData/inspectionsLocal/redundantInnerClassModifier/noOuterClassMemberReference.kt @@ -0,0 +1,3 @@ +class A { + inner class B +} \ No newline at end of file diff --git a/idea/testData/inspectionsLocal/redundantInnerClassModifier/noOuterClassMemberReference.kt.after b/idea/testData/inspectionsLocal/redundantInnerClassModifier/noOuterClassMemberReference.kt.after new file mode 100644 index 00000000000..4e610ee6db7 --- /dev/null +++ b/idea/testData/inspectionsLocal/redundantInnerClassModifier/noOuterClassMemberReference.kt.after @@ -0,0 +1,3 @@ +class A { + class B +} \ No newline at end of file diff --git a/idea/testData/inspectionsLocal/redundantInnerClassModifier/noOuterClassMemberReference2.kt b/idea/testData/inspectionsLocal/redundantInnerClassModifier/noOuterClassMemberReference2.kt new file mode 100644 index 00000000000..1d6d838ceab --- /dev/null +++ b/idea/testData/inspectionsLocal/redundantInnerClassModifier/noOuterClassMemberReference2.kt @@ -0,0 +1,9 @@ +fun foo() {} + +class A { + inner class B { + fun b() { + foo() + } + } +} \ No newline at end of file diff --git a/idea/testData/inspectionsLocal/redundantInnerClassModifier/noOuterClassMemberReference2.kt.after b/idea/testData/inspectionsLocal/redundantInnerClassModifier/noOuterClassMemberReference2.kt.after new file mode 100644 index 00000000000..6a9be16bebe --- /dev/null +++ b/idea/testData/inspectionsLocal/redundantInnerClassModifier/noOuterClassMemberReference2.kt.after @@ -0,0 +1,9 @@ +fun foo() {} + +class A { + class B { + fun b() { + foo() + } + } +} \ No newline at end of file diff --git a/idea/testData/inspectionsLocal/redundantInnerClassModifier/noOuterClassMemberReference3.kt b/idea/testData/inspectionsLocal/redundantInnerClassModifier/noOuterClassMemberReference3.kt new file mode 100644 index 00000000000..69b226139c0 --- /dev/null +++ b/idea/testData/inspectionsLocal/redundantInnerClassModifier/noOuterClassMemberReference3.kt @@ -0,0 +1,12 @@ +class A { + inner class B { + + fun b() {} + + inner class C { + fun c() { + b() + } + } + } +} \ No newline at end of file diff --git a/idea/testData/inspectionsLocal/redundantInnerClassModifier/noOuterClassMemberReference3.kt.after b/idea/testData/inspectionsLocal/redundantInnerClassModifier/noOuterClassMemberReference3.kt.after new file mode 100644 index 00000000000..930d6b80ff4 --- /dev/null +++ b/idea/testData/inspectionsLocal/redundantInnerClassModifier/noOuterClassMemberReference3.kt.after @@ -0,0 +1,12 @@ +class A { + class B { + + fun b() {} + + inner class C { + fun c() { + b() + } + } + } +} \ No newline at end of file diff --git a/idea/testData/inspectionsLocal/redundantInnerClassModifier/noOuterClassTypeReference.kt b/idea/testData/inspectionsLocal/redundantInnerClassModifier/noOuterClassTypeReference.kt new file mode 100644 index 00000000000..af73fc45b19 --- /dev/null +++ b/idea/testData/inspectionsLocal/redundantInnerClassModifier/noOuterClassTypeReference.kt @@ -0,0 +1,6 @@ +class A { + inner class B { + fun b(t: T) { + } + } +} \ No newline at end of file diff --git a/idea/testData/inspectionsLocal/redundantInnerClassModifier/noOuterClassTypeReference.kt.after b/idea/testData/inspectionsLocal/redundantInnerClassModifier/noOuterClassTypeReference.kt.after new file mode 100644 index 00000000000..9118fb64dce --- /dev/null +++ b/idea/testData/inspectionsLocal/redundantInnerClassModifier/noOuterClassTypeReference.kt.after @@ -0,0 +1,6 @@ +class A { + class B { + fun b(t: T) { + } + } +} \ No newline at end of file diff --git a/idea/tests/org/jetbrains/kotlin/idea/inspections/LocalInspectionTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/inspections/LocalInspectionTestGenerated.java index 6a4f2ece4ee..6e50cc2804d 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/inspections/LocalInspectionTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/inspections/LocalInspectionTestGenerated.java @@ -7376,6 +7376,114 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } } + @TestMetadata("idea/testData/inspectionsLocal/redundantInnerClassModifier") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class RedundantInnerClassModifier extends AbstractLocalInspectionTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInRedundantInnerClassModifier() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantInnerClassModifier"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + } + + @TestMetadata("extendClass.kt") + public void testExtendClass() throws Exception { + runTest("idea/testData/inspectionsLocal/redundantInnerClassModifier/extendClass.kt"); + } + + @TestMetadata("extendClass2.kt") + public void testExtendClass2() throws Exception { + runTest("idea/testData/inspectionsLocal/redundantInnerClassModifier/extendClass2.kt"); + } + + @TestMetadata("extendInnerClass.kt") + public void testExtendInnerClass() throws Exception { + runTest("idea/testData/inspectionsLocal/redundantInnerClassModifier/extendInnerClass.kt"); + } + + @TestMetadata("extendInnerClass2.kt") + public void testExtendInnerClass2() throws Exception { + runTest("idea/testData/inspectionsLocal/redundantInnerClassModifier/extendInnerClass2.kt"); + } + + @TestMetadata("hasOuterClassMemberReference.kt") + public void testHasOuterClassMemberReference() throws Exception { + runTest("idea/testData/inspectionsLocal/redundantInnerClassModifier/hasOuterClassMemberReference.kt"); + } + + @TestMetadata("hasOuterClassMemberReference2.kt") + public void testHasOuterClassMemberReference2() throws Exception { + runTest("idea/testData/inspectionsLocal/redundantInnerClassModifier/hasOuterClassMemberReference2.kt"); + } + + @TestMetadata("hasOuterClassMemberReference3.kt") + public void testHasOuterClassMemberReference3() throws Exception { + runTest("idea/testData/inspectionsLocal/redundantInnerClassModifier/hasOuterClassMemberReference3.kt"); + } + + @TestMetadata("hasOuterClassMemberReference4.kt") + public void testHasOuterClassMemberReference4() throws Exception { + runTest("idea/testData/inspectionsLocal/redundantInnerClassModifier/hasOuterClassMemberReference4.kt"); + } + + @TestMetadata("hasOuterClassMemberReference5.kt") + public void testHasOuterClassMemberReference5() throws Exception { + runTest("idea/testData/inspectionsLocal/redundantInnerClassModifier/hasOuterClassMemberReference5.kt"); + } + + @TestMetadata("hasOuterClassTypeReference.kt") + public void testHasOuterClassTypeReference() throws Exception { + runTest("idea/testData/inspectionsLocal/redundantInnerClassModifier/hasOuterClassTypeReference.kt"); + } + + @TestMetadata("hasSuperClassMemberReference.kt") + public void testHasSuperClassMemberReference() throws Exception { + runTest("idea/testData/inspectionsLocal/redundantInnerClassModifier/hasSuperClassMemberReference.kt"); + } + + @TestMetadata("hasSuperJavaClassMemberReference.kt") + public void testHasSuperJavaClassMemberReference() throws Exception { + runTest("idea/testData/inspectionsLocal/redundantInnerClassModifier/hasSuperJavaClassMemberReference.kt"); + } + + @TestMetadata("hasSuperJavaClassMemberReference2.kt") + public void testHasSuperJavaClassMemberReference2() throws Exception { + runTest("idea/testData/inspectionsLocal/redundantInnerClassModifier/hasSuperJavaClassMemberReference2.kt"); + } + + @TestMetadata("inInnerClass.kt") + public void testInInnerClass() throws Exception { + runTest("idea/testData/inspectionsLocal/redundantInnerClassModifier/inInnerClass.kt"); + } + + @TestMetadata("inLocalClass.kt") + public void testInLocalClass() throws Exception { + runTest("idea/testData/inspectionsLocal/redundantInnerClassModifier/inLocalClass.kt"); + } + + @TestMetadata("noOuterClassMemberReference.kt") + public void testNoOuterClassMemberReference() throws Exception { + runTest("idea/testData/inspectionsLocal/redundantInnerClassModifier/noOuterClassMemberReference.kt"); + } + + @TestMetadata("noOuterClassMemberReference2.kt") + public void testNoOuterClassMemberReference2() throws Exception { + runTest("idea/testData/inspectionsLocal/redundantInnerClassModifier/noOuterClassMemberReference2.kt"); + } + + @TestMetadata("noOuterClassMemberReference3.kt") + public void testNoOuterClassMemberReference3() throws Exception { + runTest("idea/testData/inspectionsLocal/redundantInnerClassModifier/noOuterClassMemberReference3.kt"); + } + + @TestMetadata("noOuterClassTypeReference.kt") + public void testNoOuterClassTypeReference() throws Exception { + runTest("idea/testData/inspectionsLocal/redundantInnerClassModifier/noOuterClassTypeReference.kt"); + } + } + @TestMetadata("idea/testData/inspectionsLocal/redundantLabelMigration") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class)