From 254e8156aca826fd868358c5b7a936454641397c Mon Sep 17 00:00:00 2001 From: Yan Zhulanow Date: Thu, 4 May 2017 17:55:35 +0300 Subject: [PATCH] NoArg: Initialize properties in noarg constructor (KT-16692) --- .../kotlin/codegen/ClassBodyCodegen.java | 5 + .../codegen/ImplementationBodyCodegen.java | 2 +- .../impl/ClassConstructorDescriptorImpl.java | 2 +- .../kotlin/generators/tests/GenerateTests.kt | 9 +- idea/src/META-INF/plugin.xml | 2 +- .../NoArgClassBuilderInterceptorExtension.kt | 130 ------------------ .../src/NoArgExpressionCodegenExtension.kt | 83 +++++++++++ plugins/noarg/noarg-cli/src/NoArgPlugin.kt | 3 +- .../noarg-cli/testData/box/initializers.kt | 35 +++++ .../noarg/noarg-cli/testData/box/simple.kt | 15 ++ .../AbstractBlackBoxCodegenTestForNoArg.kt | 37 +++++ .../AbstractBytecodeListingTestForNoArg.kt | 10 +- .../BlackBoxCodegenTestForNoArgGenerated.java | 50 +++++++ 13 files changed, 243 insertions(+), 140 deletions(-) delete mode 100644 plugins/noarg/noarg-cli/src/NoArgClassBuilderInterceptorExtension.kt create mode 100644 plugins/noarg/noarg-cli/src/NoArgExpressionCodegenExtension.kt create mode 100644 plugins/noarg/noarg-cli/testData/box/initializers.kt create mode 100644 plugins/noarg/noarg-cli/testData/box/simple.kt create mode 100644 plugins/plugins-tests/tests/org/jetbrains/kotlin/noarg/AbstractBlackBoxCodegenTestForNoArg.kt create mode 100644 plugins/plugins-tests/tests/org/jetbrains/kotlin/noarg/BlackBoxCodegenTestForNoArgGenerated.java diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassBodyCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassBodyCodegen.java index a63fe746699..ae68ab5a051 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassBodyCodegen.java @@ -35,8 +35,13 @@ import java.util.List; import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.enumEntryNeedSubclass; public abstract class ClassBodyCodegen extends MemberCodegen { + @NotNull public final KtPureClassOrObject myClass; + + @NotNull public final OwnerKind kind; + + @NotNull public final ClassDescriptor descriptor; protected ClassBodyCodegen( diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java index d35ec4ad10b..0aec9a5b0f2 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java @@ -1047,7 +1047,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { } } - private void generateInitializers(@NotNull ExpressionCodegen codegen) { + public void generateInitializers(@NotNull ExpressionCodegen codegen) { generateInitializers(() -> codegen); } diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ClassConstructorDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ClassConstructorDescriptorImpl.java index cf0ad2eb707..760e9a55da5 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ClassConstructorDescriptorImpl.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ClassConstructorDescriptorImpl.java @@ -87,7 +87,7 @@ public class ClassConstructorDescriptorImpl extends FunctionDescriptorImpl imple } @Nullable - private ReceiverParameterDescriptor calculateDispatchReceiverParameter() { + public ReceiverParameterDescriptor calculateDispatchReceiverParameter() { ClassDescriptor classDescriptor = getContainingDeclaration(); if (classDescriptor.isInner()) { DeclarationDescriptor classContainer = classDescriptor.getContainingDeclaration(); diff --git a/generators/src/org/jetbrains/kotlin/generators/tests/GenerateTests.kt b/generators/src/org/jetbrains/kotlin/generators/tests/GenerateTests.kt index 1415a827a61..820f4166470 100755 --- a/generators/src/org/jetbrains/kotlin/generators/tests/GenerateTests.kt +++ b/generators/src/org/jetbrains/kotlin/generators/tests/GenerateTests.kt @@ -151,6 +151,7 @@ import org.jetbrains.kotlin.lang.resolve.android.test.AbstractAndroidBytecodeSha import org.jetbrains.kotlin.lang.resolve.android.test.AbstractAndroidSyntheticPropertyDescriptorTest import org.jetbrains.kotlin.modules.xml.AbstractModuleXmlParserTest import org.jetbrains.kotlin.multiplatform.AbstractMultiPlatformIntegrationTest +import org.jetbrains.kotlin.noarg.AbstractBlackBoxCodegenTestForNoArg import org.jetbrains.kotlin.noarg.AbstractBytecodeListingTestForNoArg import org.jetbrains.kotlin.parsing.AbstractParsingTest import org.jetbrains.kotlin.psi.patternMatching.AbstractPsiUnifierTest @@ -1210,15 +1211,19 @@ fun main(args: Array) { } testGroup("plugins/plugins-tests/tests", "plugins/allopen/allopen-cli/testData") { - testClass() { + testClass { model("bytecodeListing", extension = "kt") } } testGroup("plugins/plugins-tests/tests", "plugins/noarg/noarg-cli/testData") { - testClass() { + testClass { model("bytecodeListing", extension = "kt") } + + testClass { + model("box", targetBackend = TargetBackend.JVM) + } } testGroup("plugins/plugins-tests/tests", "plugins/sam-with-receiver/sam-with-receiver-cli/testData") { diff --git a/idea/src/META-INF/plugin.xml b/idea/src/META-INF/plugin.xml index 18ddfb47145..55ee89547d5 100644 --- a/idea/src/META-INF/plugin.xml +++ b/idea/src/META-INF/plugin.xml @@ -2186,7 +2186,7 @@ - + diff --git a/plugins/noarg/noarg-cli/src/NoArgClassBuilderInterceptorExtension.kt b/plugins/noarg/noarg-cli/src/NoArgClassBuilderInterceptorExtension.kt deleted file mode 100644 index 0f0d07c3855..00000000000 --- a/plugins/noarg/noarg-cli/src/NoArgClassBuilderInterceptorExtension.kt +++ /dev/null @@ -1,130 +0,0 @@ -/* - * Copyright 2010-2016 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.kotlin.noarg - -import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.codegen.ClassBuilder -import org.jetbrains.kotlin.codegen.ClassBuilderFactory -import org.jetbrains.kotlin.codegen.DelegatingClassBuilder -import org.jetbrains.kotlin.codegen.extensions.ClassBuilderInterceptorExtension -import org.jetbrains.kotlin.descriptors.ClassDescriptor -import org.jetbrains.kotlin.descriptors.ClassKind -import org.jetbrains.kotlin.diagnostics.DiagnosticSink -import org.jetbrains.kotlin.psi.KtClass -import org.jetbrains.kotlin.resolve.BindingContext -import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin -import org.jetbrains.org.objectweb.asm.MethodVisitor -import org.jetbrains.org.objectweb.asm.Opcodes - -class NoArgClassBuilderInterceptorExtension : ClassBuilderInterceptorExtension { - override fun interceptClassBuilderFactory( - interceptedFactory: ClassBuilderFactory, - bindingContext: BindingContext, - diagnostics: DiagnosticSink - ): ClassBuilderFactory = NoArgClassBuilderFactory(interceptedFactory, bindingContext) - - private inner class NoArgClassBuilderFactory( - private val delegateFactory: ClassBuilderFactory, - val bindingContext: BindingContext - ) : ClassBuilderFactory { - - override fun newClassBuilder(origin: JvmDeclarationOrigin): ClassBuilder { - return AllOpenClassBuilder(delegateFactory.newClassBuilder(origin), bindingContext) - } - - override fun getClassBuilderMode() = delegateFactory.classBuilderMode - - override fun asText(builder: ClassBuilder?): String? { - return delegateFactory.asText((builder as AllOpenClassBuilder).delegateClassBuilder) - } - - override fun asBytes(builder: ClassBuilder?): ByteArray? { - return delegateFactory.asBytes((builder as AllOpenClassBuilder).delegateClassBuilder) - } - - override fun close() { - delegateFactory.close() - } - } - - private inner class AllOpenClassBuilder( - internal val delegateClassBuilder: ClassBuilder, - val bindingContext: BindingContext - ) : DelegatingClassBuilder() { - override fun getDelegate() = delegateClassBuilder - - private var superClassInternalName = "" - private var hasSpecialAnnotation = false - private var noArgConstructorGenerated = false - - override fun defineClass( - origin: PsiElement?, - version: Int, - access: Int, - name: String, - signature: String?, - superName: String, - interfaces: Array - ) { - super.defineClass(origin, version, access, name, signature, superName, interfaces) - - hasSpecialAnnotation = false - noArgConstructorGenerated = false - superClassInternalName = superName - - if (origin is KtClass) { - val descriptor = bindingContext[BindingContext.DECLARATION_TO_DESCRIPTOR, origin] as? ClassDescriptor - if (descriptor != null && descriptor.kind == ClassKind.CLASS && origin.isNoArgClass()) { - hasSpecialAnnotation = true - } - } - } - - private fun KtClass.isNoArgClass() = this.getUserData(NO_ARG_CLASS_KEY) ?: false - - override fun newMethod( - origin: JvmDeclarationOrigin, - access: Int, - name: String, - desc: String, - signature: String?, - exceptions: Array? - ): MethodVisitor { - if (name == "" && desc == "()V") { - noArgConstructorGenerated = true - } - - return super.newMethod(origin, access, name, desc, signature, exceptions) - } - - override fun done() { - val superClassInternalName = this.superClassInternalName - if (hasSpecialAnnotation && !noArgConstructorGenerated && superClassInternalName.isNotEmpty()) { - super.newMethod(JvmDeclarationOrigin.NO_ORIGIN, Opcodes.ACC_PUBLIC, "", "()V", null, null).apply { - visitCode() - visitVarInsn(Opcodes.ALOAD, 0) - visitMethodInsn(Opcodes.INVOKESPECIAL, superClassInternalName, "", "()V", false) - visitInsn(Opcodes.RETURN) - visitMaxs(1, 1) - visitEnd() - } - } - - super.done() - } - } -} \ No newline at end of file diff --git a/plugins/noarg/noarg-cli/src/NoArgExpressionCodegenExtension.kt b/plugins/noarg/noarg-cli/src/NoArgExpressionCodegenExtension.kt new file mode 100644 index 00000000000..cb1692efaeb --- /dev/null +++ b/plugins/noarg/noarg-cli/src/NoArgExpressionCodegenExtension.kt @@ -0,0 +1,83 @@ +/* + * Copyright 2010-2017 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.kotlin.noarg + +import org.jetbrains.kotlin.codegen.* +import org.jetbrains.kotlin.codegen.context.ConstructorContext +import org.jetbrains.kotlin.codegen.extensions.ExpressionCodegenExtension +import org.jetbrains.kotlin.descriptors.* +import org.jetbrains.kotlin.descriptors.annotations.Annotations +import org.jetbrains.kotlin.descriptors.impl.ClassConstructorDescriptorImpl +import org.jetbrains.kotlin.psi.KtClass +import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperClassOrAny +import org.jetbrains.kotlin.resolve.descriptorUtil.hasDefaultValue +import org.jetbrains.kotlin.resolve.jvm.AsmTypes +import org.jetbrains.kotlin.resolve.jvm.annotations.findJvmOverloadsAnnotation +import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin +import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature +import org.jetbrains.kotlin.codegen.FunctionGenerationStrategy.CodegenBased +import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns +import org.jetbrains.org.objectweb.asm.Opcodes +import org.jetbrains.org.objectweb.asm.Type + +class NoArgExpressionCodegenExtension : ExpressionCodegenExtension { + override fun generateClassSyntheticParts(codegen: ImplementationBodyCodegen) = with(codegen) { + if (shouldGenerateNoArgConstructor()) { + generateNoArgConstructor() + } + } + + private fun ImplementationBodyCodegen.generateNoArgConstructor() { + val superClassInternalName = typeMapper.mapClass(descriptor.getSuperClassOrAny()).internalName + + val constructorDescriptor = createNoArgConstructorDescriptor(descriptor) + + functionCodegen.generateMethod(JvmDeclarationOrigin.NO_ORIGIN, constructorDescriptor, object: CodegenBased(state) { + override fun doGenerateBody(codegen: ExpressionCodegen, signature: JvmMethodSignature) { + codegen.v.load(0, AsmTypes.OBJECT_TYPE) + codegen.v.visitMethodInsn(Opcodes.INVOKESPECIAL, superClassInternalName, "", "()V", false) + generateInitializers(codegen) + codegen.v.visitInsn(Opcodes.RETURN) + } + }) + } + + private fun createNoArgConstructorDescriptor(containingClass: ClassDescriptor): ConstructorDescriptor { + return ClassConstructorDescriptorImpl.createSynthesized(containingClass, Annotations.EMPTY, false, SourceElement.NO_SOURCE).apply { + initialize(null, calculateDispatchReceiverParameter(), emptyList(), emptyList(), + containingClass.builtIns.unitType, Modality.OPEN, Visibilities.PUBLIC) + } + } + + private fun KtClass.isNoArgClass() = this.getUserData(NO_ARG_CLASS_KEY) ?: false + + private fun ImplementationBodyCodegen.shouldGenerateNoArgConstructor(): Boolean { + val origin = myClass as? KtClass ?: return false + + if (descriptor.kind != ClassKind.CLASS || !origin.isNoArgClass()) { + return false + } + + return descriptor.constructors.none { it.isZeroParameterConstructor() } + } + + private fun ClassConstructorDescriptor.isZeroParameterConstructor(): Boolean { + val parameters = this.valueParameters + return parameters.isEmpty() + || (parameters.all { it.hasDefaultValue() } && (isPrimary || findJvmOverloadsAnnotation() != null)) + } +} \ No newline at end of file diff --git a/plugins/noarg/noarg-cli/src/NoArgPlugin.kt b/plugins/noarg/noarg-cli/src/NoArgPlugin.kt index 8acaf13d2bd..dac7b14f21a 100644 --- a/plugins/noarg/noarg-cli/src/NoArgPlugin.kt +++ b/plugins/noarg/noarg-cli/src/NoArgPlugin.kt @@ -20,6 +20,7 @@ import com.intellij.mock.MockProject import com.intellij.openapi.extensions.Extensions import org.jetbrains.kotlin.noarg.diagnostic.DefaultErrorMessagesNoArg import org.jetbrains.kotlin.codegen.extensions.ClassBuilderInterceptorExtension +import org.jetbrains.kotlin.codegen.extensions.ExpressionCodegenExtension import org.jetbrains.kotlin.compiler.plugin.CliOption import org.jetbrains.kotlin.compiler.plugin.CliOptionProcessingException import org.jetbrains.kotlin.compiler.plugin.CommandLineProcessor @@ -78,7 +79,7 @@ class NoArgComponentRegistrar : ComponentRegistrar { Extensions.getRootArea().getExtensionPoint(DefaultErrorMessages.Extension.EP_NAME).registerExtension(DefaultErrorMessagesNoArg()) StorageComponentContainerContributor.registerExtension(project, CliNoArgComponentContainerContributor(annotations)) - ClassBuilderInterceptorExtension.registerExtension(project, NoArgClassBuilderInterceptorExtension()) + ExpressionCodegenExtension.registerExtension(project, NoArgExpressionCodegenExtension()) } } diff --git a/plugins/noarg/noarg-cli/testData/box/initializers.kt b/plugins/noarg/noarg-cli/testData/box/initializers.kt new file mode 100644 index 00000000000..7eb055c704c --- /dev/null +++ b/plugins/noarg/noarg-cli/testData/box/initializers.kt @@ -0,0 +1,35 @@ +// WITH_RUNTIME + +annotation class NoArg + +class Simple(val a: String) + +@NoArg +class Test(val a: String) { + val x = 5 + val y = Simple("Hello, world!") + val z by lazy { "TEST" } +} + +fun box(): String { + try { + val test = Test::class.java.newInstance() + + if (test.x != 5) { + return "Bad 5" + } + + if (test.y == null || test.y.a != "Hello, world!") { + return "Bad Hello, world!" + } + + if (test.z != "TEST") { + return "Bad TEST" + } + + return "OK" + } catch (e: Throwable) { + e.printStackTrace() + return "Fail" + } +} \ No newline at end of file diff --git a/plugins/noarg/noarg-cli/testData/box/simple.kt b/plugins/noarg/noarg-cli/testData/box/simple.kt new file mode 100644 index 00000000000..8a4915bbba9 --- /dev/null +++ b/plugins/noarg/noarg-cli/testData/box/simple.kt @@ -0,0 +1,15 @@ +// WITH_RUNTIME + +annotation class NoArg + +@NoArg +class Test(val a: String) + +fun box(): String { + try { + Test::class.java.newInstance() + return "OK" + } catch (_: Throwable) { + return "Fail" + } +} \ No newline at end of file diff --git a/plugins/plugins-tests/tests/org/jetbrains/kotlin/noarg/AbstractBlackBoxCodegenTestForNoArg.kt b/plugins/plugins-tests/tests/org/jetbrains/kotlin/noarg/AbstractBlackBoxCodegenTestForNoArg.kt new file mode 100644 index 00000000000..348f7a261c0 --- /dev/null +++ b/plugins/plugins-tests/tests/org/jetbrains/kotlin/noarg/AbstractBlackBoxCodegenTestForNoArg.kt @@ -0,0 +1,37 @@ +/* + * Copyright 2010-2017 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.kotlin.noarg + +import com.intellij.openapi.extensions.Extensions +import org.jetbrains.kotlin.codegen.AbstractBlackBoxCodegenTest +import org.jetbrains.kotlin.codegen.extensions.ExpressionCodegenExtension +import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages +import org.jetbrains.kotlin.extensions.StorageComponentContainerContributor.Companion.registerExtension +import org.jetbrains.kotlin.noarg.AbstractBytecodeListingTestForNoArg.Companion.NOARG_ANNOTATIONS +import org.jetbrains.kotlin.noarg.diagnostic.DefaultErrorMessagesNoArg + +abstract class AbstractBlackBoxCodegenTestForNoArg : AbstractBlackBoxCodegenTest() { + override fun loadMultiFiles(files: MutableList) { + Extensions.getRootArea().getExtensionPoint(DefaultErrorMessages.Extension.EP_NAME).registerExtension(DefaultErrorMessagesNoArg()) + + val project = myEnvironment.project + registerExtension(project, CliNoArgComponentContainerContributor(NOARG_ANNOTATIONS)) + ExpressionCodegenExtension.registerExtension(project, NoArgExpressionCodegenExtension()) + + super.loadMultiFiles(files) + } +} \ No newline at end of file diff --git a/plugins/plugins-tests/tests/org/jetbrains/kotlin/noarg/AbstractBytecodeListingTestForNoArg.kt b/plugins/plugins-tests/tests/org/jetbrains/kotlin/noarg/AbstractBytecodeListingTestForNoArg.kt index 3183e042687..835a8f7d97f 100644 --- a/plugins/plugins-tests/tests/org/jetbrains/kotlin/noarg/AbstractBytecodeListingTestForNoArg.kt +++ b/plugins/plugins-tests/tests/org/jetbrains/kotlin/noarg/AbstractBytecodeListingTestForNoArg.kt @@ -19,19 +19,21 @@ package org.jetbrains.kotlin.noarg import com.intellij.openapi.extensions.Extensions import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment import org.jetbrains.kotlin.codegen.AbstractBytecodeListingTest -import org.jetbrains.kotlin.codegen.extensions.ClassBuilderInterceptorExtension +import org.jetbrains.kotlin.codegen.extensions.ExpressionCodegenExtension import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages import org.jetbrains.kotlin.extensions.StorageComponentContainerContributor import org.jetbrains.kotlin.noarg.diagnostic.DefaultErrorMessagesNoArg abstract class AbstractBytecodeListingTestForNoArg : AbstractBytecodeListingTest() { - private companion object { + internal companion object { val NOARG_ANNOTATIONS = listOf("NoArg", "NoArg2", "test.NoArg") } override fun setupEnvironment(environment: KotlinCoreEnvironment) { Extensions.getRootArea().getExtensionPoint(DefaultErrorMessages.Extension.EP_NAME).registerExtension(DefaultErrorMessagesNoArg()) - StorageComponentContainerContributor.registerExtension(environment.project, CliNoArgComponentContainerContributor(NOARG_ANNOTATIONS)) - ClassBuilderInterceptorExtension.registerExtension(environment.project, NoArgClassBuilderInterceptorExtension()) + + val project = environment.project + StorageComponentContainerContributor.registerExtension(project, CliNoArgComponentContainerContributor(NOARG_ANNOTATIONS)) + ExpressionCodegenExtension.registerExtension(project, NoArgExpressionCodegenExtension()) } } \ No newline at end of file diff --git a/plugins/plugins-tests/tests/org/jetbrains/kotlin/noarg/BlackBoxCodegenTestForNoArgGenerated.java b/plugins/plugins-tests/tests/org/jetbrains/kotlin/noarg/BlackBoxCodegenTestForNoArgGenerated.java new file mode 100644 index 00000000000..5a92f45d5cf --- /dev/null +++ b/plugins/plugins-tests/tests/org/jetbrains/kotlin/noarg/BlackBoxCodegenTestForNoArgGenerated.java @@ -0,0 +1,50 @@ +/* + * Copyright 2010-2017 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.kotlin.noarg; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; +import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.TargetBackend; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.runner.RunWith; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("plugins/noarg/noarg-cli/testData/box") +@TestDataPath("$PROJECT_ROOT") +@RunWith(JUnit3RunnerWithInners.class) +public class BlackBoxCodegenTestForNoArgGenerated extends AbstractBlackBoxCodegenTestForNoArg { + public void testAllFilesPresentInBox() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/noarg/noarg-cli/testData/box"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true); + } + + @TestMetadata("initializers.kt") + public void testInitializers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("plugins/noarg/noarg-cli/testData/box/initializers.kt"); + doTest(fileName); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("plugins/noarg/noarg-cli/testData/box/simple.kt"); + doTest(fileName); + } +}