From d25b2459d4a19c96a135a124016c18e6d87f2ad6 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Sun, 25 May 2014 13:22:30 +0200 Subject: [PATCH] Report clashing signatures in the IDE Expose extra diagnostics about platform signature clashes from light class data #KT-1 In Progress --- .../asJava/KotlinJavaFileStubProvider.java | 31 +++++--- ...otlinLightClassForExplicitDeclaration.java | 2 +- .../jet/asJava/LightClassStubWithData.kt | 13 ++-- .../jet/generators/tests/GenerateTests.kt | 1 + idea/src/META-INF/plugin.xml | 1 + .../DuplicateJvmSignatureAnnotator.java | 72 +++++++++++++++++++ .../jet/plugin/highlighter/JetPsiChecker.java | 20 +++--- .../functionAndProperty/class.kt | 4 ++ .../functionAndProperty/classObject.kt | 6 ++ .../functionAndProperty/localClass.kt | 6 ++ .../functionAndProperty/nestedClass.kt | 6 ++ .../functionAndProperty/object.kt | 4 ++ .../functionAndProperty/objectExpression.kt | 5 ++ .../functionAndProperty/topLevel.kt | 2 + .../checkers/JetPsiCheckerTestGenerated.java | 61 +++++++++++++++- 15 files changed, 210 insertions(+), 24 deletions(-) create mode 100644 idea/src/org/jetbrains/jet/plugin/highlighter/DuplicateJvmSignatureAnnotator.java create mode 100644 idea/testData/checker/duplicateJvmSignature/functionAndProperty/class.kt create mode 100644 idea/testData/checker/duplicateJvmSignature/functionAndProperty/classObject.kt create mode 100644 idea/testData/checker/duplicateJvmSignature/functionAndProperty/localClass.kt create mode 100644 idea/testData/checker/duplicateJvmSignature/functionAndProperty/nestedClass.kt create mode 100644 idea/testData/checker/duplicateJvmSignature/functionAndProperty/object.kt create mode 100644 idea/testData/checker/duplicateJvmSignature/functionAndProperty/objectExpression.kt create mode 100644 idea/testData/checker/duplicateJvmSignature/functionAndProperty/topLevel.kt diff --git a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinJavaFileStubProvider.java b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinJavaFileStubProvider.java index 032c0ac046d..e3ce17134f7 100644 --- a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinJavaFileStubProvider.java +++ b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinJavaFileStubProvider.java @@ -52,13 +52,14 @@ import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingContextUtils; import org.jetbrains.jet.lang.resolve.BindingTraceContext; +import org.jetbrains.jet.lang.resolve.Diagnostics; import org.jetbrains.jet.lang.resolve.name.FqName; import java.util.Collection; import java.util.Collections; import java.util.Map; -public class KotlinJavaFileStubProvider implements CachedValueProvider { +public class KotlinJavaFileStubProvider implements CachedValueProvider { @NotNull public static KotlinJavaFileStubProvider createForPackageClass( @@ -86,8 +87,12 @@ public class KotlinJavaFileStubProvider implements Cache @NotNull @Override - public KotlinPackageLightClassData createLightClassData(PsiJavaFileStub javaFileStub, BindingContext bindingContext) { - return new KotlinPackageLightClassData(javaFileStub); + public KotlinPackageLightClassData createLightClassData( + PsiJavaFileStub javaFileStub, + BindingContext bindingContext, + Diagnostics extraDiagnostics + ) { + return new KotlinPackageLightClassData(javaFileStub, extraDiagnostics); } @NotNull @@ -134,11 +139,15 @@ public class KotlinJavaFileStubProvider implements Cache @NotNull @Override - public OutermostKotlinClassLightClassData createLightClassData(PsiJavaFileStub javaFileStub, BindingContext bindingContext) { + public OutermostKotlinClassLightClassData createLightClassData( + PsiJavaFileStub javaFileStub, + BindingContext bindingContext, + Diagnostics extraDiagnostics + ) { ClassDescriptor classDescriptor = bindingContext.get(BindingContext.CLASS, classOrObject); if (classDescriptor == null) { return new OutermostKotlinClassLightClassData( - javaFileStub, + javaFileStub, extraDiagnostics, "", classOrObject, null, Collections.emptyMap() ); } @@ -164,6 +173,7 @@ public class KotlinJavaFileStubProvider implements Cache return new OutermostKotlinClassLightClassData( javaFileStub, + extraDiagnostics, jvmInternalName, classOrObject, classDescriptor, @@ -264,6 +274,7 @@ public class KotlinJavaFileStubProvider implements Cache PsiJavaFileStub javaFileStub = createJavaFileStub(packageFqName, getRepresentativeVirtualFile(files)); BindingContext bindingContext; + BindingTraceContext forExtraDiagnostics = new BindingTraceContext(); try { Stack stubStack = new Stack(); stubStack.push(javaFileStub); @@ -280,7 +291,7 @@ public class KotlinJavaFileStubProvider implements Cache /*to generate inline flag on methods*/true, null, null, - new BindingTraceContext() // TODO + forExtraDiagnostics ); state.beforeCompile(); @@ -292,7 +303,6 @@ public class KotlinJavaFileStubProvider implements Cache if (pop != javaFileStub) { LOG.error("Unbalanced stack operations: " + pop); } - } catch (ProcessCanceledException e) { throw e; @@ -302,8 +312,9 @@ public class KotlinJavaFileStubProvider implements Cache throw e; } + Diagnostics extraDiagnostics = forExtraDiagnostics.getBindingContext().getDiagnostics(); return Result.create( - stubGenerationStrategy.createLightClassData(javaFileStub, bindingContext), + stubGenerationStrategy.createLightClassData(javaFileStub, bindingContext, extraDiagnostics), local ? PsiModificationTracker.MODIFICATION_COUNT : PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT ); } @@ -362,12 +373,12 @@ public class KotlinJavaFileStubProvider implements Cache cause); } - private interface StubGenerationStrategy { + private interface StubGenerationStrategy { @NotNull Collection getFiles(); @NotNull FqName getPackageFqName(); @NotNull LightClassConstructionContext getContext(@NotNull Collection files); - @NotNull T createLightClassData(PsiJavaFileStub javaFileStub, BindingContext bindingContext); + @NotNull T createLightClassData(PsiJavaFileStub javaFileStub, BindingContext bindingContext, Diagnostics extraDiagnostics); GenerationState.GenerateClassFilter getGenerateClassFilter(); void generate(@NotNull GenerationState state, @NotNull Collection files); diff --git a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightClassForExplicitDeclaration.java b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightClassForExplicitDeclaration.java index c0cf4e75fa3..f9978738e82 100644 --- a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightClassForExplicitDeclaration.java +++ b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightClassForExplicitDeclaration.java @@ -251,7 +251,7 @@ public class KotlinLightClassForExplicitDeclaration extends KotlinWrappingLightC } @NotNull - private static OutermostKotlinClassLightClassData getLightClassData(JetClassOrObject classOrObject) { + public static OutermostKotlinClassLightClassData getLightClassData(JetClassOrObject classOrObject) { JetClassOrObject outermostClassOrObject = getOutermostClassOrObject(classOrObject); return CachedValuesManager.getManager(classOrObject.getProject()).getCachedValue( outermostClassOrObject, diff --git a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/LightClassStubWithData.kt b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/LightClassStubWithData.kt index 7bc3df8b3fd..e6f22850bbf 100644 --- a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/LightClassStubWithData.kt +++ b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/LightClassStubWithData.kt @@ -19,11 +19,14 @@ package org.jetbrains.jet.asJava import com.intellij.psi.impl.java.stubs.PsiJavaFileStub import org.jetbrains.jet.lang.descriptors.ClassDescriptor import org.jetbrains.jet.lang.psi.JetClassOrObject +import org.jetbrains.jet.lang.resolve.BindingContext +import org.jetbrains.jet.lang.resolve.Diagnostics trait LightClassData -trait WithFileStub { +trait WithFileStubAndExtraDiagnostics { val javaFileStub: PsiJavaFileStub + val extraDiagnostics: Diagnostics } trait LightClassDataForKotlinClass: LightClassData { @@ -33,8 +36,9 @@ trait LightClassDataForKotlinClass: LightClassData { } data class KotlinPackageLightClassData( - override val javaFileStub: PsiJavaFileStub -): LightClassData, WithFileStub + override val javaFileStub: PsiJavaFileStub, + override val extraDiagnostics: Diagnostics +): LightClassData, WithFileStubAndExtraDiagnostics data class InnerKotlinClassLightClassData( override val jvmInternalName: String, @@ -44,8 +48,9 @@ data class InnerKotlinClassLightClassData( data class OutermostKotlinClassLightClassData( override val javaFileStub: PsiJavaFileStub, + override val extraDiagnostics: Diagnostics, override val jvmInternalName: String, override val classOrObject: JetClassOrObject, override val descriptor: ClassDescriptor?, val allInnerClasses: Map -): LightClassDataForKotlinClass, WithFileStub \ No newline at end of file +): LightClassDataForKotlinClass, WithFileStubAndExtraDiagnostics \ No newline at end of file diff --git a/generators/src/org/jetbrains/jet/generators/tests/GenerateTests.kt b/generators/src/org/jetbrains/jet/generators/tests/GenerateTests.kt index c0d5d5bda56..2f39ef29612 100644 --- a/generators/src/org/jetbrains/jet/generators/tests/GenerateTests.kt +++ b/generators/src/org/jetbrains/jet/generators/tests/GenerateTests.kt @@ -279,6 +279,7 @@ fun main(args: Array) { model("checker", recursive = false) model("checker/regression") model("checker/rendering") + model("checker/duplicateJvmSignature") model("checker/infos", testMethod = "doTestWithInfos") } diff --git a/idea/src/META-INF/plugin.xml b/idea/src/META-INF/plugin.xml index 4ed61ec01b6..808fb2a6898 100644 --- a/idea/src/META-INF/plugin.xml +++ b/idea/src/META-INF/plugin.xml @@ -277,6 +277,7 @@ + diff --git a/idea/src/org/jetbrains/jet/plugin/highlighter/DuplicateJvmSignatureAnnotator.java b/idea/src/org/jetbrains/jet/plugin/highlighter/DuplicateJvmSignatureAnnotator.java new file mode 100644 index 00000000000..a231e0dcdf6 --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/highlighter/DuplicateJvmSignatureAnnotator.java @@ -0,0 +1,72 @@ +/* + * Copyright 2010-2014 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.highlighter; + +import com.intellij.lang.annotation.AnnotationHolder; +import com.intellij.lang.annotation.Annotator; +import com.intellij.openapi.project.Project; +import com.intellij.psi.PsiElement; +import com.intellij.psi.search.GlobalSearchScope; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.asJava.KotlinLightClassForExplicitDeclaration; +import org.jetbrains.jet.asJava.KotlinLightClassForPackage; +import org.jetbrains.jet.lang.psi.JetClassBody; +import org.jetbrains.jet.lang.psi.JetClassOrObject; +import org.jetbrains.jet.lang.psi.JetFile; +import org.jetbrains.jet.lang.resolve.Diagnostics; +import org.jetbrains.jet.plugin.project.TargetPlatform; +import org.jetbrains.jet.plugin.project.TargetPlatformDetector; + +public class DuplicateJvmSignatureAnnotator implements Annotator { + + @Override + public void annotate(@NotNull PsiElement element, @NotNull AnnotationHolder holder) { + Diagnostics diagnostics; + + PsiElement parent = element.getParent(); + if (parent instanceof JetFile) { + if (TargetPlatformDetector.getPlatform((JetFile) parent) != TargetPlatform.JVM) return; + diagnostics = getDiagnosticsForPackage((JetFile) parent); + } + else if (parent instanceof JetClassBody) { + PsiElement parentsParent = parent.getParent(); + if (!(parentsParent instanceof JetClassOrObject)) return; + + if (TargetPlatformDetector.getPlatform(((JetClassBody) parent).getContainingJetFile()) != TargetPlatform.JVM) return; + + diagnostics = getDiagnosticsForNonLocalClass((JetClassOrObject) parentsParent); + } + else { + return; + } + JetPsiChecker.annotateElement(element, holder, diagnostics); + } + + @NotNull + private static Diagnostics getDiagnosticsForPackage(JetFile file) { + Project project = file.getProject(); + return KotlinLightClassForPackage.FileStubCache.getInstance(project).get( + file.getPackageFqName(), + GlobalSearchScope.allScope(project) + ).getValue().getExtraDiagnostics(); + } + + @NotNull + private static Diagnostics getDiagnosticsForNonLocalClass(JetClassOrObject jetClassOrObject) { + return KotlinLightClassForExplicitDeclaration.getLightClassData(jetClassOrObject).getExtraDiagnostics(); + } +} diff --git a/idea/src/org/jetbrains/jet/plugin/highlighter/JetPsiChecker.java b/idea/src/org/jetbrains/jet/plugin/highlighter/JetPsiChecker.java index 9809b2b53dd..1b7ead53549 100644 --- a/idea/src/org/jetbrains/jet/plugin/highlighter/JetPsiChecker.java +++ b/idea/src/org/jetbrains/jet/plugin/highlighter/JetPsiChecker.java @@ -41,13 +41,12 @@ import org.jetbrains.jet.lang.diagnostics.Errors; import org.jetbrains.jet.lang.diagnostics.Severity; import org.jetbrains.jet.lang.diagnostics.rendering.DefaultErrorMessages; import org.jetbrains.jet.lang.psi.JetCodeFragment; -import org.jetbrains.jet.lang.psi.JetElement; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetReferenceExpression; import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.resolve.Diagnostics; import org.jetbrains.jet.plugin.JetPluginUtil; import org.jetbrains.jet.plugin.caches.resolve.ResolvePackage; -import org.jetbrains.jet.plugin.project.ResolveSessionForBodies; import org.jetbrains.jet.plugin.quickfix.JetIntentionActionsFactory; import org.jetbrains.jet.plugin.quickfix.QuickFixes; @@ -117,12 +116,7 @@ public class JetPsiChecker implements Annotator, HighlightRangeExtension { element.accept(visitor); } - if (JetPluginUtil.isInSource(element, /* includeLibrarySources = */ false) || file instanceof JetCodeFragment) { - ElementAnnotator elementAnnotator = new ElementAnnotator(element, holder); - for (Diagnostic diagnostic : bindingContext.getDiagnostics().forElement(element)) { - elementAnnotator.registerDiagnosticAnnotations(diagnostic); - } - } + annotateElement(element, holder, bindingContext.getDiagnostics()); if (element instanceof JetFile) { //noinspection StaticMethodReferencedViaSubclass @@ -130,6 +124,15 @@ public class JetPsiChecker implements Annotator, HighlightRangeExtension { } } + public static void annotateElement(PsiElement element, AnnotationHolder holder, Diagnostics diagnostics) { + if (JetPluginUtil.isInSource(element, /* includeLibrarySources = */ false) || element.getContainingFile() instanceof JetCodeFragment) { + ElementAnnotator elementAnnotator = new ElementAnnotator(element, holder); + for (Diagnostic diagnostic : diagnostics.forElement(element)) { + elementAnnotator.registerDiagnosticAnnotations(diagnostic); + } + } + } + @Override public boolean isForceHighlightParents(@NotNull PsiFile file) { return file instanceof JetFile; @@ -283,4 +286,5 @@ public class JetPsiChecker implements Annotator, HighlightRangeExtension { return message; } } + } diff --git a/idea/testData/checker/duplicateJvmSignature/functionAndProperty/class.kt b/idea/testData/checker/duplicateJvmSignature/functionAndProperty/class.kt new file mode 100644 index 00000000000..9140b8c8ad9 --- /dev/null +++ b/idea/testData/checker/duplicateJvmSignature/functionAndProperty/class.kt @@ -0,0 +1,4 @@ +class C { + val x = 1 + fun getX() = 1 +} \ No newline at end of file diff --git a/idea/testData/checker/duplicateJvmSignature/functionAndProperty/classObject.kt b/idea/testData/checker/duplicateJvmSignature/functionAndProperty/classObject.kt new file mode 100644 index 00000000000..85ef49331ad --- /dev/null +++ b/idea/testData/checker/duplicateJvmSignature/functionAndProperty/classObject.kt @@ -0,0 +1,6 @@ +class C { + class object { + val x = 1 + fun getX() = 1 + } +} \ No newline at end of file diff --git a/idea/testData/checker/duplicateJvmSignature/functionAndProperty/localClass.kt b/idea/testData/checker/duplicateJvmSignature/functionAndProperty/localClass.kt new file mode 100644 index 00000000000..ced85553267 --- /dev/null +++ b/idea/testData/checker/duplicateJvmSignature/functionAndProperty/localClass.kt @@ -0,0 +1,6 @@ +fun foo() { + class C { + val x = 1 + fun getX() = 1 + } +} \ No newline at end of file diff --git a/idea/testData/checker/duplicateJvmSignature/functionAndProperty/nestedClass.kt b/idea/testData/checker/duplicateJvmSignature/functionAndProperty/nestedClass.kt new file mode 100644 index 00000000000..5455d4a1475 --- /dev/null +++ b/idea/testData/checker/duplicateJvmSignature/functionAndProperty/nestedClass.kt @@ -0,0 +1,6 @@ +class B { + class C { + val x = 1 + fun getX() = 1 + } +} \ No newline at end of file diff --git a/idea/testData/checker/duplicateJvmSignature/functionAndProperty/object.kt b/idea/testData/checker/duplicateJvmSignature/functionAndProperty/object.kt new file mode 100644 index 00000000000..ced024a5983 --- /dev/null +++ b/idea/testData/checker/duplicateJvmSignature/functionAndProperty/object.kt @@ -0,0 +1,4 @@ +object C { + val x = 1 + fun getX() = 1 +} \ No newline at end of file diff --git a/idea/testData/checker/duplicateJvmSignature/functionAndProperty/objectExpression.kt b/idea/testData/checker/duplicateJvmSignature/functionAndProperty/objectExpression.kt new file mode 100644 index 00000000000..3dd729a9772 --- /dev/null +++ b/idea/testData/checker/duplicateJvmSignature/functionAndProperty/objectExpression.kt @@ -0,0 +1,5 @@ +fun foo() = + object { + val x = 1 + fun getX() = 1 + } \ No newline at end of file diff --git a/idea/testData/checker/duplicateJvmSignature/functionAndProperty/topLevel.kt b/idea/testData/checker/duplicateJvmSignature/functionAndProperty/topLevel.kt new file mode 100644 index 00000000000..28d788dd0b0 --- /dev/null +++ b/idea/testData/checker/duplicateJvmSignature/functionAndProperty/topLevel.kt @@ -0,0 +1,2 @@ +val x = 1 +fun getX() = 1 \ No newline at end of file diff --git a/idea/tests/org/jetbrains/jet/checkers/JetPsiCheckerTestGenerated.java b/idea/tests/org/jetbrains/jet/checkers/JetPsiCheckerTestGenerated.java index 1ef3d24ce9b..0f0a32a0bef 100644 --- a/idea/tests/org/jetbrains/jet/checkers/JetPsiCheckerTestGenerated.java +++ b/idea/tests/org/jetbrains/jet/checkers/JetPsiCheckerTestGenerated.java @@ -30,7 +30,7 @@ import org.jetbrains.jet.checkers.AbstractJetPsiCheckerTest; /** This class is generated by {@link org.jetbrains.jet.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ @SuppressWarnings("all") -@InnerTestClasses({JetPsiCheckerTestGenerated.Checker.class, JetPsiCheckerTestGenerated.Regression.class, JetPsiCheckerTestGenerated.Rendering.class, JetPsiCheckerTestGenerated.Infos.class}) +@InnerTestClasses({JetPsiCheckerTestGenerated.Checker.class, JetPsiCheckerTestGenerated.Regression.class, JetPsiCheckerTestGenerated.Rendering.class, JetPsiCheckerTestGenerated.DuplicateJvmSignature.class, JetPsiCheckerTestGenerated.Infos.class}) public class JetPsiCheckerTestGenerated extends AbstractJetPsiCheckerTest { @TestMetadata("idea/testData/checker") public static class Checker extends AbstractJetPsiCheckerTest { @@ -421,6 +421,64 @@ public class JetPsiCheckerTestGenerated extends AbstractJetPsiCheckerTest { } + @TestMetadata("idea/testData/checker/duplicateJvmSignature") + @InnerTestClasses({DuplicateJvmSignature.FunctionAndProperty.class}) + public static class DuplicateJvmSignature extends AbstractJetPsiCheckerTest { + public void testAllFilesPresentInDuplicateJvmSignature() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("idea/testData/checker/duplicateJvmSignature"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("idea/testData/checker/duplicateJvmSignature/functionAndProperty") + public static class FunctionAndProperty extends AbstractJetPsiCheckerTest { + public void testAllFilesPresentInFunctionAndProperty() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("idea/testData/checker/duplicateJvmSignature/functionAndProperty"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("class.kt") + public void testClass() throws Exception { + doTest("idea/testData/checker/duplicateJvmSignature/functionAndProperty/class.kt"); + } + + @TestMetadata("classObject.kt") + public void testClassObject() throws Exception { + doTest("idea/testData/checker/duplicateJvmSignature/functionAndProperty/classObject.kt"); + } + + @TestMetadata("localClass.kt") + public void testLocalClass() throws Exception { + doTest("idea/testData/checker/duplicateJvmSignature/functionAndProperty/localClass.kt"); + } + + @TestMetadata("nestedClass.kt") + public void testNestedClass() throws Exception { + doTest("idea/testData/checker/duplicateJvmSignature/functionAndProperty/nestedClass.kt"); + } + + @TestMetadata("object.kt") + public void testObject() throws Exception { + doTest("idea/testData/checker/duplicateJvmSignature/functionAndProperty/object.kt"); + } + + @TestMetadata("objectExpression.kt") + public void testObjectExpression() throws Exception { + doTest("idea/testData/checker/duplicateJvmSignature/functionAndProperty/objectExpression.kt"); + } + + @TestMetadata("topLevel.kt") + public void testTopLevel() throws Exception { + doTest("idea/testData/checker/duplicateJvmSignature/functionAndProperty/topLevel.kt"); + } + + } + + public static Test innerSuite() { + TestSuite suite = new TestSuite("DuplicateJvmSignature"); + suite.addTestSuite(DuplicateJvmSignature.class); + suite.addTestSuite(FunctionAndProperty.class); + return suite; + } + } + @TestMetadata("idea/testData/checker/infos") public static class Infos extends AbstractJetPsiCheckerTest { public void testAllFilesPresentInInfos() throws Exception { @@ -464,6 +522,7 @@ public class JetPsiCheckerTestGenerated extends AbstractJetPsiCheckerTest { suite.addTestSuite(Checker.class); suite.addTestSuite(Regression.class); suite.addTestSuite(Rendering.class); + suite.addTest(DuplicateJvmSignature.innerSuite()); suite.addTestSuite(Infos.class); return suite; }