diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/KotlinStandardLibrariesPathProvider.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/KotlinStandardLibrariesPathProvider.kt index 9098360e649..849b46d1532 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/KotlinStandardLibrariesPathProvider.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/KotlinStandardLibrariesPathProvider.kt @@ -111,7 +111,7 @@ object EnvironmentBasedStandardLibrariesPathProvider : KotlinStandardLibrariesPa const val KOTLIN_SCRIPT_RUNTIME_PROP = "org.jetbrains.kotlin.test.kotlin-script-runtime" const val KOTLIN_ANNOTATIONS_JVM_PROP = "org.jetbrains.kotlin.test.kotlin-annotations-jvm" - private fun getFile(propertyName: String): File { + fun getFile(propertyName: String): File { return System.getProperty(propertyName) ?.let(::File) ?.takeIf { it.exists() } diff --git a/plugins/lombok/build.gradle.kts b/plugins/lombok/build.gradle.kts index f5d444d048c..3dae45f33f4 100644 --- a/plugins/lombok/build.gradle.kts +++ b/plugins/lombok/build.gradle.kts @@ -38,7 +38,7 @@ dependencies { testApi(commonDependency("junit:junit")) - + testRuntimeOnly(commonDependency("com.google.guava:guava")) testRuntimeOnly(toolsJar()) } @@ -54,6 +54,16 @@ sourceSets { projectTest(parallel = true) { workingDir = rootDir + + doFirst { + project.configurations + .testRuntimeClasspath.get() + .files + .find { "guava" in it.name } + ?.absolutePath + ?.let { systemProperty("org.jetbrains.kotlin.test.guava-location", it) } + + } } runtimeJar() diff --git a/plugins/lombok/lombok.common/src/org/jetbrains/kotlin/lombok/utils/LombokNames.kt b/plugins/lombok/lombok.common/src/org/jetbrains/kotlin/lombok/utils/LombokNames.kt index e92451ba435..437beedb8a1 100644 --- a/plugins/lombok/lombok.common/src/org/jetbrains/kotlin/lombok/utils/LombokNames.kt +++ b/plugins/lombok/lombok.common/src/org/jetbrains/kotlin/lombok/utils/LombokNames.kt @@ -22,6 +22,7 @@ object LombokNames { val BUILDER = FqName("lombok.Builder") val SINGULAR = FqName("lombok.Singular") + val TABLE = FqName("com.google.common.collect.Table") val ACCESSORS_ID = ClassId.topLevel(ACCESSORS) val GETTER_ID = ClassId.topLevel(GETTER) @@ -35,6 +36,8 @@ object LombokNames { val ALL_ARGS_CONSTRUCTOR_ID = ClassId.topLevel(ALL_ARGS_CONSTRUCTOR) val REQUIRED_ARGS_CONSTRUCTOR_ID = ClassId.topLevel(REQUIRED_ARGS_CONSTRUCTOR) + val TABLE_CLASS_ID = ClassId.topLevel(TABLE) + //taken from idea lombok plugin val NON_NULL_ANNOTATIONS = listOf( "androidx.annotation.NonNull", @@ -83,36 +86,23 @@ object LombokNames { "kotlin.collections.MutableMap", ) - private val SUPPORTED_COLLECTIONS = SUPPORTED_JAVA_COLLECTIONS + SUPPORTED_KOTLIN_COLLECTIONS - private val SUPPORTED_MAPS = SUPPORTED_JAVA_MAPS + SUPPORTED_KOTLIN_MAPS - - private val SUPPORTED_COLLECTIONS_WITH_GUAVA = SUPPORTED_COLLECTIONS + setOf( + val SUPPORTED_GUAVA_COLLECTIONS = setOf( "com.google.common.collect.ImmutableCollection", "com.google.common.collect.ImmutableList", "com.google.common.collect.ImmutableSet", "com.google.common.collect.ImmutableSortedSet", ) - private val SUPPORTED_MAPS_WITH_GUAVA = SUPPORTED_MAPS + setOf( + private val SUPPORTED_GUAVA_MAPS = setOf( "com.google.common.collect.ImmutableMap", "com.google.common.collect.ImmutableBiMap", "com.google.common.collect.ImmutableSortedMap", + ) + val SUPPORTED_COLLECTIONS = SUPPORTED_JAVA_COLLECTIONS + SUPPORTED_KOTLIN_COLLECTIONS + SUPPORTED_GUAVA_COLLECTIONS + + val SUPPORTED_MAPS = SUPPORTED_JAVA_MAPS + SUPPORTED_KOTLIN_MAPS + SUPPORTED_GUAVA_MAPS + + val SUPPORTED_TABLES = setOf( "com.google.common.collect.ImmutableTable", ) - - fun getSupportedCollectionsForSingular(includeGuava: Boolean): Set { - return if (includeGuava) { - SUPPORTED_COLLECTIONS_WITH_GUAVA - } else { - SUPPORTED_COLLECTIONS - } - } - - fun getSupportedMapsForSingular(includeGuava: Boolean): Set { - return if (includeGuava) { - SUPPORTED_MAPS_WITH_GUAVA - } else { - SUPPORTED_MAPS - } - } } diff --git a/plugins/lombok/lombok.k1/src/org/jetbrains/kotlin/lombok/processor/BuilderProcessor.kt b/plugins/lombok/lombok.k1/src/org/jetbrains/kotlin/lombok/processor/BuilderProcessor.kt index 7af5ef6e5c5..4720c7bc416 100644 --- a/plugins/lombok/lombok.k1/src/org/jetbrains/kotlin/lombok/processor/BuilderProcessor.kt +++ b/plugins/lombok/lombok.k1/src/org/jetbrains/kotlin/lombok/processor/BuilderProcessor.kt @@ -9,6 +9,7 @@ import com.intellij.openapi.util.text.StringUtil import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.descriptors.annotations.Annotations import org.jetbrains.kotlin.descriptors.annotations.CompositeAnnotations +import org.jetbrains.kotlin.incremental.components.NoLookupLocation import org.jetbrains.kotlin.load.java.JavaDescriptorVisibilities import org.jetbrains.kotlin.load.java.lazy.LazyJavaResolverContext import org.jetbrains.kotlin.load.java.lazy.descriptors.SyntheticJavaClassDescriptor @@ -146,26 +147,28 @@ class BuilderProcessor(private val config: LombokConfig) : Processor { val nameInSingularForm = (singular.singularName ?: field.name.identifier.singularForm)?.let(Name::identifier) ?: return val typeName = field.type.constructor.declarationDescriptor?.fqNameSafe?.asString() ?: return - val useGuava = config.useGuava - val supportedCollections = LombokNames.getSupportedCollectionsForSingular(useGuava) - val supportedMaps = LombokNames.getSupportedMapsForSingular(useGuava) - val addMultipleParameterType: KotlinType val valueParameters: List when (typeName) { - in supportedCollections -> { + in LombokNames.SUPPORTED_COLLECTIONS -> { val parameterType = field.parameterType(0, singular.allowNull) ?: return valueParameters = listOf( LombokValueParameter(nameInSingularForm, parameterType) ) - addMultipleParameterType = field.module.builtIns.collection.defaultType.replace( + val builtIns = field.module.builtIns + val baseType = when (typeName) { + in LombokNames.SUPPORTED_GUAVA_COLLECTIONS -> builtIns.iterable.defaultType + else -> builtIns.collection.defaultType + } + + addMultipleParameterType = baseType.replace( newArguments = listOf(TypeProjectionImpl(parameterType)) ) } - in supportedMaps -> { + in LombokNames.SUPPORTED_MAPS -> { val keyType = field.parameterType(0, singular.allowNull) ?: return val valueType = field.parameterType(1, singular.allowNull) ?: return valueParameters = listOf( @@ -178,6 +181,28 @@ class BuilderProcessor(private val config: LombokConfig) : Processor { ) } + in LombokNames.SUPPORTED_TABLES -> { + val rowKeyType = field.parameterType(0, singular.allowNull) ?: return + val columnKeyType = field.parameterType(1, singular.allowNull) ?: return + val valueType = field.parameterType(2, singular.allowNull) ?: return + + val tableDescriptor = field.module.resolveClassByFqName(LombokNames.TABLE, NoLookupLocation.FROM_SYNTHETIC_SCOPE) ?: return + + valueParameters = listOf( + LombokValueParameter(Name.identifier("rowKey"), rowKeyType), + LombokValueParameter(Name.identifier("columnKey"), columnKeyType), + LombokValueParameter(Name.identifier("value"), valueType), + ) + + addMultipleParameterType = tableDescriptor.defaultType.replace( + newArguments = listOf( + TypeProjectionImpl(rowKeyType), + TypeProjectionImpl(columnKeyType), + TypeProjectionImpl(valueType), + ) + ) + } + else -> return } @@ -217,9 +242,6 @@ class BuilderProcessor(private val config: LombokConfig) : Processor { private class BuilderData(val builder: Builder, val constructingClass: ClassDescriptor) - private val LombokConfig.useGuava: Boolean - get() = getBoolean("lombok.singular.useGuava") ?: false - private fun PropertyDescriptor.parameterType(index: Int, allowNull: Boolean): KotlinType? { val type = returnType?.arguments?.getOrNull(index)?.type ?: return null val typeWithProperNullability = if (allowNull) type.makeNullable() else type.makeNotNullable() diff --git a/plugins/lombok/lombok.k2/src/org/jetbrains/kotlin/lombok/k2/generators/BuilderGenerator.kt b/plugins/lombok/lombok.k2/src/org/jetbrains/kotlin/lombok/k2/generators/BuilderGenerator.kt index 588034df26a..be2975f554e 100644 --- a/plugins/lombok/lombok.k2/src/org/jetbrains/kotlin/lombok/k2/generators/BuilderGenerator.kt +++ b/plugins/lombok/lombok.k2/src/org/jetbrains/kotlin/lombok/k2/generators/BuilderGenerator.kt @@ -184,24 +184,25 @@ class BuilderGenerator(session: FirSession) : FirDeclarationGenerationExtension( val nameInSingularForm = (singular.singularName ?: field.name.identifier.singularForm)?.let(Name::identifier) ?: return - val useGuava = lombokService.config.useGuava - val supportedCollections = LombokNames.getSupportedCollectionsForSingular(useGuava) - val supportedMaps = LombokNames.getSupportedMapsForSingular(useGuava) - val addMultipleParameterType: FirTypeRef val valueParameters: List when (typeName) { - in supportedCollections -> { + in LombokNames.SUPPORTED_COLLECTIONS -> { val parameterType = javaClassifierType.parameterType(0, singular.allowNull) ?: return valueParameters = listOf( ConeLombokValueParameter(nameInSingularForm, parameterType.toRef()) ) - addMultipleParameterType = DummyJavaClassType(JavaClasses.Collection, typeArguments = listOf(parameterType)).toRef() + val baseType = when (typeName) { + in LombokNames.SUPPORTED_GUAVA_COLLECTIONS -> JavaClasses.Iterable + else -> JavaClasses.Collection + } + + addMultipleParameterType = DummyJavaClassType(baseType, typeArguments = listOf(parameterType)).toRef() } - in supportedMaps -> { + in LombokNames.SUPPORTED_MAPS -> { val keyType = javaClassifierType.parameterType(0, singular.allowNull) ?: return val valueType = javaClassifierType.parameterType(1, singular.allowNull) ?: return valueParameters = listOf( @@ -212,6 +213,23 @@ class BuilderGenerator(session: FirSession) : FirDeclarationGenerationExtension( addMultipleParameterType = DummyJavaClassType(JavaClasses.Map, typeArguments = listOf(keyType, valueType)).toRef() } + in LombokNames.SUPPORTED_TABLES -> { + val rowKeyType = javaClassifierType.parameterType(0, singular.allowNull) ?: return + val columnKeyType = javaClassifierType.parameterType(1, singular.allowNull) ?: return + val valueType = javaClassifierType.parameterType(2, singular.allowNull) ?: return + + valueParameters = listOf( + ConeLombokValueParameter(Name.identifier("rowKey"), rowKeyType.toRef()), + ConeLombokValueParameter(Name.identifier("columnKey"), columnKeyType.toRef()), + ConeLombokValueParameter(Name.identifier("value"), valueType.toRef()), + ) + + addMultipleParameterType = DummyJavaClassType( + JavaClasses.Table, + typeArguments = listOf(rowKeyType, columnKeyType, valueType) + ).toRef() + } + else -> return } @@ -255,9 +273,6 @@ class BuilderGenerator(session: FirSession) : FirDeclarationGenerationExtension( private val String.singularForm: String? get() = StringUtil.unpluralize(this) - private val LombokConfig.useGuava: Boolean - get() = getBoolean("lombok.singular.useGuava") ?: false - private fun JavaClassifierType.parameterType(index: Int, allowNull: Boolean): JavaType? { val type = typeArguments.getOrNull(index) ?: return null return if (allowNull) type.makeNullable() else type.makeNotNullable() diff --git a/plugins/lombok/lombok.k2/src/org/jetbrains/kotlin/lombok/k2/java/dummyJavaElements.kt b/plugins/lombok/lombok.k2/src/org/jetbrains/kotlin/lombok/k2/java/dummyJavaElements.kt index 3fb5dfcea4a..968182f12f0 100644 --- a/plugins/lombok/lombok.k2/src/org/jetbrains/kotlin/lombok/k2/java/dummyJavaElements.kt +++ b/plugins/lombok/lombok.k2/src/org/jetbrains/kotlin/lombok/k2/java/dummyJavaElements.kt @@ -7,17 +7,24 @@ package org.jetbrains.kotlin.lombok.k2.java import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.load.java.structure.* +import org.jetbrains.kotlin.lombok.utils.LombokNames import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name object JavaClasses { + val Iterable = DummyJavaClass("Iterable", javaLangName("Iterable"), numberOfTypeParameters = 1) val Collection = DummyJavaClass("Collection", javaUtilName("Collection"), numberOfTypeParameters = 1) val Map = DummyJavaClass("Map", javaUtilName("Map"), numberOfTypeParameters = 2) + val Table = DummyJavaClass("Table", LombokNames.TABLE, numberOfTypeParameters = 3) private fun javaUtilName(name: String): FqName { return FqName.fromSegments(listOf("java", "util", name)) } + + private fun javaLangName(name: String): FqName { + return FqName.fromSegments(listOf("java", "lang", name)) + } } class DummyJavaClass(name: String, override val fqName: FqName, numberOfTypeParameters: Int) : JavaClass { diff --git a/plugins/lombok/testData/box/builderGuava.kt b/plugins/lombok/testData/box/builderGuava.kt new file mode 100644 index 00000000000..750f9662d56 --- /dev/null +++ b/plugins/lombok/testData/box/builderGuava.kt @@ -0,0 +1,68 @@ +// WITH_GUAVA +// WITH_STDLIB +// FULL_JDK +// FILE: User.java +import lombok.Builder; +import lombok.Data; +import lombok.Singular; + +@Builder +@Data +public class User { + @Singular private com.google.common.collect.ImmutableMap numbers; + @Singular private com.google.common.collect.ImmutableList statuses; + @Singular private com.google.common.collect.ImmutableTable values; +} + +// FILE: Other.java +import lombok.Builder; +import lombok.Data; +import lombok.Singular; + +@Builder(setterPrefix = "with") +@Data +public class Other { + @Singular("singleSome") private java.util.List some; +} + +// FILE: test.kt +import com.google.common.collect.ImmutableTable +import com.google.common.collect.HashBasedTable + +fun box(): String { + val userBuilder = User.builder() + .status("wrong") + .clearStatuses() + .status("hello") + .statuses(listOf("world", "!")) + .number("1", 1) + .numbers(mapOf("2" to 2, "3" to 3)) + .value("1", "a", "hello") + .values(ImmutableTable.of("2", "b", "world")) + + val user = userBuilder.build() + + val outer = Other.builder() + .withSingleSome(1) + .withSome(listOf(2, 3)) + .build() + + val expectedNumbers = mapOf("1" to 1, "2" to 2, "3" to 3) + val expectedStatuses = listOf("hello", "world", "!") + val expectedSome = listOf(1, 2, 3) + val expectedValues = HashBasedTable.create().apply { + put("1", "a", "hello") + put("2", "b", "world") + } + + return if ( + user.numbers == expectedNumbers && + user.statuses == expectedStatuses && + user.values == expectedValues && + outer.some == expectedSome + ) { + "OK" + } else { + "Error: $user" + } +} diff --git a/plugins/lombok/tests-gen/org/jetbrains/kotlin/lombok/BlackBoxCodegenTestForLombokGenerated.java b/plugins/lombok/tests-gen/org/jetbrains/kotlin/lombok/BlackBoxCodegenTestForLombokGenerated.java index fd95caf07cc..0d7dbfb0143 100644 --- a/plugins/lombok/tests-gen/org/jetbrains/kotlin/lombok/BlackBoxCodegenTestForLombokGenerated.java +++ b/plugins/lombok/tests-gen/org/jetbrains/kotlin/lombok/BlackBoxCodegenTestForLombokGenerated.java @@ -55,6 +55,12 @@ public class BlackBoxCodegenTestForLombokGenerated extends AbstractBlackBoxCodeg runTest("plugins/lombok/testData/box/builder.kt"); } + @Test + @TestMetadata("builderGuava.kt") + public void testBuilderGuava() throws Exception { + runTest("plugins/lombok/testData/box/builderGuava.kt"); + } + @Test @TestMetadata("builderSingular.kt") public void testBuilderSingular() throws Exception { diff --git a/plugins/lombok/tests-gen/org/jetbrains/kotlin/lombok/FirBlackBoxCodegenTestForLombokGenerated.java b/plugins/lombok/tests-gen/org/jetbrains/kotlin/lombok/FirBlackBoxCodegenTestForLombokGenerated.java index 47b495ab0c8..10bf052b12c 100644 --- a/plugins/lombok/tests-gen/org/jetbrains/kotlin/lombok/FirBlackBoxCodegenTestForLombokGenerated.java +++ b/plugins/lombok/tests-gen/org/jetbrains/kotlin/lombok/FirBlackBoxCodegenTestForLombokGenerated.java @@ -55,6 +55,12 @@ public class FirBlackBoxCodegenTestForLombokGenerated extends AbstractFirBlackBo runTest("plugins/lombok/testData/box/builder.kt"); } + @Test + @TestMetadata("builderGuava.kt") + public void testBuilderGuava() throws Exception { + runTest("plugins/lombok/testData/box/builderGuava.kt"); + } + @Test @TestMetadata("builderSingular.kt") public void testBuilderSingular() throws Exception { diff --git a/plugins/lombok/tests-gen/org/jetbrains/kotlin/lombok/IrBlackBoxCodegenTestForLombokGenerated.java b/plugins/lombok/tests-gen/org/jetbrains/kotlin/lombok/IrBlackBoxCodegenTestForLombokGenerated.java index e5a2d73e8bd..27f61a4821f 100644 --- a/plugins/lombok/tests-gen/org/jetbrains/kotlin/lombok/IrBlackBoxCodegenTestForLombokGenerated.java +++ b/plugins/lombok/tests-gen/org/jetbrains/kotlin/lombok/IrBlackBoxCodegenTestForLombokGenerated.java @@ -55,6 +55,12 @@ public class IrBlackBoxCodegenTestForLombokGenerated extends AbstractIrBlackBoxC runTest("plugins/lombok/testData/box/builder.kt"); } + @Test + @TestMetadata("builderGuava.kt") + public void testBuilderGuava() throws Exception { + runTest("plugins/lombok/testData/box/builderGuava.kt"); + } + @Test @TestMetadata("builderSingular.kt") public void testBuilderSingular() throws Exception { diff --git a/plugins/lombok/tests/org/jetbrains/kotlin/lombok/LombokTestServices.kt b/plugins/lombok/tests/org/jetbrains/kotlin/lombok/LombokTestServices.kt new file mode 100644 index 00000000000..c8ba4b3699d --- /dev/null +++ b/plugins/lombok/tests/org/jetbrains/kotlin/lombok/LombokTestServices.kt @@ -0,0 +1,79 @@ +/* + * 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.lombok + +import lombok.Getter +import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoot +import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar.ExtensionStorage +import org.jetbrains.kotlin.config.CompilerConfiguration +import org.jetbrains.kotlin.lombok.LombokDirectives.WITH_GUAVA +import org.jetbrains.kotlin.lombok.LombokEnvironmentConfigurator.Companion.GUAVA_JAR +import org.jetbrains.kotlin.test.directives.model.DirectivesContainer +import org.jetbrains.kotlin.test.directives.model.RegisteredDirectives +import org.jetbrains.kotlin.test.directives.model.SimpleDirectivesContainer +import org.jetbrains.kotlin.test.model.TestFile +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.* +import org.jetbrains.kotlin.utils.PathUtil +import java.io.File + +class LombokAdditionalSourceFileProvider(testServices: TestServices) : AdditionalSourceProvider(testServices) { + companion object { + const val COMMON_SOURCE_PATH = "plugins/lombok/testData/common.kt" + } + + override fun produceAdditionalFiles(globalDirectives: RegisteredDirectives, module: TestModule): List { + return listOf(File(COMMON_SOURCE_PATH).toTestFile()) + } +} + +class LombokEnvironmentConfigurator(testServices: TestServices) : EnvironmentConfigurator(testServices) { + companion object { + const val LOMBOK_CONFIG_NAME = "lombok.config" + private const val guavaPropertyName = "org.jetbrains.kotlin.test.guava-location" + + val GUAVA_JAR: File + get() = EnvironmentBasedStandardLibrariesPathProvider.getFile(guavaPropertyName) + } + + override val directiveContainers: List + get() = listOf(LombokDirectives) + + override fun configureCompilerConfiguration(configuration: CompilerConfiguration, module: TestModule) { + configuration.addJvmClasspathRoot(PathUtil.getResourcePathForClass(Getter::class.java)) + if (WITH_GUAVA in module.directives) { + configuration.addJvmClasspathRoot(GUAVA_JAR) + } + + val lombokConfig = findLombokConfig(module) ?: return + lombokConfig.copyTo(testServices.sourceFileProvider.javaSourceDirectory.resolve(lombokConfig.name)) + configuration.put(LombokConfigurationKeys.CONFIG_FILE, lombokConfig) + } + + private fun findLombokConfig(module: TestModule): File? { + return module.files.singleOrNull { it.name == LOMBOK_CONFIG_NAME }?.let { + testServices.sourceFileProvider.getRealFileForSourceFile(it) + } + } + + override fun ExtensionStorage.registerCompilerExtensions(module: TestModule, configuration: CompilerConfiguration) { + LombokComponentRegistrar.registerComponents(this, configuration) + } +} + +class LombokRuntimeClassPathProvider(testServices: TestServices) : RuntimeClasspathProvider(testServices) { + override fun runtimeClassPaths(module: TestModule): List { + return if (WITH_GUAVA in module.directives) { + listOf(GUAVA_JAR) + } else { + emptyList() + } + } +} + +object LombokDirectives : SimpleDirectivesContainer() { + val WITH_GUAVA by directive("Add guava to classpath") +} diff --git a/plugins/lombok/tests/org/jetbrains/kotlin/lombok/LombokTests.kt b/plugins/lombok/tests/org/jetbrains/kotlin/lombok/LombokTests.kt index 01940403686..a00986243d4 100644 --- a/plugins/lombok/tests/org/jetbrains/kotlin/lombok/LombokTests.kt +++ b/plugins/lombok/tests/org/jetbrains/kotlin/lombok/LombokTests.kt @@ -5,26 +5,13 @@ package org.jetbrains.kotlin.lombok -import lombok.Getter -import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoot -import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar.ExtensionStorage -import org.jetbrains.kotlin.config.CompilerConfiguration import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder -import org.jetbrains.kotlin.test.directives.model.RegisteredDirectives -import org.jetbrains.kotlin.test.model.TestFile -import org.jetbrains.kotlin.test.model.TestModule import org.jetbrains.kotlin.test.runners.AbstractDiagnosticTest import org.jetbrains.kotlin.test.runners.AbstractFirDiagnosticTest import org.jetbrains.kotlin.test.runners.codegen.AbstractBlackBoxCodegenTest import org.jetbrains.kotlin.test.runners.codegen.AbstractFirBlackBoxCodegenTest import org.jetbrains.kotlin.test.runners.codegen.AbstractIrBlackBoxCodegenTest import org.jetbrains.kotlin.test.runners.configurationForClassicAndFirTestsAlongside -import org.jetbrains.kotlin.test.services.AdditionalSourceProvider -import org.jetbrains.kotlin.test.services.EnvironmentConfigurator -import org.jetbrains.kotlin.test.services.TestServices -import org.jetbrains.kotlin.test.services.sourceFileProvider -import org.jetbrains.kotlin.utils.PathUtil -import java.io.File // ---------------------------- box ---------------------------- @@ -71,38 +58,5 @@ open class AbstractFirDiagnosticTestForLombok : AbstractFirDiagnosticTest() { fun TestConfigurationBuilder.enableLombok() { useConfigurators(::LombokEnvironmentConfigurator) useAdditionalSourceProviders(::LombokAdditionalSourceFileProvider) -} - -class LombokAdditionalSourceFileProvider(testServices: TestServices) : AdditionalSourceProvider(testServices) { - companion object { - const val COMMON_SOURCE_PATH = "plugins/lombok/testData/common.kt" - } - - override fun produceAdditionalFiles(globalDirectives: RegisteredDirectives, module: TestModule): List { - return listOf(File(COMMON_SOURCE_PATH).toTestFile()) - } -} - -class LombokEnvironmentConfigurator(testServices: TestServices) : EnvironmentConfigurator(testServices) { - companion object { - const val LOMBOK_CONFIG_NAME = "lombok.config" - } - - override fun configureCompilerConfiguration(configuration: CompilerConfiguration, module: TestModule) { - configuration.addJvmClasspathRoot(PathUtil.getResourcePathForClass(Getter::class.java)) - - val lombokConfig = findLombokConfig(module) ?: return - lombokConfig.copyTo(testServices.sourceFileProvider.javaSourceDirectory.resolve(lombokConfig.name)) - configuration.put(LombokConfigurationKeys.CONFIG_FILE, lombokConfig) - } - - private fun findLombokConfig(module: TestModule): File? { - return module.files.singleOrNull { it.name == LOMBOK_CONFIG_NAME }?.let { - testServices.sourceFileProvider.getRealFileForSourceFile(it) - } - } - - override fun ExtensionStorage.registerCompilerExtensions(module: TestModule, configuration: CompilerConfiguration) { - LombokComponentRegistrar.registerComponents(this, configuration) - } + useCustomRuntimeClasspathProviders(::LombokRuntimeClassPathProvider) }