[NoArg] Add implementation of plugin for FIR

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
 }

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/*") {

generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt

@@ -404,18 +404,27 @@ fun main(args: Array<String>) {
             testClass<AbstractDiagnosticsTestForNoArg> {
                 model("diagnostics", excludedPattern = excludedFirTestdataPattern)
             }
+            testClass<AbstractFirDiagnosticsTestForNoArg> {
+                model("diagnostics", excludedPattern = excludedFirTestdataPattern)
+            }
             testClass<AbstractBytecodeListingTestForNoArg> {
                 model("bytecodeListing", excludedPattern = excludedFirTestdataPattern)
             }
             testClass<AbstractIrBytecodeListingTestForNoArg> {
                 model("bytecodeListing", excludedPattern = excludedFirTestdataPattern)
             }
+            testClass<AbstractFirBytecodeListingTestForNoArg> {
+                model("bytecodeListing", excludedPattern = excludedFirTestdataPattern)
+            }
             testClass<AbstractBlackBoxCodegenTestForNoArg> {
                 model("box")
             }
             testClass<AbstractIrBlackBoxCodegenTestForNoArg> {
                 model("box")
             }
+            testClass<AbstractFirBlackBoxCodegenTestForNoArg> {
+                model("box")
+            }
         }
     }
 }

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())
 }

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())

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<List<String>> =
@@ -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<String>, 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))
         }

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()

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<FirRegularClassChecker> = setOf(FirNoArgDeclarationChecker)
+    }
+}

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<FirConstructorSymbol>().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 }
+    }
+}

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<String>) : FirExtensionRegistrar() {
+    override fun ExtensionRegistrarContext.configurePlugin() {
+        +FirNoArgPredicateMatcher.getFactory(noArgAnnotationFqNames)
+        +::FirNoArgCheckers
+    }
+}

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<PsiElement>(SourceElementPositioningStrategies.NAME_IDENTIFIER)
+    val NOARG_ON_INNER_CLASS_ERROR by error0<PsiElement>(SourceElementPositioningStrategies.NAME_IDENTIFIER)
+    val NOARG_ON_LOCAL_CLASS_ERROR by error0<PsiElement>(SourceElementPositioningStrategies.NAME_IDENTIFIER)
+}

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<String>
+) : AbstractSimpleClassPredicateMatchingService(session) {
+    companion object {
+        fun getFactory(noArgAnnotationFqNames: List<String>): 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()

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() {

plugins/noarg/testData/diagnostics/innerClass.fir.kt

@@ -0,0 +1,14 @@
+annotation class NoArg
+
+class Outer {
+    @NoArg
+    inner class <!NOARG_ON_INNER_CLASS_ERROR!>Inner<!>(val b: Any)
+}
+
+fun local() {
+    @NoArg
+    class Local(val l: Any) {
+        @NoArg
+        inner class InnerLocal(val x: Any)
+    }
+}

plugins/noarg/testData/diagnostics/innerClass.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 annotation class NoArg
 
 class Outer {

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");
+    }
+}

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");
+    }
+}

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");
+    }
+}

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