Fix primitive override with inline class in Kotlin-Java inheritance

2018-08-22 11:00:57 +03:00
parent 01eca8bac8
commit 34548a0667
15 changed files with 241 additions and 28 deletions
@@ -9,8 +9,9 @@ import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.junit.Assert
-import java.util.*
+import java.io.File
 import java.util.regex.Pattern
+import kotlin.collections.HashMap

 const val LANGUAGE_DIRECTIVE = "LANGUAGE"
 const val API_VERSION_DIRECTIVE = "API_VERSION"
@@ -80,6 +81,14 @@ fun parseLanguageVersionSettings(directiveMap: Map<String, String>): CompilerTes
 fun defaultLanguageVersionSettings(): CompilerTestLanguageVersionSettings =
    CompilerTestLanguageVersionSettings(emptyMap(), ApiVersion.LATEST_STABLE, LanguageVersion.LATEST_STABLE)

+fun setupLanguageVersionSettingsForMultifileCompilerTests(files: List<File>, environment: KotlinCoreEnvironment) {
+    val allDirectives = HashMap<String, String>()
+    for (file in files) {
+        allDirectives.putAll(KotlinTestUtils.parseDirectives(file.readText()))
+    }
+    environment.configuration.languageVersionSettings = parseLanguageVersionSettingsOrDefault(allDirectives)
+}
+
 fun setupLanguageVersionSettingsForCompilerTests(originalFileText: String, environment: KotlinCoreEnvironment) {
    val directives = KotlinTestUtils.parseDirectives(originalFileText)
    val languageVersionSettings = parseLanguageVersionSettingsOrDefault(directives)
@@ -17,6 +17,8 @@
 package org.jetbrains.kotlin.jvm.compiler

 import com.intellij.openapi.Disposable
+import org.jetbrains.kotlin.checkers.setupLanguageVersionSettingsForCompilerTests
+import org.jetbrains.kotlin.checkers.setupLanguageVersionSettingsForMultifileCompilerTests
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
@@ -62,22 +64,27 @@ abstract class AbstractCompileJavaAgainstKotlinTest : TestCaseWithTmpdir() {
        val out = File(tmpdir, "out")

        val compiledSuccessfully = if (useJavac) {
-            compileKotlinWithJava(listOf(javaFile),
-                                  listOf(ktFile),
-                                  out, testRootDisposable)
+            compileKotlinWithJava(
+                listOf(javaFile),
+                listOf(ktFile),
+                out, testRootDisposable
+            )
        } else {
-            KotlinTestUtils.compileKotlinWithJava(listOf(javaFile),
-                                                  listOf(ktFile),
-                                                  out, testRootDisposable, javaErrorFile)
+            KotlinTestUtils.compileKotlinWithJava(
+                listOf(javaFile),
+                listOf(ktFile),
+                out, testRootDisposable, javaErrorFile
+            )
        }

        if (!compiledSuccessfully) return

        val environment = KotlinCoreEnvironment.createForTests(
-                testRootDisposable,
-                newConfiguration(ConfigurationKind.ALL, TestJdkKind.FULL_JDK, getAnnotationsJar(), out),
-                EnvironmentConfigFiles.JVM_CONFIG_FILES
+            testRootDisposable,
+            newConfiguration(ConfigurationKind.ALL, TestJdkKind.FULL_JDK, getAnnotationsJar(), out),
+            EnvironmentConfigFiles.JVM_CONFIG_FILES
        )
+        setupLanguageVersionSettingsForCompilerTests(ktFile.readText(), environment)

        val analysisResult = JvmResolveUtil.analyze(environment)
        val packageView = analysisResult.moduleDescriptor.getPackage(LoadDescriptorUtil.TEST_PACKAGE_FQNAME)
@@ -89,22 +96,24 @@ abstract class AbstractCompileJavaAgainstKotlinTest : TestCaseWithTmpdir() {

    @Throws(IOException::class)
    fun compileKotlinWithJava(
-            javaFiles: List<File>,
-            ktFiles: List<File>,
-            outDir: File,
-            disposable: Disposable
+        javaFiles: List<File>,
+        ktFiles: List<File>,
+        outDir: File,
+        disposable: Disposable
    ): Boolean {
        val environment = createEnvironmentWithMockJdkAndIdeaAnnotations(disposable)
+        setupLanguageVersionSettingsForMultifileCompilerTests(ktFiles, environment)
        environment.configuration.put(JVMConfigurationKeys.USE_JAVAC, true)
        environment.configuration.put(JVMConfigurationKeys.COMPILE_JAVA, true)
        environment.configuration.put(JVMConfigurationKeys.OUTPUT_DIRECTORY, outDir)
        environment.configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, MessageCollector.NONE)
-        environment.registerJavac(javaFiles = javaFiles,
-                                  kotlinFiles = listOf(KotlinTestUtils.loadJetFile(environment.project, ktFiles.first())))
+        environment.registerJavac(
+            javaFiles = javaFiles,
+            kotlinFiles = listOf(KotlinTestUtils.loadJetFile(environment.project, ktFiles.first()))
+        )
        if (!ktFiles.isEmpty()) {
            LoadDescriptorUtil.compileKotlinToDirAndGetModule(ktFiles, outDir, environment)
-        }
-        else {
+        } else {
            val mkdirs = outDir.mkdirs()
            assert(mkdirs) { "Not created: $outDir" }
        }
@@ -116,14 +125,14 @@ abstract class AbstractCompileJavaAgainstKotlinTest : TestCaseWithTmpdir() {
        // Do not render parameter names because there are test cases where classes inherit from JDK collections,
        // and some versions of JDK have debug information in the class files (including parameter names), and some don't
        private val CONFIGURATION = AbstractLoadJavaTest.COMPARATOR_CONFIGURATION.withRenderer(
-                DescriptorRenderer.withOptions {
-                    withDefinedIn = false
-                    parameterNameRenderingPolicy = ParameterNameRenderingPolicy.NONE
-                    verbose = true
-                    annotationArgumentsRenderingPolicy = AnnotationArgumentsRenderingPolicy.UNLESS_EMPTY
-                    excludedAnnotationClasses = setOf(FqName(Retention::class.java.name))
-                    modifiers = DescriptorRendererModifier.ALL
-                }
+            DescriptorRenderer.withOptions {
+                withDefinedIn = false
+                parameterNameRenderingPolicy = ParameterNameRenderingPolicy.NONE
+                verbose = true
+                annotationArgumentsRenderingPolicy = AnnotationArgumentsRenderingPolicy.UNLESS_EMPTY
+                excludedAnnotationClasses = setOf(FqName(Retention::class.java.name))
+                modifiers = DescriptorRendererModifier.ALL
+            }
        )
    }
 }
@@ -40,6 +40,7 @@ import org.jetbrains.kotlin.analyzer.AnalysisResult;
 import org.jetbrains.kotlin.builtins.DefaultBuiltIns;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.checkers.CompilerTestLanguageVersionSettings;
+import org.jetbrains.kotlin.checkers.CompilerTestLanguageVersionSettingsKt;
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys;
 import org.jetbrains.kotlin.cli.common.config.ContentRootsKt;
 import org.jetbrains.kotlin.cli.common.config.KotlinSourceRoot;
@@ -681,6 +682,7 @@ public class KotlinTestUtils {
    ) throws IOException {
        if (!ktFiles.isEmpty()) {
            KotlinCoreEnvironment environment = createEnvironmentWithFullJdkAndIdeaAnnotations(disposable);
+            CompilerTestLanguageVersionSettingsKt.setupLanguageVersionSettingsForMultifileCompilerTests(ktFiles, environment);
            LoadDescriptorUtil.compileKotlinToDirAndGetModule(ktFiles, outDir, environment);
        }
        else {
@@ -39,6 +39,7 @@ import org.jetbrains.kotlin.analyzer.AnalysisResult;
 import org.jetbrains.kotlin.builtins.DefaultBuiltIns;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.checkers.CompilerTestLanguageVersionSettings;
+import org.jetbrains.kotlin.checkers.CompilerTestLanguageVersionSettingsKt;
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys;
 import org.jetbrains.kotlin.cli.common.config.ContentRootsKt;
 import org.jetbrains.kotlin.cli.common.config.KotlinSourceRoot;
@@ -680,6 +681,7 @@ public class KotlinTestUtils {
    ) throws IOException {
        if (!ktFiles.isEmpty()) {
            KotlinCoreEnvironment environment = createEnvironmentWithFullJdkAndIdeaAnnotations(disposable);
+            CompilerTestLanguageVersionSettingsKt.setupLanguageVersionSettingsForMultifileCompilerTests(ktFiles, environment);
            LoadDescriptorUtil.compileKotlinToDirAndGetModule(ktFiles, outDir, environment);
        }
        else {
@@ -38,6 +38,7 @@ import org.jetbrains.kotlin.analyzer.AnalysisResult;
 import org.jetbrains.kotlin.builtins.DefaultBuiltIns;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.checkers.CompilerTestLanguageVersionSettings;
+import org.jetbrains.kotlin.checkers.CompilerTestLanguageVersionSettingsKt;
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys;
 import org.jetbrains.kotlin.cli.common.config.ContentRootsKt;
 import org.jetbrains.kotlin.cli.common.config.KotlinSourceRoot;
@@ -680,6 +681,7 @@ public class KotlinTestUtils {
    ) throws IOException {
        if (!ktFiles.isEmpty()) {
            KotlinCoreEnvironment environment = createEnvironmentWithFullJdkAndIdeaAnnotations(disposable);
+            CompilerTestLanguageVersionSettingsKt.setupLanguageVersionSettingsForMultifileCompilerTests(ktFiles, environment);
            LoadDescriptorUtil.compileKotlinToDirAndGetModule(ktFiles, outDir, environment);
        }
        else {
@@ -38,6 +38,7 @@ import org.jetbrains.kotlin.analyzer.AnalysisResult;
 import org.jetbrains.kotlin.builtins.DefaultBuiltIns;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.checkers.CompilerTestLanguageVersionSettings;
+import org.jetbrains.kotlin.checkers.CompilerTestLanguageVersionSettingsKt;
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys;
 import org.jetbrains.kotlin.cli.common.config.ContentRootsKt;
 import org.jetbrains.kotlin.cli.common.config.KotlinSourceRoot;
@@ -680,6 +681,7 @@ public class KotlinTestUtils {
    ) throws IOException {
        if (!ktFiles.isEmpty()) {
            KotlinCoreEnvironment environment = createEnvironmentWithFullJdkAndIdeaAnnotations(disposable);
+            CompilerTestLanguageVersionSettingsKt.setupLanguageVersionSettingsForMultifileCompilerTests(ktFiles, environment);
            LoadDescriptorUtil.compileKotlinToDirAndGetModule(ktFiles, outDir, environment);
        }
        else {