From 5d0655247fa18a24cd5710fbd351a13fcf0931a6 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Fri, 20 May 2022 14:58:13 +0300 Subject: [PATCH] [NoArg] Add implementation of plugin for FIR --- .../annotatedAnnotationParameter.kt | 2 +- .../test/runners/AbstractFirDiagnosticTest.kt | 14 +-- .../kotlin/generators/tests/GenerateTests.kt | 9 ++ plugins/noarg/build.gradle.kts | 2 + plugins/noarg/noarg.cli/build.gradle.kts | 2 + .../org/jetbrains/kotlin/noarg/NoArgPlugin.kt | 8 ++ plugins/noarg/noarg.k2/build.gradle.kts | 27 ++++++ .../noarg/fir/FirNoArgCheckersComponent.kt | 17 ++++ .../noarg/fir/FirNoArgDeclarationChecker.kt | 56 ++++++++++++ .../noarg/fir/FirNoArgExtensionRegistrar.kt | 15 ++++ .../kotlin/noarg/fir/KtErrorsNoArg.kt | 17 ++++ .../noarg/fir/NoArgAnnotationNameProvider.kt | 38 ++++++++ .../org/jetbrains/kotlin/noarg/NoArgTests.kt | 29 ++++++- .../testData/diagnostics/innerClass.fir.kt | 14 +++ .../noarg/testData/diagnostics/innerClass.kt | 1 - ...rBlackBoxCodegenTestForNoArgGenerated.java | 87 +++++++++++++++++++ ...rBytecodeListingTestForNoArgGenerated.java | 81 +++++++++++++++++ .../FirDiagnosticsTestForNoArgGenerated.java | 38 ++++++++ settings.gradle | 2 + 19 files changed, 448 insertions(+), 11 deletions(-) create mode 100644 plugins/noarg/noarg.k2/build.gradle.kts create mode 100644 plugins/noarg/noarg.k2/src/org/jetbrains/kotlin/noarg/fir/FirNoArgCheckersComponent.kt create mode 100644 plugins/noarg/noarg.k2/src/org/jetbrains/kotlin/noarg/fir/FirNoArgDeclarationChecker.kt create mode 100644 plugins/noarg/noarg.k2/src/org/jetbrains/kotlin/noarg/fir/FirNoArgExtensionRegistrar.kt create mode 100644 plugins/noarg/noarg.k2/src/org/jetbrains/kotlin/noarg/fir/KtErrorsNoArg.kt create mode 100644 plugins/noarg/noarg.k2/src/org/jetbrains/kotlin/noarg/fir/NoArgAnnotationNameProvider.kt create mode 100644 plugins/noarg/testData/diagnostics/innerClass.fir.kt create mode 100644 plugins/noarg/tests-gen/org/jetbrains/kotlin/noarg/FirBlackBoxCodegenTestForNoArgGenerated.java create mode 100644 plugins/noarg/tests-gen/org/jetbrains/kotlin/noarg/FirBytecodeListingTestForNoArgGenerated.java create mode 100644 plugins/noarg/tests-gen/org/jetbrains/kotlin/noarg/FirDiagnosticsTestForNoArgGenerated.java diff --git a/compiler/testData/codegen/box/annotations/annotatedAnnotationParameter.kt b/compiler/testData/codegen/box/annotations/annotatedAnnotationParameter.kt index 3fffe400397..58594a79a35 100644 --- a/compiler/testData/codegen/box/annotations/annotatedAnnotationParameter.kt +++ b/compiler/testData/codegen/box/annotations/annotatedAnnotationParameter.kt @@ -14,5 +14,5 @@ fun box(): String { val ms = Anno::class.java.declaredMethods return (ms.single { it.name == "o" }.annotations.single() as Name).value + - (ms.single { it.name == "k" }.annotations.single() as Name).value + (ms.single { it.name == "k" }.annotations.single() as Name).value } diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractFirDiagnosticTest.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractFirDiagnosticTest.kt index e96c42b1599..c1894324b6b 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractFirDiagnosticTest.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractFirDiagnosticTest.kt @@ -51,6 +51,14 @@ abstract class AbstractFirDiagnosticsWithLightTreeTest : AbstractFirDiagnosticTe } } +fun TestConfigurationBuilder.configurationForClassicAndFirTestsAlongside() { + useAfterAnalysisCheckers( + ::FirIdenticalChecker, + ::FirFailingTestSuppressor, + ) + useMetaTestConfigurators(::FirOldFrontendMetaConfigurator) +} + // `baseDir` is used in Kotlin plugin from IJ infra fun TestConfigurationBuilder.baseFirDiagnosticTestConfiguration( baseDir: String = ".", @@ -89,11 +97,7 @@ fun TestConfigurationBuilder.baseFirDiagnosticTestConfiguration( useMetaInfoProcessors(::PsiLightTreeMetaInfoProcessor) forTestsMatching("compiler/testData/diagnostics/*") { - useAfterAnalysisCheckers( - ::FirIdenticalChecker, - ::FirFailingTestSuppressor, - ) - useMetaTestConfigurators(::FirOldFrontendMetaConfigurator) + configurationForClassicAndFirTestsAlongside() } forTestsMatching("compiler/fir/analysis-tests/testData/*") { diff --git a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt index ec9e40e76af..9d108ed2c4a 100644 --- a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt +++ b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt @@ -404,18 +404,27 @@ fun main(args: Array) { testClass { model("diagnostics", excludedPattern = excludedFirTestdataPattern) } + testClass { + model("diagnostics", excludedPattern = excludedFirTestdataPattern) + } testClass { model("bytecodeListing", excludedPattern = excludedFirTestdataPattern) } testClass { model("bytecodeListing", excludedPattern = excludedFirTestdataPattern) } + testClass { + model("bytecodeListing", excludedPattern = excludedFirTestdataPattern) + } testClass { model("box") } testClass { model("box") } + testClass { + model("box") + } } } } diff --git a/plugins/noarg/build.gradle.kts b/plugins/noarg/build.gradle.kts index ce100a34ac1..9bb4cedb86e 100644 --- a/plugins/noarg/build.gradle.kts +++ b/plugins/noarg/build.gradle.kts @@ -7,6 +7,7 @@ plugins { dependencies { embedded(project(":kotlin-noarg-compiler-plugin.k1")) + embedded(project(":kotlin-noarg-compiler-plugin.k2")) embedded(project(":kotlin-noarg-compiler-plugin.backend")) embedded(project(":kotlin-noarg-compiler-plugin.cli")) @@ -22,6 +23,7 @@ dependencies { testCompileOnly(project(":kotlin-reflect-api")) testRuntimeOnly(project(":kotlin-reflect")) testRuntimeOnly(project(":core:descriptors.runtime")) + testRuntimeOnly(project(":compiler:fir:fir-serialization")) testApi(intellijCore()) } diff --git a/plugins/noarg/noarg.cli/build.gradle.kts b/plugins/noarg/noarg.cli/build.gradle.kts index 98903a08ae1..b79ad3d8fa1 100644 --- a/plugins/noarg/noarg.cli/build.gradle.kts +++ b/plugins/noarg/noarg.cli/build.gradle.kts @@ -7,9 +7,11 @@ plugins { dependencies { api(project(":kotlin-noarg-compiler-plugin.k1")) + api(project(":kotlin-noarg-compiler-plugin.k2")) api(project(":kotlin-noarg-compiler-plugin.backend")) compileOnly(project(":compiler:util")) compileOnly(project(":compiler:plugin-api")) + compileOnly(project(":compiler:fir:entrypoint")) compileOnly(project(":compiler:backend")) compileOnly(project(":compiler:ir.backend.common")) compileOnly(intellijCore()) diff --git a/plugins/noarg/noarg.cli/src/org/jetbrains/kotlin/noarg/NoArgPlugin.kt b/plugins/noarg/noarg.cli/src/org/jetbrains/kotlin/noarg/NoArgPlugin.kt index 91d9d83873c..f01a3508c25 100644 --- a/plugins/noarg/noarg.cli/src/org/jetbrains/kotlin/noarg/NoArgPlugin.kt +++ b/plugins/noarg/noarg.cli/src/org/jetbrains/kotlin/noarg/NoArgPlugin.kt @@ -17,13 +17,17 @@ import org.jetbrains.kotlin.container.StorageComponentContainer import org.jetbrains.kotlin.container.useInstance import org.jetbrains.kotlin.descriptors.ModuleDescriptor import org.jetbrains.kotlin.extensions.StorageComponentContainerContributor +import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar +import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrarAdapter import org.jetbrains.kotlin.noarg.NoArgCommandLineProcessor.Companion.SUPPORTED_PRESETS import org.jetbrains.kotlin.noarg.NoArgConfigurationKeys.ANNOTATION import org.jetbrains.kotlin.noarg.NoArgConfigurationKeys.INVOKE_INITIALIZERS import org.jetbrains.kotlin.noarg.NoArgConfigurationKeys.PRESET import org.jetbrains.kotlin.noarg.diagnostic.CliNoArgDeclarationChecker +import org.jetbrains.kotlin.noarg.fir.FirNoArgExtensionRegistrar import org.jetbrains.kotlin.platform.TargetPlatform import org.jetbrains.kotlin.platform.jvm.isJvm +import java.util.concurrent.Executors object NoArgConfigurationKeys { val ANNOTATION: CompilerConfigurationKey> = @@ -73,6 +77,9 @@ class NoArgCommandLineProcessor : CommandLineProcessor { } class NoArgComponentRegistrar : ComponentRegistrar { + override val supportsK2: Boolean + get() = true + override fun registerProjectComponents(project: MockProject, configuration: CompilerConfiguration) { val annotations = configuration.get(ANNOTATION).orEmpty().toMutableList() configuration.get(PRESET)?.forEach { preset -> @@ -88,6 +95,7 @@ class NoArgComponentRegistrar : ComponentRegistrar { companion object { fun registerNoArgComponents(project: Project, annotations: List, useIr: Boolean, invokeInitializers: Boolean) { StorageComponentContainerContributor.registerExtension(project, CliNoArgComponentContainerContributor(annotations, useIr)) + FirExtensionRegistrar.registerExtension(project, FirNoArgExtensionRegistrar(annotations)) ExpressionCodegenExtension.registerExtension(project, CliNoArgExpressionCodegenExtension(annotations, invokeInitializers)) IrGenerationExtension.registerExtension(project, NoArgIrGenerationExtension(annotations, invokeInitializers)) } diff --git a/plugins/noarg/noarg.k2/build.gradle.kts b/plugins/noarg/noarg.k2/build.gradle.kts new file mode 100644 index 00000000000..10f1b4c3bd0 --- /dev/null +++ b/plugins/noarg/noarg.k2/build.gradle.kts @@ -0,0 +1,27 @@ +description = "Kotlin NoArg Compiler Plugin (K2)" + +plugins { + kotlin("jvm") + id("jps-compatible") +} + +dependencies { + compileOnly(project(":compiler:fir:cones")) + compileOnly(project(":compiler:fir:tree")) + compileOnly(project(":compiler:fir:resolve")) + compileOnly(project(":compiler:fir:checkers")) + compileOnly(project(":compiler:ir.backend.common")) + compileOnly(project(":compiler:fir:entrypoint")) + + compileOnly(intellijCore()) + runtimeOnly(kotlinStdlib()) +} + +sourceSets { + "main" { projectDefault() } + "test" { none() } +} + +runtimeJar() +sourcesJar() +javadocJar() diff --git a/plugins/noarg/noarg.k2/src/org/jetbrains/kotlin/noarg/fir/FirNoArgCheckersComponent.kt b/plugins/noarg/noarg.k2/src/org/jetbrains/kotlin/noarg/fir/FirNoArgCheckersComponent.kt new file mode 100644 index 00000000000..5479d89c675 --- /dev/null +++ b/plugins/noarg/noarg.k2/src/org/jetbrains/kotlin/noarg/fir/FirNoArgCheckersComponent.kt @@ -0,0 +1,17 @@ +/* + * Copyright 2010-2022 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.noarg.fir + +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.analysis.checkers.declaration.DeclarationCheckers +import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirRegularClassChecker +import org.jetbrains.kotlin.fir.analysis.extensions.FirAdditionalCheckersExtension + +class FirNoArgCheckers(session: FirSession) : FirAdditionalCheckersExtension(session) { + override val declarationCheckers: DeclarationCheckers = object : DeclarationCheckers() { + override val regularClassCheckers: Set = setOf(FirNoArgDeclarationChecker) + } +} diff --git a/plugins/noarg/noarg.k2/src/org/jetbrains/kotlin/noarg/fir/FirNoArgDeclarationChecker.kt b/plugins/noarg/noarg.k2/src/org/jetbrains/kotlin/noarg/fir/FirNoArgDeclarationChecker.kt new file mode 100644 index 00000000000..b600e8e6584 --- /dev/null +++ b/plugins/noarg/noarg.k2/src/org/jetbrains/kotlin/noarg/fir/FirNoArgDeclarationChecker.kt @@ -0,0 +1,56 @@ +/* + * Copyright 2010-2022 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.noarg.fir + +import org.jetbrains.kotlin.descriptors.ClassKind +import org.jetbrains.kotlin.diagnostics.DiagnosticReporter +import org.jetbrains.kotlin.diagnostics.reportOn +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext +import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirRegularClassChecker +import org.jetbrains.kotlin.fir.caches.FirCache +import org.jetbrains.kotlin.fir.caches.firCachesFactory +import org.jetbrains.kotlin.fir.caches.getValue +import org.jetbrains.kotlin.fir.declarations.FirRegularClass +import org.jetbrains.kotlin.fir.declarations.utils.isInner +import org.jetbrains.kotlin.fir.declarations.utils.isLocal +import org.jetbrains.kotlin.fir.extensions.predicateBasedProvider +import org.jetbrains.kotlin.fir.resolve.fullyExpandedType +import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol +import org.jetbrains.kotlin.fir.types.toRegularClassSymbol + +object FirNoArgDeclarationChecker : FirRegularClassChecker() { + override fun check(declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter) { + val source = declaration.source ?: return + if (declaration.classKind != ClassKind.CLASS) return + val matcher = context.session.noArgPredicateMatcher + if (!matcher.isAnnotated(declaration.symbol)) return + + when { + declaration.isInner -> reporter.reportOn(source, KtErrorsNoArg.NOARG_ON_INNER_CLASS_ERROR, context) + declaration.isLocal -> reporter.reportOn(source, KtErrorsNoArg.NOARG_ON_LOCAL_CLASS_ERROR, context) + } + + val superClassSymbol = declaration.symbol.getSuperClassSymbolOrAny(context.session) + if (superClassSymbol.declarationSymbols.filterIsInstance().none { it.isNoArgConstructor() } && !matcher.isAnnotated(superClassSymbol)) { + reporter.reportOn(source, KtErrorsNoArg.NO_NOARG_CONSTRUCTOR_IN_SUPERCLASS, context) + } + + } + + private fun FirRegularClassSymbol.getSuperClassSymbolOrAny(session: FirSession): FirRegularClassSymbol { + for (superType in resolvedSuperTypes) { + val symbol = superType.fullyExpandedType(session).toRegularClassSymbol(session) ?: continue + if (symbol.classKind == ClassKind.CLASS) return symbol + } + return session.builtinTypes.anyType.type.toRegularClassSymbol(session) ?: error("Symbol for Any not found") + } + + private fun FirConstructorSymbol.isNoArgConstructor(): Boolean { + return valueParameterSymbols.all { it.hasDefaultValue } + } +} diff --git a/plugins/noarg/noarg.k2/src/org/jetbrains/kotlin/noarg/fir/FirNoArgExtensionRegistrar.kt b/plugins/noarg/noarg.k2/src/org/jetbrains/kotlin/noarg/fir/FirNoArgExtensionRegistrar.kt new file mode 100644 index 00000000000..0c88e1ec37a --- /dev/null +++ b/plugins/noarg/noarg.k2/src/org/jetbrains/kotlin/noarg/fir/FirNoArgExtensionRegistrar.kt @@ -0,0 +1,15 @@ +/* + * Copyright 2010-2022 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.noarg.fir + +import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar + +class FirNoArgExtensionRegistrar(val noArgAnnotationFqNames: List) : FirExtensionRegistrar() { + override fun ExtensionRegistrarContext.configurePlugin() { + +FirNoArgPredicateMatcher.getFactory(noArgAnnotationFqNames) + +::FirNoArgCheckers + } +} diff --git a/plugins/noarg/noarg.k2/src/org/jetbrains/kotlin/noarg/fir/KtErrorsNoArg.kt b/plugins/noarg/noarg.k2/src/org/jetbrains/kotlin/noarg/fir/KtErrorsNoArg.kt new file mode 100644 index 00000000000..615fe0d7536 --- /dev/null +++ b/plugins/noarg/noarg.k2/src/org/jetbrains/kotlin/noarg/fir/KtErrorsNoArg.kt @@ -0,0 +1,17 @@ +/* + * Copyright 2010-2022 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.noarg.fir + +import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.diagnostics.SourceElementPositioningStrategies +import org.jetbrains.kotlin.diagnostics.error0 +import org.jetbrains.kotlin.diagnostics.warning0 + +object KtErrorsNoArg { + val NO_NOARG_CONSTRUCTOR_IN_SUPERCLASS by warning0(SourceElementPositioningStrategies.NAME_IDENTIFIER) + val NOARG_ON_INNER_CLASS_ERROR by error0(SourceElementPositioningStrategies.NAME_IDENTIFIER) + val NOARG_ON_LOCAL_CLASS_ERROR by error0(SourceElementPositioningStrategies.NAME_IDENTIFIER) +} diff --git a/plugins/noarg/noarg.k2/src/org/jetbrains/kotlin/noarg/fir/NoArgAnnotationNameProvider.kt b/plugins/noarg/noarg.k2/src/org/jetbrains/kotlin/noarg/fir/NoArgAnnotationNameProvider.kt new file mode 100644 index 00000000000..4dade8a79a5 --- /dev/null +++ b/plugins/noarg/noarg.k2/src/org/jetbrains/kotlin/noarg/fir/NoArgAnnotationNameProvider.kt @@ -0,0 +1,38 @@ +/* + * Copyright 2010-2022 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.noarg.fir + +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.FirSessionComponent +import org.jetbrains.kotlin.fir.caches.FirCache +import org.jetbrains.kotlin.fir.caches.firCachesFactory +import org.jetbrains.kotlin.fir.caches.getValue +import org.jetbrains.kotlin.fir.extensions.predicate.has +import org.jetbrains.kotlin.fir.extensions.predicate.metaHas +import org.jetbrains.kotlin.fir.extensions.predicate.or +import org.jetbrains.kotlin.fir.extensions.predicateBasedProvider +import org.jetbrains.kotlin.fir.extensions.utils.AbstractSimpleClassPredicateMatchingService +import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol +import org.jetbrains.kotlin.fir.types.toRegularClassSymbol +import org.jetbrains.kotlin.name.FqName + +class FirNoArgPredicateMatcher( + session: FirSession, + noArgAnnotationFqNames: List +) : AbstractSimpleClassPredicateMatchingService(session) { + companion object { + fun getFactory(noArgAnnotationFqNames: List): Factory { + return Factory { session -> FirNoArgPredicateMatcher(session, noArgAnnotationFqNames) } + } + } + + override val predicate = run { + val annotationFqNames = noArgAnnotationFqNames.map { FqName(it) } + has(annotationFqNames) or metaHas(annotationFqNames) + } +} + +val FirSession.noArgPredicateMatcher: FirNoArgPredicateMatcher by FirSession.sessionComponentAccessor() diff --git a/plugins/noarg/test/org/jetbrains/kotlin/noarg/NoArgTests.kt b/plugins/noarg/test/org/jetbrains/kotlin/noarg/NoArgTests.kt index d8033adeb3a..3a147836047 100644 --- a/plugins/noarg/test/org/jetbrains/kotlin/noarg/NoArgTests.kt +++ b/plugins/noarg/test/org/jetbrains/kotlin/noarg/NoArgTests.kt @@ -12,10 +12,9 @@ import org.jetbrains.kotlin.test.directives.model.DirectivesContainer import org.jetbrains.kotlin.test.directives.model.SimpleDirectivesContainer import org.jetbrains.kotlin.test.model.TestModule import org.jetbrains.kotlin.test.runners.AbstractDiagnosticTest -import org.jetbrains.kotlin.test.runners.codegen.AbstractBlackBoxCodegenTest -import org.jetbrains.kotlin.test.runners.codegen.AbstractBytecodeListingTest -import org.jetbrains.kotlin.test.runners.codegen.AbstractIrBlackBoxCodegenTest -import org.jetbrains.kotlin.test.runners.codegen.AbstractIrBytecodeListingTest +import org.jetbrains.kotlin.test.runners.AbstractFirDiagnosticTest +import org.jetbrains.kotlin.test.runners.codegen.* +import org.jetbrains.kotlin.test.runners.configurationForClassicAndFirTestsAlongside import org.jetbrains.kotlin.test.services.EnvironmentConfigurator import org.jetbrains.kotlin.test.services.TestServices @@ -35,6 +34,13 @@ open class AbstractIrBlackBoxCodegenTestForNoArg : AbstractIrBlackBoxCodegenTest } } +open class AbstractFirBlackBoxCodegenTestForNoArg : AbstractFirBlackBoxCodegenTest() { + override fun configure(builder: TestConfigurationBuilder) { + super.configure(builder) + builder.enableNoArg() + } +} + // ---------------------------- bytecode ---------------------------- open class AbstractBytecodeListingTestForNoArg : AbstractBytecodeListingTest() { @@ -51,6 +57,13 @@ open class AbstractIrBytecodeListingTestForNoArg : AbstractIrBytecodeListingTest } } +open class AbstractFirBytecodeListingTestForNoArg : AbstractFirBytecodeListingTest() { + override fun configure(builder: TestConfigurationBuilder) { + super.configure(builder) + builder.enableNoArg() + } +} + // ---------------------------- diagnostic ---------------------------- abstract class AbstractDiagnosticsTestForNoArg : AbstractDiagnosticTest() { @@ -60,6 +73,14 @@ abstract class AbstractDiagnosticsTestForNoArg : AbstractDiagnosticTest() { } } +abstract class AbstractFirDiagnosticsTestForNoArg : AbstractFirDiagnosticTest() { + override fun configure(builder: TestConfigurationBuilder) { + super.configure(builder) + builder.configurationForClassicAndFirTestsAlongside() + builder.enableNoArg() + } +} + // ---------------------------- configurator ---------------------------- private fun TestConfigurationBuilder.enableNoArg() { diff --git a/plugins/noarg/testData/diagnostics/innerClass.fir.kt b/plugins/noarg/testData/diagnostics/innerClass.fir.kt new file mode 100644 index 00000000000..3f0c80e2ed6 --- /dev/null +++ b/plugins/noarg/testData/diagnostics/innerClass.fir.kt @@ -0,0 +1,14 @@ +annotation class NoArg + +class Outer { + @NoArg + inner class Inner(val b: Any) +} + +fun local() { + @NoArg + class Local(val l: Any) { + @NoArg + inner class InnerLocal(val x: Any) + } +} diff --git a/plugins/noarg/testData/diagnostics/innerClass.kt b/plugins/noarg/testData/diagnostics/innerClass.kt index e2969727f92..f7bbfb9d26c 100644 --- a/plugins/noarg/testData/diagnostics/innerClass.kt +++ b/plugins/noarg/testData/diagnostics/innerClass.kt @@ -1,4 +1,3 @@ -// FIR_IDENTICAL annotation class NoArg class Outer { diff --git a/plugins/noarg/tests-gen/org/jetbrains/kotlin/noarg/FirBlackBoxCodegenTestForNoArgGenerated.java b/plugins/noarg/tests-gen/org/jetbrains/kotlin/noarg/FirBlackBoxCodegenTestForNoArgGenerated.java new file mode 100644 index 00000000000..d4ee3a42577 --- /dev/null +++ b/plugins/noarg/tests-gen/org/jetbrains/kotlin/noarg/FirBlackBoxCodegenTestForNoArgGenerated.java @@ -0,0 +1,87 @@ +/* + * Copyright 2010-2021 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.noarg; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.kotlin.test.TargetBackend; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("plugins/noarg/testData/box") +@TestDataPath("$PROJECT_ROOT") +public class FirBlackBoxCodegenTestForNoArgGenerated extends AbstractFirBlackBoxCodegenTestForNoArg { + @Test + public void testAllFilesPresentInBox() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/noarg/testData/box"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("initializers.kt") + public void testInitializers() throws Exception { + runTest("plugins/noarg/testData/box/initializers.kt"); + } + + @Test + @TestMetadata("initializersWithoutInvokeInitializers.kt") + public void testInitializersWithoutInvokeInitializers() throws Exception { + runTest("plugins/noarg/testData/box/initializersWithoutInvokeInitializers.kt"); + } + + @Test + @TestMetadata("kt18245.kt") + public void testKt18245() throws Exception { + runTest("plugins/noarg/testData/box/kt18245.kt"); + } + + @Test + @TestMetadata("kt18667.kt") + public void testKt18667() throws Exception { + runTest("plugins/noarg/testData/box/kt18667.kt"); + } + + @Test + @TestMetadata("kt18668.kt") + public void testKt18668() throws Exception { + runTest("plugins/noarg/testData/box/kt18668.kt"); + } + + @Test + @TestMetadata("localClassInInitiailzer.kt") + public void testLocalClassInInitiailzer() throws Exception { + runTest("plugins/noarg/testData/box/localClassInInitiailzer.kt"); + } + + @Test + @TestMetadata("nestedClass.kt") + public void testNestedClass() throws Exception { + runTest("plugins/noarg/testData/box/nestedClass.kt"); + } + + @Test + @TestMetadata("sealedClassWithExistingNoargCtor.kt") + public void testSealedClassWithExistingNoargCtor() throws Exception { + runTest("plugins/noarg/testData/box/sealedClassWithExistingNoargCtor.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("plugins/noarg/testData/box/simple.kt"); + } + + @Test + @TestMetadata("subclass.kt") + public void testSubclass() throws Exception { + runTest("plugins/noarg/testData/box/subclass.kt"); + } +} diff --git a/plugins/noarg/tests-gen/org/jetbrains/kotlin/noarg/FirBytecodeListingTestForNoArgGenerated.java b/plugins/noarg/tests-gen/org/jetbrains/kotlin/noarg/FirBytecodeListingTestForNoArgGenerated.java new file mode 100644 index 00000000000..c6886836ac3 --- /dev/null +++ b/plugins/noarg/tests-gen/org/jetbrains/kotlin/noarg/FirBytecodeListingTestForNoArgGenerated.java @@ -0,0 +1,81 @@ +/* + * Copyright 2010-2021 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.noarg; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.kotlin.test.TargetBackend; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("plugins/noarg/testData/bytecodeListing") +@TestDataPath("$PROJECT_ROOT") +public class FirBytecodeListingTestForNoArgGenerated extends AbstractFirBytecodeListingTestForNoArg { + @Test + public void testAllFilesPresentInBytecodeListing() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/noarg/testData/bytecodeListing"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("annoOnNotClass.kt") + public void testAnnoOnNotClass() throws Exception { + runTest("plugins/noarg/testData/bytecodeListing/annoOnNotClass.kt"); + } + + @Test + @TestMetadata("constructorVisibility.kt") + public void testConstructorVisibility() throws Exception { + runTest("plugins/noarg/testData/bytecodeListing/constructorVisibility.kt"); + } + + @Test + @TestMetadata("defaultParameters.kt") + public void testDefaultParameters() throws Exception { + runTest("plugins/noarg/testData/bytecodeListing/defaultParameters.kt"); + } + + @Test + @TestMetadata("inherited.kt") + public void testInherited() throws Exception { + runTest("plugins/noarg/testData/bytecodeListing/inherited.kt"); + } + + @Test + @TestMetadata("nestedClass.kt") + public void testNestedClass() throws Exception { + runTest("plugins/noarg/testData/bytecodeListing/nestedClass.kt"); + } + + @Test + @TestMetadata("noNoArg.kt") + public void testNoNoArg() throws Exception { + runTest("plugins/noarg/testData/bytecodeListing/noNoArg.kt"); + } + + @Test + @TestMetadata("severalNoArg.kt") + public void testSeveralNoArg() throws Exception { + runTest("plugins/noarg/testData/bytecodeListing/severalNoArg.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("plugins/noarg/testData/bytecodeListing/simple.kt"); + } + + @Test + @TestMetadata("superTypes.kt") + public void testSuperTypes() throws Exception { + runTest("plugins/noarg/testData/bytecodeListing/superTypes.kt"); + } +} diff --git a/plugins/noarg/tests-gen/org/jetbrains/kotlin/noarg/FirDiagnosticsTestForNoArgGenerated.java b/plugins/noarg/tests-gen/org/jetbrains/kotlin/noarg/FirDiagnosticsTestForNoArgGenerated.java new file mode 100644 index 00000000000..b9bb524d7fb --- /dev/null +++ b/plugins/noarg/tests-gen/org/jetbrains/kotlin/noarg/FirDiagnosticsTestForNoArgGenerated.java @@ -0,0 +1,38 @@ +/* + * Copyright 2010-2021 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.noarg; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("plugins/noarg/testData/diagnostics") +@TestDataPath("$PROJECT_ROOT") +public class FirDiagnosticsTestForNoArgGenerated extends AbstractFirDiagnosticsTestForNoArg { + @Test + public void testAllFilesPresentInDiagnostics() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/noarg/testData/diagnostics"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @Test + @TestMetadata("innerClass.kt") + public void testInnerClass() throws Exception { + runTest("plugins/noarg/testData/diagnostics/innerClass.kt"); + } + + @Test + @TestMetadata("noNoargCtorInSuperclass.kt") + public void testNoNoargCtorInSuperclass() throws Exception { + runTest("plugins/noarg/testData/diagnostics/noNoargCtorInSuperclass.kt"); + } +} diff --git a/settings.gradle b/settings.gradle index 034a5321cbb..364368756c4 100644 --- a/settings.gradle +++ b/settings.gradle @@ -195,6 +195,7 @@ include ":kotlin-allopen-compiler-plugin", include ":kotlin-noarg-compiler-plugin", ":kotlin-noarg-compiler-plugin.k1", + ":kotlin-noarg-compiler-plugin.k2", ":kotlin-noarg-compiler-plugin.backend", ":kotlin-noarg-compiler-plugin.cli" @@ -692,6 +693,7 @@ project(':kotlin-allopen-compiler-plugin.k1').projectDir = "$rootDir/plugins/all project(':kotlin-allopen-compiler-plugin.k2').projectDir = "$rootDir/plugins/allopen/allopen.k2" as File project(':kotlin-noarg-compiler-plugin').projectDir = "$rootDir/plugins/noarg" as File project(':kotlin-noarg-compiler-plugin.k1').projectDir = "$rootDir/plugins/noarg/noarg.k1" as File +project(':kotlin-noarg-compiler-plugin.k2').projectDir = "$rootDir/plugins/noarg/noarg.k2" as File project(':kotlin-noarg-compiler-plugin.backend').projectDir = "$rootDir/plugins/noarg/noarg.backend" as File project(':kotlin-noarg-compiler-plugin.cli').projectDir = "$rootDir/plugins/noarg/noarg.cli" as File project(':kotlin-sam-with-receiver-compiler-plugin').projectDir = "$rootDir/plugins/sam-with-receiver/sam-with-receiver-cli" as File