AbstractPsi2IrDiagnosticsTest

compiler/ir/ir.tests/ir.tests.iml

@@ -16,5 +16,6 @@
     <orderEntry type="module" module-name="ir.psi2ir" scope="TEST" />
     <orderEntry type="library" scope="TEST" name="junit-4.12" level="project" />
     <orderEntry type="module" module-name="backend.common" scope="TEST" />
+    <orderEntry type="module" module-name="compiler-tests" scope="TEST" />
   </component>
 </module>

compiler/ir/ir.tests/tests/org/jetbrains/kotlin/ir/AbstractIrGeneratorTestCase.kt

@@ -20,11 +20,14 @@ import junit.framework.TestCase
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.codegen.CodegenTestCase
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.ir.declarations.IrFile
 import org.jetbrains.kotlin.ir.declarations.IrModule
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi2ir.Psi2IrConfiguration
 import org.jetbrains.kotlin.psi2ir.Psi2IrTranslator
 import org.jetbrains.kotlin.resolve.AnalyzingUtils
+import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil
 import org.jetbrains.kotlin.test.ConfigurationKind
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
@@ -80,14 +83,7 @@ abstract class AbstractIrGeneratorTestCase : CodegenTestCase() {
     protected fun generateIrModule(ignoreErrors: Boolean = false): IrModule {
         assert(myFiles != null) { "myFiles not initialized" }
         assert(myEnvironment != null) { "myEnvironment not initialized" }
-        val analysisResult = JvmResolveUtil.analyze(myFiles.psiFiles, myEnvironment)
+        return generateIrModule(myFiles.psiFiles, myEnvironment, ignoreErrors)
-        if (!ignoreErrors) {
-            analysisResult.throwIfError()
-            AnalyzingUtils.throwExceptionOnErrors(analysisResult.bindingContext)
-        }
-        val psi2ir = Psi2IrTranslator(Psi2IrConfiguration(ignoreErrors))
-        val irModule = psi2ir.generateModule(analysisResult.moduleDescriptor, myFiles.psiFiles, analysisResult.bindingContext)
-        return irModule
     }
 
     protected fun generateIrFilesAsSingleModule(testFiles: List<TestFile>, ignoreErrors: Boolean = false): Map<TestFile, IrFile> {
@@ -112,6 +108,18 @@ abstract class AbstractIrGeneratorTestCase : CodegenTestCase() {
             }
             return textFile
         }
+
+        fun generateIrModule(ktFiles: List<KtFile>, environment: KotlinCoreEnvironment, ignoreErrors: Boolean = false): IrModule {
+            val analysisResult = JvmResolveUtil.analyze(ktFiles, environment)
+            if (!ignoreErrors) {
+                analysisResult.throwIfError()
+                AnalyzingUtils.throwExceptionOnErrors(analysisResult.bindingContext)
+            }
+            return generateIrModule(ktFiles, analysisResult.moduleDescriptor, analysisResult.bindingContext, ignoreErrors)
+        }
+
+        fun generateIrModule(ktFiles: List<KtFile>, moduleDescriptor: ModuleDescriptor, bindingContext: BindingContext, ignoreErrors: Boolean = false) =
+                Psi2IrTranslator(Psi2IrConfiguration(ignoreErrors)).generateModule(moduleDescriptor, ktFiles, bindingContext)
     }
 }
 

compiler/ir/ir.tests/tests/org/jetbrains/kotlin/ir/AbstractPsi2IrDiagnosticsTest.kt

@@ -0,0 +1,46 @@
+/*
+ * 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.ir
+
+import org.jetbrains.kotlin.checkers.AbstractDiagnosticsTest
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
+import org.jetbrains.kotlin.ir.util.dump
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.test.KotlinTestUtils
+import java.io.File
+
+abstract class AbstractPsi2IrDiagnosticsTest : AbstractDiagnosticsTest() {
+    override fun performAdditionalChecksAfterDiagnostics(
+            testDataFile: File,
+            testFiles: MutableList<TestFile>,
+            moduleFiles: MutableMap<TestModule?, MutableList<TestFile>>,
+            moduleDescriptors: MutableMap<TestModule?, ModuleDescriptorImpl>,
+            moduleBindings: MutableMap<TestModule?, BindingContext>
+    ) {
+        val actualIrDump = StringBuilder()
+        for (module in moduleFiles.keys) {
+            val ktFiles = moduleFiles[module]?.mapNotNull { it.jetFile } ?: continue
+            val moduleDescriptor = moduleDescriptors[module] ?: continue
+            val moduleBindingContext = moduleBindings[module] ?: continue
+            val irModule = AbstractIrGeneratorTestCase.generateIrModule(ktFiles, moduleDescriptor, moduleBindingContext, true)
+            actualIrDump.append(irModule.dump())
+        }
+
+        val expectedIrFile = File(testDataFile.canonicalPath.replace(".kt", ".ir.txt"))
+        KotlinTestUtils.assertEqualsToFile(expectedIrFile, actualIrDump.toString())
+    }
+}

compiler/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTest.java

@@ -208,6 +208,18 @@ public abstract class AbstractDiagnosticsTest extends BaseDiagnosticsTest {
         if (exceptionFromDynamicCallDescriptorsValidation != null) {
             throw ExceptionUtilsKt.rethrow(exceptionFromDynamicCallDescriptorsValidation);
         }
+
+        performAdditionalChecksAfterDiagnostics(testDataFile, testFiles, groupedByModule, modules, moduleBindings);
+    }
+
+    protected void performAdditionalChecksAfterDiagnostics(
+            File testDataFile,
+            List<TestFile> testFiles,
+            Map<TestModule, List<TestFile>> moduleFiles,
+            Map<TestModule, ModuleDescriptorImpl> moduleDescriptors,
+            Map<TestModule, BindingContext> moduleBindings
+    ) {
+        // To be overridden by diagnostic-like tests.
     }
 
     @Nullable