diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt index 17d13ab1b7a..8409d1bacaa 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt @@ -207,7 +207,7 @@ private fun JavaAnnotationArgument.toFirExpression(session: FirSession): FirExpr null } this.calleeReference = calleeReference - ?: FirErrorNamedReference(session, null, "Strange Java enum value: ${this@toFirExpression}") + ?: FirErrorNamedReference(session, null, "Strange Java enum value: $classId.$entryName") } } is JavaClassObjectAnnotationArgument -> FirGetClassCallImpl(session, null).apply { diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/EnhancementSignatureParts.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/EnhancementSignatureParts.kt index eb0bb43e7e3..4e4a3d27783 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/EnhancementSignatureParts.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/EnhancementSignatureParts.kt @@ -53,9 +53,12 @@ internal class EnhancementSignatureParts( } val containsFunctionN = current.toNotNullConeKotlinType().contains { - val classId = it.lookupTag.classId - classId.shortClassName == JavaToKotlinClassMap.FUNCTION_N_FQ_NAME.shortName() && - classId.asSingleFqName() == JavaToKotlinClassMap.FUNCTION_N_FQ_NAME + if (it is ConeClassErrorType) false + else { + val classId = it.lookupTag.classId + classId.shortClassName == JavaToKotlinClassMap.FUNCTION_N_FQ_NAME.shortName() && + classId.asSingleFqName() == JavaToKotlinClassMap.FUNCTION_N_FQ_NAME + } } val enhancedCurrent = current.enhance(qualifiersWithPredefined ?: qualifiers) diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirAnnotationTypeQualifierResolver.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirAnnotationTypeQualifierResolver.kt index 094929eb630..d83c0ec1127 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirAnnotationTypeQualifierResolver.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirAnnotationTypeQualifierResolver.kt @@ -10,8 +10,6 @@ import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.resolve.toSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol -import org.jetbrains.kotlin.fir.types.ConeClassLikeType -import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef import org.jetbrains.kotlin.load.java.* import org.jetbrains.kotlin.load.java.lazy.NullabilityQualifierWithApplicability import org.jetbrains.kotlin.utils.Jsr305State @@ -50,10 +48,7 @@ class FirAnnotationTypeQualifierResolver(private val jsr305State: Jsr305State) { } private val FirAnnotationCall.resolvedClass: FirRegularClass? - get() { - val lookupTag = ((annotationTypeRef as? FirResolvedTypeRef)?.type as? ConeClassLikeType)?.lookupTag - return (lookupTag?.toSymbol(session) as? FirClassSymbol)?.fir - } + get() = (coneClassLikeType?.lookupTag?.toSymbol(session) as? FirClassSymbol)?.fir fun resolveTypeQualifierAnnotation(annotationCall: FirAnnotationCall): FirAnnotationCall? { if (jsr305State.disabled) { diff --git a/compiler/fir/resolve/testData/enhancement/note.txt b/compiler/fir/resolve/testData/enhancement/note.txt new file mode 100644 index 00000000000..fb7bced66ab --- /dev/null +++ b/compiler/fir/resolve/testData/enhancement/note.txt @@ -0,0 +1 @@ +FIR enhancement tests use compiler/testData/loadJava/compilerJava \ No newline at end of file diff --git a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/AbstractFirResolveTestCase.kt b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/AbstractFirResolveTestCase.kt index 7cc528b9a9b..9e4b96a1b6c 100644 --- a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/AbstractFirResolveTestCase.kt +++ b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/AbstractFirResolveTestCase.kt @@ -27,7 +27,7 @@ abstract class AbstractFirResolveTestCase : AbstractFirResolveWithSessionTestCas val scope = GlobalSearchScope.filesScope(project, ktFiles.mapNotNull { it.virtualFile }) .uniteWith(TopDownAnalyzerFacadeForJVM.AllJavaSourcesInProjectScope(project)) - val session = createSession(scope) + val session = createSession(project, scope) val builder = RawFirBuilder(session, stubMode = false) diff --git a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/AbstractFirResolveWithSessionTestCase.kt b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/AbstractFirResolveWithSessionTestCase.kt index 8928c8f1ae6..a6c1bcf6a75 100644 --- a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/AbstractFirResolveWithSessionTestCase.kt +++ b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/AbstractFirResolveWithSessionTestCase.kt @@ -24,19 +24,4 @@ abstract class AbstractFirResolveWithSessionTestCase : KotlinTestWithEnvironment .unregisterExtension(JavaElementFinder::class.java) } - open fun createSession(sourceScope: GlobalSearchScope): FirSession { - val moduleInfo = FirTestModuleInfo() - val provider = FirProjectSessionProvider(project) - return FirJavaModuleBasedSession(moduleInfo, provider, sourceScope).also { - createSessionForDependencies(provider, moduleInfo, sourceScope) - } - } - - private fun createSessionForDependencies( - provider: FirProjectSessionProvider, moduleInfo: FirTestModuleInfo, sourceScope: GlobalSearchScope - ) { - val dependenciesInfo = FirTestModuleInfo() - moduleInfo.dependencies.add(dependenciesInfo) - FirLibrarySession(dependenciesInfo, provider, GlobalSearchScope.notScope(sourceScope)) - } } \ No newline at end of file diff --git a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/AbstractFirResolveWithSessionTestCase.kt.181 b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/AbstractFirResolveWithSessionTestCase.kt.181 index d847cc8b285..bccb8bbbe49 100644 --- a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/AbstractFirResolveWithSessionTestCase.kt.181 +++ b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/AbstractFirResolveWithSessionTestCase.kt.181 @@ -16,19 +16,4 @@ import org.jetbrains.kotlin.test.KotlinTestWithEnvironment abstract class AbstractFirResolveWithSessionTestCase : KotlinTestWithEnvironment() { - open fun createSession(sourceScope: GlobalSearchScope): FirSession { - val moduleInfo = FirTestModuleInfo() - val provider = FirProjectSessionProvider(project) - return FirJavaModuleBasedSession(moduleInfo, provider, sourceScope).also { - createSessionForDependencies(provider, moduleInfo, sourceScope) - } - } - - private fun createSessionForDependencies( - provider: FirProjectSessionProvider, moduleInfo: FirTestModuleInfo, sourceScope: GlobalSearchScope - ) { - val dependenciesInfo = FirTestModuleInfo() - moduleInfo.dependencies.add(dependenciesInfo) - FirLibrarySession(dependenciesInfo, provider, GlobalSearchScope.notScope(sourceScope)) - } } \ No newline at end of file diff --git a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirResolveTestTotalKotlin.kt b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirResolveTestTotalKotlin.kt index 8f83f279b57..a5404e3d6f9 100644 --- a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirResolveTestTotalKotlin.kt +++ b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirResolveTestTotalKotlin.kt @@ -64,7 +64,7 @@ class FirResolveTestTotalKotlin : AbstractFirResolveWithSessionTestCase() { } val scope = ProjectScope.getContentScope(project) - val session = createSession(scope) + val session = createSession(project, scope) val builder = RawFirBuilder(session, stubMode = true) val totalTransformer = FirTotalResolveTransformer() diff --git a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/SessionTestUtils.kt b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/SessionTestUtils.kt new file mode 100644 index 00000000000..f63d4a80a20 --- /dev/null +++ b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/SessionTestUtils.kt @@ -0,0 +1,28 @@ +/* + * Copyright 2010-2019 JetBrains s.r.o. 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.fir + +import com.intellij.openapi.project.Project +import com.intellij.psi.search.GlobalSearchScope +import org.jetbrains.kotlin.fir.java.FirJavaModuleBasedSession +import org.jetbrains.kotlin.fir.java.FirLibrarySession +import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider + +fun createSession(project: Project, sourceScope: GlobalSearchScope): FirSession { + val moduleInfo = FirTestModuleInfo() + val provider = FirProjectSessionProvider(project) + return FirJavaModuleBasedSession(moduleInfo, provider, sourceScope).also { + createSessionForDependencies(provider, moduleInfo, sourceScope) + } +} + +private fun createSessionForDependencies( + provider: FirProjectSessionProvider, moduleInfo: FirTestModuleInfo, sourceScope: GlobalSearchScope +) { + val dependenciesInfo = FirTestModuleInfo() + moduleInfo.dependencies.add(dependenciesInfo) + FirLibrarySession(dependenciesInfo, provider, GlobalSearchScope.notScope(sourceScope)) +} diff --git a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt new file mode 100644 index 00000000000..21a1663ddba --- /dev/null +++ b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt @@ -0,0 +1,217 @@ +/* + * Copyright 2010-2019 JetBrains s.r.o. 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.fir.java + +import com.intellij.lang.java.JavaLanguage +import com.intellij.openapi.extensions.Extensions +import com.intellij.openapi.project.Project +import com.intellij.openapi.util.io.FileUtil +import com.intellij.openapi.util.text.StringUtilRt +import com.intellij.psi.* +import com.intellij.psi.impl.PsiFileFactoryImpl +import com.intellij.psi.search.GlobalSearchScope +import com.intellij.testFramework.LightVirtualFile +import org.jetbrains.kotlin.asJava.finder.JavaElementFinder +import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles +import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment +import org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM +import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime +import org.jetbrains.kotlin.fir.FirRenderer +import org.jetbrains.kotlin.fir.createSession +import org.jetbrains.kotlin.fir.declarations.FirDeclaration +import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass +import org.jetbrains.kotlin.fir.java.declarations.FirJavaMethod +import org.jetbrains.kotlin.fir.java.scopes.JavaClassEnhancementScope +import org.jetbrains.kotlin.fir.resolve.FirScopeProvider +import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider +import org.jetbrains.kotlin.fir.resolve.impl.FirCompositeSymbolProvider +import org.jetbrains.kotlin.fir.scopes.ProcessorAction +import org.jetbrains.kotlin.fir.scopes.impl.FirCompositeScope +import org.jetbrains.kotlin.fir.service +import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol +import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.psi.psiUtil.getChildrenOfType +import org.jetbrains.kotlin.test.* +import org.jetbrains.kotlin.test.KotlinTestUtils.getAnnotationsJar +import org.jetbrains.kotlin.test.KotlinTestUtils.newConfiguration +import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase +import java.io.File +import java.io.IOException + +abstract class AbstractFirTypeEnhancementTest : KtUsefulTestCase() { + private lateinit var javaFilesDir: File + + private lateinit var environment: KotlinCoreEnvironment + + val project: Project + get() { + return environment.project + } + + @Throws(Exception::class) + override fun setUp() { + super.setUp() + javaFilesDir = KotlinTestUtils.tmpDirForTest(this) + } + + override fun tearDown() { + FileUtil.delete(javaFilesDir) + super.tearDown() + } + + private fun createJarWithForeignAnnotations(): File = + MockLibraryUtil.compileJavaFilesLibraryToJar(FOREIGN_ANNOTATIONS_SOURCES_PATH, "foreign-annotations") + + private fun createEnvironment(content: String): KotlinCoreEnvironment { + val classpath = mutableListOf(getAnnotationsJar(), ForTestCompileRuntime.runtimeJarForTests()) + if (InTextDirectivesUtils.isDirectiveDefined(content, "ANDROID_ANNOTATIONS")) { + classpath.add(ForTestCompileRuntime.androidAnnotationsForTests()) + } + if (InTextDirectivesUtils.isDirectiveDefined(content, "JVM_ANNOTATIONS")) { + classpath.add(ForTestCompileRuntime.jvmAnnotationsForTests()) + } + if (InTextDirectivesUtils.isDirectiveDefined(content, "FOREIGN_ANNOTATIONS")) { + classpath.add(createJarWithForeignAnnotations()) + } + return KotlinCoreEnvironment.createForTests( + testRootDisposable, + newConfiguration( + ConfigurationKind.JDK_NO_RUNTIME, TestJdkKind.FULL_JDK, classpath, listOf(javaFilesDir) + ), + EnvironmentConfigFiles.JVM_CONFIG_FILES + ).apply { + Extensions.getArea(project) + .getExtensionPoint(PsiElementFinder.EP_NAME) + .unregisterExtension(JavaElementFinder::class.java) + } + } + + fun doTest(path: String) { + val javaFile = File(path) + val javaLines = javaFile.readLines() + val content = javaLines.joinToString(separator = "\n") + if (InTextDirectivesUtils.isDirectiveDefined(content, "SKIP_IN_FIR_TEST")) return + + val srcFiles = KotlinTestUtils.createTestFiles( + javaFile.name, FileUtil.loadFile(javaFile, true), + object : KotlinTestUtils.TestFileFactoryNoModules() { + override fun create(fileName: String, text: String, directives: Map): File { + var currentDir = javaFilesDir + if ("/" !in fileName) { + val packageFqName = + text.split("\n").firstOrNull { + it.startsWith("package") + }?.substringAfter("package")?.trim()?.substringBefore(";")?.let { name -> + FqName(name) + } ?: FqName.ROOT + for (segment in packageFqName.pathSegments()) { + currentDir = File(currentDir, segment.asString()).apply { mkdir() } + } + } + val targetFile = File(currentDir, fileName) + try { + FileUtil.writeToFile(targetFile, text) + } catch (e: IOException) { + throw AssertionError(e) + } + + return targetFile + } + }, "" + ) + environment = createEnvironment(content) + val virtualFiles = srcFiles.map { + object : LightVirtualFile( + it.name, JavaLanguage.INSTANCE, StringUtilRt.convertLineSeparators(it.readText()) + ) { + override fun getPath(): String { + //TODO: patch LightVirtualFile + return "/${it.name}" + } + } + } + val factory = PsiFileFactory.getInstance(project) as PsiFileFactoryImpl + val psiFiles = virtualFiles.map { factory.trySetupPsiForFile(it, JavaLanguage.INSTANCE, true, false)!! } + + val scope = GlobalSearchScope.filesScope(project, virtualFiles) + .uniteWith(TopDownAnalyzerFacadeForJVM.AllJavaSourcesInProjectScope(project)) + val session = createSession(project, scope) + + val topPsiClasses = psiFiles.flatMap { it.getChildrenOfType().toList() } + + val javaFirDump = StringBuilder().also { builder -> + val renderer = FirRenderer(builder) + val symbolProvider = session.service() as FirCompositeSymbolProvider + val javaProvider = symbolProvider.providers.filterIsInstance().first() + + fun processClassWithChildren(psiClass: PsiClass, parentFqName: FqName) { + val psiFile = psiClass.containingFile + val packageStatement = psiFile.children.filterIsInstance().firstOrNull() + val packageName = packageStatement?.packageName + val fqName = parentFqName.child(Name.identifier(psiClass.name!!)) + val classId = ClassId(packageName?.let { FqName(it) } ?: FqName.ROOT, fqName, false) + javaProvider.getClassLikeSymbolByFqName(classId) + ?: throw AssertionError(classId.asString()) + psiClass.innerClasses.forEach { + processClassWithChildren(psiClass = it, parentFqName = fqName) + } + } + for (psiClass in topPsiClasses) { + processClassWithChildren(psiClass, FqName.ROOT) + } + + val processedJavaClasses = mutableSetOf() + for (javaClass in javaProvider.getJavaTopLevelClasses().sortedBy { it.name }) { + if (javaClass !is FirJavaClass || javaClass in processedJavaClasses) continue + val enhancementScope = session.service().getDeclaredMemberScope(javaClass, session).let { + when (it) { + is FirCompositeScope -> it.scopes.filterIsInstance().first() + is JavaClassEnhancementScope -> it + else -> null + } + } + if (enhancementScope == null) { + javaClass.accept(renderer, null) + } else { + renderer.visitMemberDeclaration(javaClass) + renderer.renderSupertypes(javaClass) + renderer.renderInBraces { + val renderedDeclarations = mutableListOf() + for (declaration in javaClass.declarations) { + if (declaration in renderedDeclarations) continue + when (declaration) { + is FirJavaMethod -> enhancementScope.processFunctionsByName(declaration.name) { symbol -> + val enhanced = (symbol as? FirFunctionSymbol)?.fir + if (enhanced != null && enhanced !in renderedDeclarations) { + enhanced.accept(renderer, null) + renderer.newLine() + renderedDeclarations += enhanced + } + ProcessorAction.NEXT + } + else -> { + declaration.accept(renderer, null) + renderer.newLine() + renderedDeclarations += declaration + } + } + } + } + } + processedJavaClasses += javaClass + } + }.toString() + + val expectedFile = File(javaFile.absolutePath.replace(".java", ".fir.txt")) + KotlinTestUtils.assertEqualsToFile(expectedFile, javaFirDump) + } + + companion object { + private const val FOREIGN_ANNOTATIONS_SOURCES_PATH = "third-party/annotations" + } +} diff --git a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/java/FirTypeEnhancementTestGenerated.java b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/java/FirTypeEnhancementTestGenerated.java new file mode 100644 index 00000000000..58eb58efabc --- /dev/null +++ b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/java/FirTypeEnhancementTestGenerated.java @@ -0,0 +1,1648 @@ +/* + * Copyright 2010-2019 JetBrains s.r.o. 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.fir.java; + +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("compiler/testData/loadJava/compiledJava") +@TestDataPath("$PROJECT_ROOT") +@RunWith(JUnit3RunnerWithInners.class) +public class FirTypeEnhancementTestGenerated extends AbstractFirTypeEnhancementTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); + } + + public void testAllFilesPresentInCompiledJava() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledJava"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true); + } + + @TestMetadata("ArrayTypeVariance.java") + public void testArrayTypeVariance() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/ArrayTypeVariance.java"); + } + + @TestMetadata("ClassDoesNotOverrideMethod.java") + public void testClassDoesNotOverrideMethod() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/ClassDoesNotOverrideMethod.java"); + } + + @TestMetadata("ClassWithConstVal.java") + public void testClassWithConstVal() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/ClassWithConstVal.java"); + } + + @TestMetadata("ClassWithTypeP.java") + public void testClassWithTypeP() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/ClassWithTypeP.java"); + } + + @TestMetadata("ClassWithTypePExtendsIterableP.java") + public void testClassWithTypePExtendsIterableP() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/ClassWithTypePExtendsIterableP.java"); + } + + @TestMetadata("ClassWithTypePP.java") + public void testClassWithTypePP() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/ClassWithTypePP.java"); + } + + @TestMetadata("ClassWithTypePRefNext.java") + public void testClassWithTypePRefNext() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/ClassWithTypePRefNext.java"); + } + + @TestMetadata("ClassWithTypePRefSelf.java") + public void testClassWithTypePRefSelf() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/ClassWithTypePRefSelf.java"); + } + + @TestMetadata("ClassWithTypePRefSelfAndClass.java") + public void testClassWithTypePRefSelfAndClass() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/ClassWithTypePRefSelfAndClass.java"); + } + + @TestMetadata("FieldAsVar.java") + public void testFieldAsVar() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/FieldAsVar.java"); + } + + @TestMetadata("FieldOfArrayType.java") + public void testFieldOfArrayType() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/FieldOfArrayType.java"); + } + + @TestMetadata("FinalFieldAsVal.java") + public void testFinalFieldAsVal() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/FinalFieldAsVal.java"); + } + + @TestMetadata("InheritMethodsDifferentReturnTypes.java") + public void testInheritMethodsDifferentReturnTypes() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/InheritMethodsDifferentReturnTypes.java"); + } + + @TestMetadata("InheritMethodsDifferentReturnTypesGeneric.java") + public void testInheritMethodsDifferentReturnTypesGeneric() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/InheritMethodsDifferentReturnTypesGeneric.java"); + } + + @TestMetadata("InnerClass.java") + public void testInnerClass() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/InnerClass.java"); + } + + @TestMetadata("InnerClassReferencesOuterTP.java") + public void testInnerClassReferencesOuterTP() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/InnerClassReferencesOuterTP.java"); + } + + @TestMetadata("InnerClassTypeMultipleGeneric.java") + public void testInnerClassTypeMultipleGeneric() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/InnerClassTypeMultipleGeneric.java"); + } + + @TestMetadata("InnerClassesInGeneric.java") + public void testInnerClassesInGeneric() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/InnerClassesInGeneric.java"); + } + + @TestMetadata("InnerOfGeneric.java") + public void testInnerOfGeneric() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/InnerOfGeneric.java"); + } + + @TestMetadata("IntrinsicCompanionObject.java") + public void testIntrinsicCompanionObject() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/IntrinsicCompanionObject.java"); + } + + @TestMetadata("MethodReferencesOuterClassTP.java") + public void testMethodReferencesOuterClassTP() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/MethodReferencesOuterClassTP.java"); + } + + @TestMetadata("MethodTypePOneUpperBound.java") + public void testMethodTypePOneUpperBound() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/MethodTypePOneUpperBound.java"); + } + + @TestMetadata("MethodTypePTwoUpperBounds.java") + public void testMethodTypePTwoUpperBounds() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/MethodTypePTwoUpperBounds.java"); + } + + @TestMetadata("MethodWithTypeP.java") + public void testMethodWithTypeP() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/MethodWithTypeP.java"); + } + + @TestMetadata("MethodWithTypePP.java") + public void testMethodWithTypePP() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/MethodWithTypePP.java"); + } + + @TestMetadata("MethodWithTypePRefClassP.java") + public void testMethodWithTypePRefClassP() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/MethodWithTypePRefClassP.java"); + } + + @TestMetadata("MethosWithPRefTP.java") + public void testMethosWithPRefTP() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/MethosWithPRefTP.java"); + } + + @TestMetadata("MyException.java") + public void testMyException() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/MyException.java"); + } + + @TestMetadata("NestedClass.java") + public void testNestedClass() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/NestedClass.java"); + } + + @TestMetadata("OverrideMethod.java") + public void testOverrideMethod() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/OverrideMethod.java"); + } + + @TestMetadata("PackageLocalVisibility.java") + public void testPackageLocalVisibility() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/PackageLocalVisibility.java"); + } + + @TestMetadata("PrivateMembers.java") + public void testPrivateMembers() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/PrivateMembers.java"); + } + + @TestMetadata("PrivateMembersInHierarchy.java") + public void testPrivateMembersInHierarchy() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/PrivateMembersInHierarchy.java"); + } + + @TestMetadata("RawOverrides.java") + public void testRawOverrides() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/RawOverrides.java"); + } + + @TestMetadata("RawTypeWithUpperBound.java") + public void testRawTypeWithUpperBound() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/RawTypeWithUpperBound.java"); + } + + @TestMetadata("RawUpperBound.java") + public void testRawUpperBound() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/RawUpperBound.java"); + } + + @TestMetadata("RecursiveRawUpperBound.java") + public void testRecursiveRawUpperBound() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/RecursiveRawUpperBound.java"); + } + + @TestMetadata("RecursiveWildcardUpperBound.java") + public void testRecursiveWildcardUpperBound() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/RecursiveWildcardUpperBound.java"); + } + + @TestMetadata("RemoveRedundantProjectionKind.java") + public void testRemoveRedundantProjectionKind() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/RemoveRedundantProjectionKind.java"); + } + + @TestMetadata("Simple.java") + public void testSimple() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/Simple.java"); + } + + @TestMetadata("SubclassFromNested.java") + public void testSubclassFromNested() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/SubclassFromNested.java"); + } + + @TestMetadata("TopLevel$Class.java") + public void testTopLevel$Class() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/TopLevel$Class.java"); + } + + @TestMetadata("TwoFields.java") + public void testTwoFields() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/TwoFields.java"); + } + + @TestMetadata("UnboundWildcard.java") + public void testUnboundWildcard() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/UnboundWildcard.java"); + } + + @TestMetadata("WildcardBounds.java") + public void testWildcardBounds() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/WildcardBounds.java"); + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/annotations") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Annotations extends AbstractFirTypeEnhancementTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); + } + + public void testAllFilesPresentInAnnotations() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledJava/annotations"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true); + } + + @TestMetadata("AnnotatedAnnotation.java") + public void testAnnotatedAnnotation() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/AnnotatedAnnotation.java"); + } + + @TestMetadata("AnnotatedConstructor.java") + public void testAnnotatedConstructor() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/AnnotatedConstructor.java"); + } + + @TestMetadata("AnnotatedEnumEntry.java") + public void testAnnotatedEnumEntry() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/AnnotatedEnumEntry.java"); + } + + @TestMetadata("AnnotatedField.java") + public void testAnnotatedField() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/AnnotatedField.java"); + } + + @TestMetadata("AnnotatedMethod.java") + public void testAnnotatedMethod() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/AnnotatedMethod.java"); + } + + @TestMetadata("AnnotatedParameterInEnumClassConstructor.java") + public void testAnnotatedParameterInEnumClassConstructor() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/AnnotatedParameterInEnumClassConstructor.java"); + } + + @TestMetadata("AnnotatedParameterInInnerClassConstructor.java") + public void testAnnotatedParameterInInnerClassConstructor() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/AnnotatedParameterInInnerClassConstructor.java"); + } + + @TestMetadata("AnnotatedTypeInEnumClassConstructor.java") + public void testAnnotatedTypeInEnumClassConstructor() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/AnnotatedTypeInEnumClassConstructor.java"); + } + + @TestMetadata("AnnotatedTypeInEnumClassConstructor2.java") + public void testAnnotatedTypeInEnumClassConstructor2() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/AnnotatedTypeInEnumClassConstructor2.java"); + } + + @TestMetadata("AnnotatedTypeInFun.java") + public void testAnnotatedTypeInFun() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/AnnotatedTypeInFun.java"); + } + + @TestMetadata("AnnotatedTypeInInnerClassConstructor.java") + public void testAnnotatedTypeInInnerClassConstructor() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/AnnotatedTypeInInnerClassConstructor.java"); + } + + @TestMetadata("AnnotatedTypeInInnerClassConstructor2.java") + public void testAnnotatedTypeInInnerClassConstructor2() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/AnnotatedTypeInInnerClassConstructor2.java"); + } + + @TestMetadata("AnnotatedValueParameter.java") + public void testAnnotatedValueParameter() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/AnnotatedValueParameter.java"); + } + + @TestMetadata("AnnotationInParam.java") + public void testAnnotationInParam() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/AnnotationInParam.java"); + } + + @TestMetadata("AnnotationRetentions.java") + public void testAnnotationRetentions() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/AnnotationRetentions.java"); + } + + @TestMetadata("AnnotationTargets.java") + public void testAnnotationTargets() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/AnnotationTargets.java"); + } + + @TestMetadata("ArithmeticExpressionInParam.java") + public void testArithmeticExpressionInParam() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/ArithmeticExpressionInParam.java"); + } + + @TestMetadata("ArrayOfEnumInParam.java") + public void testArrayOfEnumInParam() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/ArrayOfEnumInParam.java"); + } + + @TestMetadata("ArrayOfStringInParam.java") + public void testArrayOfStringInParam() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/ArrayOfStringInParam.java"); + } + + @TestMetadata("ClassObjectArrayInParam.java") + public void testClassObjectArrayInParam() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/ClassObjectArrayInParam.java"); + } + + @TestMetadata("ClassObjectInParam.java") + public void testClassObjectInParam() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParam.java"); + } + + @TestMetadata("ClassObjectInParamRaw.java") + public void testClassObjectInParamRaw() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParamRaw.java"); + } + + @TestMetadata("ClassObjectInParamVariance.java") + public void testClassObjectInParamVariance() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParamVariance.java"); + } + + @TestMetadata("CustomAnnotation.java") + public void testCustomAnnotation() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/CustomAnnotation.java"); + } + + @TestMetadata("CustomAnnotationWithDefaultParameter.java") + public void testCustomAnnotationWithDefaultParameter() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/CustomAnnotationWithDefaultParameter.java"); + } + + @TestMetadata("EmptyArrayInParam.java") + public void testEmptyArrayInParam() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/EmptyArrayInParam.java"); + } + + @TestMetadata("EnumArgumentWithCustomToString.java") + public void testEnumArgumentWithCustomToString() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/EnumArgumentWithCustomToString.java"); + } + + @TestMetadata("EnumConstructorParameter.java") + public void testEnumConstructorParameter() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/EnumConstructorParameter.java"); + } + + @TestMetadata("EnumInParam.java") + public void testEnumInParam() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/EnumInParam.java"); + } + + @TestMetadata("JavaDocDeprecated.java") + public void testJavaDocDeprecated() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/JavaDocDeprecated.java"); + } + + @TestMetadata("NestedEnumArgument.java") + public void testNestedEnumArgument() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/NestedEnumArgument.java"); + } + + @TestMetadata("PrimitiveValueInParam.java") + public void testPrimitiveValueInParam() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/PrimitiveValueInParam.java"); + } + + @TestMetadata("RecursiveAnnotation.java") + public void testRecursiveAnnotation() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/RecursiveAnnotation.java"); + } + + @TestMetadata("RecursiveAnnotation2.java") + public void testRecursiveAnnotation2() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/RecursiveAnnotation2.java"); + } + + @TestMetadata("SimpleAnnotation.java") + public void testSimpleAnnotation() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/SimpleAnnotation.java"); + } + + @TestMetadata("StringConcatenationInParam.java") + public void testStringConcatenationInParam() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/StringConcatenationInParam.java"); + } + + @TestMetadata("StringConstantInParam.java") + public void testStringConstantInParam() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/StringConstantInParam.java"); + } + + @TestMetadata("StringInParam.java") + public void testStringInParam() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/StringInParam.java"); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/constructor") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Constructor extends AbstractFirTypeEnhancementTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); + } + + public void testAllFilesPresentInConstructor() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledJava/constructor"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true); + } + + @TestMetadata("ConstructorGenericDeep.java") + public void testConstructorGenericDeep() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/constructor/ConstructorGenericDeep.java"); + } + + @TestMetadata("ConstructorGenericSimple.java") + public void testConstructorGenericSimple() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/constructor/ConstructorGenericSimple.java"); + } + + @TestMetadata("ConstructorGenericUpperBound.java") + public void testConstructorGenericUpperBound() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/constructor/ConstructorGenericUpperBound.java"); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/enum") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Enum extends AbstractFirTypeEnhancementTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); + } + + public void testAllFilesPresentInEnum() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledJava/enum"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true); + } + + @TestMetadata("EnumMembers.java") + public void testEnumMembers() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/enum/EnumMembers.java"); + } + + @TestMetadata("EnumWithSpecializedEntry.java") + public void testEnumWithSpecializedEntry() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/enum/EnumWithSpecializedEntry.java"); + } + + @TestMetadata("JavaEnum.java") + public void testJavaEnum() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/enum/JavaEnum.java"); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/javaBean") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class JavaBean extends AbstractFirTypeEnhancementTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); + } + + public void testAllFilesPresentInJavaBean() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledJava/javaBean"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true); + } + + @TestMetadata("DifferentGetterAndSetter.java") + public void testDifferentGetterAndSetter() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/javaBean/DifferentGetterAndSetter.java"); + } + + @TestMetadata("JavaBeanAbstractGetter.java") + public void testJavaBeanAbstractGetter() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/javaBean/JavaBeanAbstractGetter.java"); + } + + @TestMetadata("JavaBeanVal.java") + public void testJavaBeanVal() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/javaBean/JavaBeanVal.java"); + } + + @TestMetadata("JavaBeanVar.java") + public void testJavaBeanVar() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/javaBean/JavaBeanVar.java"); + } + + @TestMetadata("JavaBeanVarOfGenericType.java") + public void testJavaBeanVarOfGenericType() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/javaBean/JavaBeanVarOfGenericType.java"); + } + + @TestMetadata("TwoSetters.java") + public void testTwoSetters() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/javaBean/TwoSetters.java"); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class KotlinSignature extends AbstractFirTypeEnhancementTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); + } + + @TestMetadata("AllBoundsInWhen.java") + public void testAllBoundsInWhen() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/AllBoundsInWhen.java"); + } + + public void testAllFilesPresentInKotlinSignature() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true); + } + + @TestMetadata("ArrayType.java") + public void testArrayType() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/ArrayType.java"); + } + + @TestMetadata("ConstructorWithNewTypeParams.java") + public void testConstructorWithNewTypeParams() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/ConstructorWithNewTypeParams.java"); + } + + @TestMetadata("ConstructorWithParentTypeParams.java") + public void testConstructorWithParentTypeParams() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/ConstructorWithParentTypeParams.java"); + } + + @TestMetadata("ConstructorWithSeveralParams.java") + public void testConstructorWithSeveralParams() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/ConstructorWithSeveralParams.java"); + } + + @TestMetadata("ConstructorWithoutParams.java") + public void testConstructorWithoutParams() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/ConstructorWithoutParams.java"); + } + + @TestMetadata("CustomProjectionKind.java") + public void testCustomProjectionKind() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/CustomProjectionKind.java"); + } + + @TestMetadata("MethodWithFunctionTypes.java") + public void testMethodWithFunctionTypes() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithFunctionTypes.java"); + } + + @TestMetadata("MethodWithGenerics.java") + public void testMethodWithGenerics() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithGenerics.java"); + } + + @TestMetadata("MethodWithMappedClasses.java") + public void testMethodWithMappedClasses() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithMappedClasses.java"); + } + + @TestMetadata("MethodWithTypeParameters.java") + public void testMethodWithTypeParameters() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithTypeParameters.java"); + } + + @TestMetadata("MethodWithVararg.java") + public void testMethodWithVararg() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithVararg.java"); + } + + @TestMetadata("PropertyArrayTypes.java") + public void testPropertyArrayTypes() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/PropertyArrayTypes.java"); + } + + @TestMetadata("PropertyComplexTypes.java") + public void testPropertyComplexTypes() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/PropertyComplexTypes.java"); + } + + @TestMetadata("PropertySimpleType.java") + public void testPropertySimpleType() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/PropertySimpleType.java"); + } + + @TestMetadata("StarProjection.java") + public void testStarProjection() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/StarProjection.java"); + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/error") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Error extends AbstractFirTypeEnhancementTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); + } + + public void testAllFilesPresentInError() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/error"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true); + } + + @TestMetadata("WrongProjectionKind.java") + public void testWrongProjectionKind() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/error/WrongProjectionKind.java"); + } + + @TestMetadata("WrongReturnTypeStructure.java") + public void testWrongReturnTypeStructure() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/error/WrongReturnTypeStructure.java"); + } + + @TestMetadata("WrongTypeParameterBoundStructure1.java") + public void testWrongTypeParameterBoundStructure1() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/error/WrongTypeParameterBoundStructure1.java"); + } + + @TestMetadata("WrongValueParameterStructure1.java") + public void testWrongValueParameterStructure1() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/error/WrongValueParameterStructure1.java"); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Propagation extends AbstractFirTypeEnhancementTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); + } + + public void testAllFilesPresentInPropagation() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true); + } + + @TestMetadata("PropagateTypeArgumentNullable.java") + public void testPropagateTypeArgumentNullable() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/PropagateTypeArgumentNullable.java"); + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Parameter extends AbstractFirTypeEnhancementTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); + } + + public void testAllFilesPresentInParameter() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true); + } + + @TestMetadata("ChangeProjectionKind1.java") + public void testChangeProjectionKind1() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/ChangeProjectionKind1.java"); + } + + @TestMetadata("DeeplySubstitutedClassParameter.java") + public void testDeeplySubstitutedClassParameter() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.java"); + } + + @TestMetadata("DeeplySubstitutedClassParameter2.java") + public void testDeeplySubstitutedClassParameter2() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.java"); + } + + @TestMetadata("InheritNotVararg.java") + public void testInheritNotVararg() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNotVararg.java"); + } + + @TestMetadata("InheritNotVarargInteger.java") + public void testInheritNotVarargInteger() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNotVarargInteger.java"); + } + + @TestMetadata("InheritNotVarargNotNull.java") + public void testInheritNotVarargNotNull() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.java"); + } + + @TestMetadata("InheritNotVarargPrimitive.java") + public void testInheritNotVarargPrimitive() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNotVarargPrimitive.java"); + } + + @TestMetadata("InheritNullability.java") + public void testInheritNullability() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNullability.java"); + } + + @TestMetadata("InheritVararg.java") + public void testInheritVararg() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritVararg.java"); + } + + @TestMetadata("InheritVarargInteger.java") + public void testInheritVarargInteger() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritVarargInteger.java"); + } + + @TestMetadata("InheritVarargNotNull.java") + public void testInheritVarargNotNull() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritVarargNotNull.java"); + } + + @TestMetadata("InheritVarargPrimitive.java") + public void testInheritVarargPrimitive() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritVarargPrimitive.java"); + } + + @TestMetadata("Kt3302.java") + public void testKt3302() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/Kt3302.java"); + } + + @TestMetadata("MutableToReadOnly.java") + public void testMutableToReadOnly() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/MutableToReadOnly.java"); + } + + @TestMetadata("NotNullToNullable.java") + public void testNotNullToNullable() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/NotNullToNullable.java"); + } + + @TestMetadata("NullableToNotNull.java") + public void testNullableToNotNull() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/NullableToNotNull.java"); + } + + @TestMetadata("NullableToNotNullKotlinSignature.java") + public void testNullableToNotNullKotlinSignature() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/NullableToNotNullKotlinSignature.java"); + } + + @TestMetadata("OverrideWithErasedParameter.java") + public void testOverrideWithErasedParameter() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/OverrideWithErasedParameter.java"); + } + + @TestMetadata("ReadOnlyToMutable.java") + public void testReadOnlyToMutable() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/ReadOnlyToMutable.java"); + } + + @TestMetadata("SubclassFromGenericAndNot.java") + public void testSubclassFromGenericAndNot() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.java"); + } + + @TestMetadata("SubstitutedClassParameter.java") + public void testSubstitutedClassParameter() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/SubstitutedClassParameter.java"); + } + + @TestMetadata("SubstitutedClassParameters.java") + public void testSubstitutedClassParameters() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/SubstitutedClassParameters.java"); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Return extends AbstractFirTypeEnhancementTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); + } + + @TestMetadata("AddNotNullJavaSubtype.java") + public void testAddNotNullJavaSubtype() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNotNullJavaSubtype.java"); + } + + @TestMetadata("AddNotNullSameJavaType.java") + public void testAddNotNullSameJavaType() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNotNullSameJavaType.java"); + } + + @TestMetadata("AddNullabilityJavaSubtype.java") + public void testAddNullabilityJavaSubtype() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.java"); + } + + @TestMetadata("AddNullabilitySameGenericType1.java") + public void testAddNullabilitySameGenericType1() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNullabilitySameGenericType1.java"); + } + + @TestMetadata("AddNullabilitySameGenericType2.java") + public void testAddNullabilitySameGenericType2() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNullabilitySameGenericType2.java"); + } + + @TestMetadata("AddNullabilitySameJavaType.java") + public void testAddNullabilitySameJavaType() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNullabilitySameJavaType.java"); + } + + public void testAllFilesPresentInReturn() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true); + } + + @TestMetadata("CantMakeImmutableInSubclass.java") + public void testCantMakeImmutableInSubclass() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/CantMakeImmutableInSubclass.java"); + } + + @TestMetadata("DeeplySubstitutedClassParameter.java") + public void testDeeplySubstitutedClassParameter() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.java"); + } + + @TestMetadata("DeeplySubstitutedClassParameter2.java") + public void testDeeplySubstitutedClassParameter2() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter2.java"); + } + + @TestMetadata("HalfSubstitutedTypeParameters.java") + public void testHalfSubstitutedTypeParameters() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.java"); + } + + @TestMetadata("InheritNullabilityGenericSubclassSimple.java") + public void testInheritNullabilityGenericSubclassSimple() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritNullabilityGenericSubclassSimple.java"); + } + + @TestMetadata("InheritNullabilityJavaSubtype.java") + public void testInheritNullabilityJavaSubtype() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.java"); + } + + @TestMetadata("InheritNullabilitySameGenericType.java") + public void testInheritNullabilitySameGenericType() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritNullabilitySameGenericType.java"); + } + + @TestMetadata("InheritNullabilitySameJavaType.java") + public void testInheritNullabilitySameJavaType() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.java"); + } + + @TestMetadata("InheritProjectionKind.java") + public void testInheritProjectionKind() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritProjectionKind.java"); + } + + @TestMetadata("InheritReadOnlinessOfArgument.java") + public void testInheritReadOnlinessOfArgument() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritReadOnlinessOfArgument.java"); + } + + @TestMetadata("InheritReadOnlinessSameClass.java") + public void testInheritReadOnlinessSameClass() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritReadOnlinessSameClass.java"); + } + + @TestMetadata("InheritReadOnlinessSubclass.java") + public void testInheritReadOnlinessSubclass() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritReadOnlinessSubclass.java"); + } + + @TestMetadata("SameProjectionKind.java") + public void testSameProjectionKind() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SameProjectionKind.java"); + } + + @TestMetadata("SubclassFromGenericAndNot.java") + public void testSubclassFromGenericAndNot() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubclassFromGenericAndNot.java"); + } + + @TestMetadata("SubclassOfCollection.java") + public void testSubclassOfCollection() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubclassOfCollection.java"); + } + + @TestMetadata("SubclassOfMapEntry.java") + public void testSubclassOfMapEntry() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubclassOfMapEntry.java"); + } + + @TestMetadata("SubstitutedClassParameter.java") + public void testSubstitutedClassParameter() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubstitutedClassParameter.java"); + } + + @TestMetadata("SubstitutedClassParameters.java") + public void testSubstitutedClassParameters() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubstitutedClassParameters.java"); + } + + @TestMetadata("TwoSuperclassesConflictingProjectionKinds.java") + public void testTwoSuperclassesConflictingProjectionKinds() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.java"); + } + + @TestMetadata("TwoSuperclassesInvariantAndCovariantInferMutability.java") + public void testTwoSuperclassesInvariantAndCovariantInferMutability() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferMutability.java"); + } + + @TestMetadata("TwoSuperclassesInvariantAndCovariantInferNullability.java") + public void testTwoSuperclassesInvariantAndCovariantInferNullability() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferNullability.java"); + } + + @TestMetadata("TwoSuperclassesMutableAndNot.java") + public void testTwoSuperclassesMutableAndNot() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesMutableAndNot.java"); + } + + @TestMetadata("TwoSuperclassesReturnJavaSubtype.java") + public void testTwoSuperclassesReturnJavaSubtype() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesReturnJavaSubtype.java"); + } + + @TestMetadata("TwoSuperclassesReturnSameJavaType.java") + public void testTwoSuperclassesReturnSameJavaType() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesReturnSameJavaType.java"); + } + + @TestMetadata("TwoSuperclassesSupplementNotNull.java") + public void testTwoSuperclassesSupplementNotNull() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesSupplementNotNull.java"); + } + + @TestMetadata("TypeParamOfClass.java") + public void testTypeParamOfClass() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfClass.java"); + } + + @TestMetadata("TypeParamOfClassSubstituted.java") + public void testTypeParamOfClassSubstituted() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.java"); + } + + @TestMetadata("TypeParamOfFun.java") + public void testTypeParamOfFun() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfFun.java"); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TypeParameter extends AbstractFirTypeEnhancementTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); + } + + public void testAllFilesPresentInTypeParameter() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true); + } + + @TestMetadata("InheritNullability.java") + public void testInheritNullability() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/InheritNullability.java"); + } + + @TestMetadata("TwoBounds.java") + public void testTwoBounds() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/TwoBounds.java"); + } + + @TestMetadata("TwoSuperclasses.java") + public void testTwoSuperclasses() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/TwoSuperclasses.java"); + } + + @TestMetadata("TwoTypeParameters.java") + public void testTwoTypeParameters() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/TwoTypeParameters.java"); + } + + @TestMetadata("UseParameterAsUpperBound.java") + public void testUseParameterAsUpperBound() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/UseParameterAsUpperBound.java"); + } + + @TestMetadata("UseParameterInUpperBound.java") + public void testUseParameterInUpperBound() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/UseParameterInUpperBound.java"); + } + + @TestMetadata("UseParameterInUpperBoundWithKotlinSignature.java") + public void testUseParameterInUpperBoundWithKotlinSignature() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/UseParameterInUpperBoundWithKotlinSignature.java"); + } + } + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/library") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Library extends AbstractFirTypeEnhancementTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); + } + + public void testAllFilesPresentInLibrary() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledJava/library"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true); + } + + @TestMetadata("LoadIterable.java") + public void testLoadIterable() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/library/LoadIterable.java"); + } + + @TestMetadata("LoadIterator.java") + public void testLoadIterator() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/library/LoadIterator.java"); + } + + @TestMetadata("Max.java") + public void testMax() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/library/Max.java"); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/modality") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Modality extends AbstractFirTypeEnhancementTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); + } + + public void testAllFilesPresentInModality() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledJava/modality"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true); + } + + @TestMetadata("ModalityOfFakeOverrides.java") + public void testModalityOfFakeOverrides() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/modality/ModalityOfFakeOverrides.java"); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/mutability") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Mutability extends AbstractFirTypeEnhancementTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); + } + + public void testAllFilesPresentInMutability() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledJava/mutability"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true); + } + + @TestMetadata("LoadIterable.java") + public void testLoadIterable() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/mutability/LoadIterable.java"); + } + + @TestMetadata("LoadIterableWithConflict.java") + public void testLoadIterableWithConflict() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/mutability/LoadIterableWithConflict.java"); + } + + @TestMetadata("LoadIterableWithNullability.java") + public void testLoadIterableWithNullability() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/mutability/LoadIterableWithNullability.java"); + } + + @TestMetadata("LoadIterableWithPropagation.java") + public void testLoadIterableWithPropagation() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/mutability/LoadIterableWithPropagation.java"); + } + + @TestMetadata("ReadOnlyExtendsWildcard.java") + public void testReadOnlyExtendsWildcard() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/mutability/ReadOnlyExtendsWildcard.java"); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/notNull") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class NotNull extends AbstractFirTypeEnhancementTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); + } + + public void testAllFilesPresentInNotNull() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledJava/notNull"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true); + } + + @TestMetadata("NotNullField.java") + public void testNotNullField() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/notNull/NotNullField.java"); + } + + @TestMetadata("NotNullIntArray.java") + public void testNotNullIntArray() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/notNull/NotNullIntArray.java"); + } + + @TestMetadata("NotNullMethod.java") + public void testNotNullMethod() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/notNull/NotNullMethod.java"); + } + + @TestMetadata("NotNullObjectArray.java") + public void testNotNullObjectArray() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/notNull/NotNullObjectArray.java"); + } + + @TestMetadata("NotNullParameter.java") + public void testNotNullParameter() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/notNull/NotNullParameter.java"); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/protectedPackage") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ProtectedPackage extends AbstractFirTypeEnhancementTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); + } + + public void testAllFilesPresentInProtectedPackage() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledJava/protectedPackage"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true); + } + + @TestMetadata("ProtectedPackageConstructor.java") + public void testProtectedPackageConstructor() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/protectedPackage/ProtectedPackageConstructor.java"); + } + + @TestMetadata("ProtectedPackageFun.java") + public void testProtectedPackageFun() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/protectedPackage/ProtectedPackageFun.java"); + } + + @TestMetadata("ProtectedPackageProperty.java") + public void testProtectedPackageProperty() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/protectedPackage/ProtectedPackageProperty.java"); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/protectedStatic") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ProtectedStatic extends AbstractFirTypeEnhancementTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); + } + + public void testAllFilesPresentInProtectedStatic() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledJava/protectedStatic"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true); + } + + @TestMetadata("ConstructorInProtectedStaticNestedClass.java") + public void testConstructorInProtectedStaticNestedClass() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/protectedStatic/ConstructorInProtectedStaticNestedClass.java"); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/rendering") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Rendering extends AbstractFirTypeEnhancementTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); + } + + public void testAllFilesPresentInRendering() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledJava/rendering"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true); + } + + @TestMetadata("Rendering.java") + public void testRendering() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/rendering/Rendering.java"); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/sam") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Sam extends AbstractFirTypeEnhancementTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); + } + + public void testAllFilesPresentInSam() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledJava/sam"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true); + } + + @TestMetadata("Comparator.java") + public void testComparator() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/Comparator.java"); + } + + @TestMetadata("DifferentParametersCount.java") + public void testDifferentParametersCount() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/DifferentParametersCount.java"); + } + + @TestMetadata("FakeStaticOverrides.java") + public void testFakeStaticOverrides() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/FakeStaticOverrides.java"); + } + + @TestMetadata("FilenameFilter.java") + public void testFilenameFilter() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/FilenameFilter.java"); + } + + @TestMetadata("GenericInterfaceParameterWithSelfBound.java") + public void testGenericInterfaceParameterWithSelfBound() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/GenericInterfaceParameterWithSelfBound.java"); + } + + @TestMetadata("GenericInterfaceParametersWithBounds.java") + public void testGenericInterfaceParametersWithBounds() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/GenericInterfaceParametersWithBounds.java"); + } + + @TestMetadata("GenericMethodParameters.java") + public void testGenericMethodParameters() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/GenericMethodParameters.java"); + } + + @TestMetadata("InterfaceWithObjectMethod.java") + public void testInterfaceWithObjectMethod() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/InterfaceWithObjectMethod.java"); + } + + @TestMetadata("Nested.java") + public void testNested() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/Nested.java"); + } + + @TestMetadata("Runnable.java") + public void testRunnable() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/Runnable.java"); + } + + @TestMetadata("SamSubinterfaceOfTwo.java") + public void testSamSubinterfaceOfTwo() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/SamSubinterfaceOfTwo.java"); + } + + @TestMetadata("SamSubinterfaceOverridding.java") + public void testSamSubinterfaceOverridding() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/SamSubinterfaceOverridding.java"); + } + + @TestMetadata("StaticOverrides.java") + public void testStaticOverrides() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/StaticOverrides.java"); + } + + @TestMetadata("SubstitutedSamInterface.java") + public void testSubstitutedSamInterface() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/SubstitutedSamInterface.java"); + } + + @TestMetadata("SubstitutedSamInterfaceSubclassOfBuiltin.java") + public void testSubstitutedSamInterfaceSubclassOfBuiltin() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/SubstitutedSamInterfaceSubclassOfBuiltin.java"); + } + + @TestMetadata("VarargParameter.java") + public void testVarargParameter() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/VarargParameter.java"); + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/sam/adapters") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Adapters extends AbstractFirTypeEnhancementTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); + } + + public void testAllFilesPresentInAdapters() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledJava/sam/adapters"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true); + } + + @TestMetadata("AmbiguousAdapters.java") + public void testAmbiguousAdapters() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/adapters/AmbiguousAdapters.java"); + } + + @TestMetadata("Basic.java") + public void testBasic() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/adapters/Basic.java"); + } + + @TestMetadata("Constructor.java") + public void testConstructor() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/adapters/Constructor.java"); + } + + @TestMetadata("ConstructorWithAnnotations.java") + public void testConstructorWithAnnotations() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/adapters/ConstructorWithAnnotations.java"); + } + + @TestMetadata("DeepSamLoop.java") + public void testDeepSamLoop() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/adapters/DeepSamLoop.java"); + } + + @TestMetadata("NoSamForClassTypeParameter.java") + public void testNoSamForClassTypeParameter() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/adapters/NoSamForClassTypeParameter.java"); + } + + @TestMetadata("NoSamForMethodTypeParameter.java") + public void testNoSamForMethodTypeParameter() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/adapters/NoSamForMethodTypeParameter.java"); + } + + @TestMetadata("NonTrivialFunctionType.java") + public void testNonTrivialFunctionType() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/adapters/NonTrivialFunctionType.java"); + } + + @TestMetadata("PrivateSamAdapter.java") + public void testPrivateSamAdapter() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/adapters/PrivateSamAdapter.java"); + } + + @TestMetadata("SelfAsParameter.java") + public void testSelfAsParameter() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/adapters/SelfAsParameter.java"); + } + + @TestMetadata("SeveralSamParameters.java") + public void testSeveralSamParameters() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/adapters/SeveralSamParameters.java"); + } + + @TestMetadata("TypeParameterOfClass.java") + public void testTypeParameterOfClass() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/adapters/TypeParameterOfClass.java"); + } + + @TestMetadata("TypeParameterOfMethod.java") + public void testTypeParameterOfMethod() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/adapters/TypeParameterOfMethod.java"); + } + + @TestMetadata("TypeParameterOfOuterClass.java") + public void testTypeParameterOfOuterClass() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/adapters/TypeParameterOfOuterClass.java"); + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/sam/adapters/inheritance") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Inheritance extends AbstractFirTypeEnhancementTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); + } + + @TestMetadata("AdapterDoesntOverrideDeclaration.java") + public void testAdapterDoesntOverrideDeclaration() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/AdapterDoesntOverrideDeclaration.java"); + } + + public void testAllFilesPresentInInheritance() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledJava/sam/adapters/inheritance"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true); + } + + @TestMetadata("InheritedAdapterAndDeclaration.java") + public void testInheritedAdapterAndDeclaration() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedAdapterAndDeclaration.java"); + } + + @TestMetadata("InheritedAmbiguousAdapters.java") + public void testInheritedAmbiguousAdapters() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedAmbiguousAdapters.java"); + } + + @TestMetadata("InheritedAndOverriddenAmbiguousAdapters.java") + public void testInheritedAndOverriddenAmbiguousAdapters() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedAndOverriddenAmbiguousAdapters.java"); + } + + @TestMetadata("InheritedOverridden.java") + public void testInheritedOverridden() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedOverridden.java"); + } + + @TestMetadata("InheritedOverriddenAdapter.java") + public void testInheritedOverriddenAdapter() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedOverriddenAdapter.java"); + } + + @TestMetadata("InheritedSameAdapters.java") + public void testInheritedSameAdapters() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedSameAdapters.java"); + } + + @TestMetadata("InheritedSameAdaptersWithSubstitution.java") + public void testInheritedSameAdaptersWithSubstitution() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedSameAdaptersWithSubstitution.java"); + } + + @TestMetadata("InheritedSimple.java") + public void testInheritedSimple() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedSimple.java"); + } + + @TestMetadata("OverriddenAmbiguousAdapters.java") + public void testOverriddenAmbiguousAdapters() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/OverriddenAmbiguousAdapters.java"); + } + } + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/signatureAnnotations") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class SignatureAnnotations extends AbstractFirTypeEnhancementTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); + } + + public void testAllFilesPresentInSignatureAnnotations() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledJava/signatureAnnotations"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true); + } + + @TestMetadata("StableName.java") + public void testStableName() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/signatureAnnotations/StableName.java"); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/signaturePropagation") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class SignaturePropagation extends AbstractFirTypeEnhancementTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); + } + + public void testAllFilesPresentInSignaturePropagation() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledJava/signaturePropagation"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true); + } + + @TestMetadata("ArraysInSubtypes.java") + public void testArraysInSubtypes() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/signaturePropagation/ArraysInSubtypes.java"); + } + + @TestMetadata("MethodTypeParameterErased.java") + public void testMethodTypeParameterErased() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/signaturePropagation/MethodTypeParameterErased.java"); + } + + @TestMetadata("RawSuperType.java") + public void testRawSuperType() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/signaturePropagation/RawSuperType.java"); + } + + @TestMetadata("RawSuperTypeWithBound.java") + public void testRawSuperTypeWithBound() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/signaturePropagation/RawSuperTypeWithBound.java"); + } + + @TestMetadata("RawSuperTypeWithRecursiveBound.java") + public void testRawSuperTypeWithRecursiveBound() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/signaturePropagation/RawSuperTypeWithRecursiveBound.java"); + } + + @TestMetadata("RawSuperTypeWithRecursiveBoundMultipleParameters.java") + public void testRawSuperTypeWithRecursiveBoundMultipleParameters() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/signaturePropagation/RawSuperTypeWithRecursiveBoundMultipleParameters.java"); + } + + @TestMetadata("ReturnInnerSubclassOfSupersInner.java") + public void testReturnInnerSubclassOfSupersInner() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/signaturePropagation/ReturnInnerSubclassOfSupersInner.java"); + } + + @TestMetadata("SubclassWithRawType.java") + public void testSubclassWithRawType() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/signaturePropagation/SubclassWithRawType.java"); + } + + @TestMetadata("TwoSuperclassesInconsistentGenericTypes.java") + public void testTwoSuperclassesInconsistentGenericTypes() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/signaturePropagation/TwoSuperclassesInconsistentGenericTypes.java"); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/static") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Static extends AbstractFirTypeEnhancementTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); + } + + public void testAllFilesPresentInStatic() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledJava/static"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true); + } + + @TestMetadata("DeeplyInnerClass.java") + public void testDeeplyInnerClass() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/static/DeeplyInnerClass.java"); + } + + @TestMetadata("DeeplyNestedStatic.java") + public void testDeeplyNestedStatic() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/static/DeeplyNestedStatic.java"); + } + + @TestMetadata("Enum.java") + public void testEnum() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/static/Enum.java"); + } + + @TestMetadata("InnerClass.java") + public void testInnerClass() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/static/InnerClass.java"); + } + + @TestMetadata("Simple.java") + public void testSimple() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/static/Simple.java"); + } + + @TestMetadata("StaticFinal.java") + public void testStaticFinal() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/static/StaticFinal.java"); + } + + @TestMetadata("StaticMembersFromParentClass.java") + public void testStaticMembersFromParentClass() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentClass.java"); + } + + @TestMetadata("StaticMembersFromParentClassVisibility.java") + public void testStaticMembersFromParentClassVisibility() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentClassVisibility.java"); + } + + @TestMetadata("StaticMembersFromParentInterface.java") + public void testStaticMembersFromParentInterface() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentInterface.java"); + } + + @TestMetadata("StaticMembersInEnum.java") + public void testStaticMembersInEnum() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/static/StaticMembersInEnum.java"); + } + + @TestMetadata("StaticMembersInEnumFromParents.java") + public void testStaticMembersInEnumFromParents() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/static/StaticMembersInEnumFromParents.java"); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/vararg") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Vararg extends AbstractFirTypeEnhancementTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); + } + + public void testAllFilesPresentInVararg() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledJava/vararg"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true); + } + + @TestMetadata("VarargInt.java") + public void testVarargInt() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/vararg/VarargInt.java"); + } + + @TestMetadata("VarargString.java") + public void testVarargString() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/vararg/VarargString.java"); + } + } +} diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirAnnotationCall.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirAnnotationCall.kt index 501d76df122..f1d1ca9ffbb 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirAnnotationCall.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirAnnotationCall.kt @@ -10,6 +10,7 @@ import org.jetbrains.kotlin.fir.BaseTransformedType import org.jetbrains.kotlin.fir.types.ConeClassLikeType import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef import org.jetbrains.kotlin.fir.types.FirTypeRef +import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.name.FqName @@ -29,5 +30,8 @@ interface FirAnnotationCall : FirCall { } } +val FirAnnotationCall.coneClassLikeType: ConeClassLikeType? + get() = ((annotationTypeRef as? FirResolvedTypeRef)?.type as? ConeClassLikeType)?.takeIf { it !is ConeClassErrorType } + val FirAnnotationCall.resolvedFqName: FqName? - get() = ((annotationTypeRef as? FirResolvedTypeRef)?.type as? ConeClassLikeType)?.lookupTag?.classId?.asSingleFqName() + get() = coneClassLikeType?.lookupTag?.classId?.asSingleFqName() diff --git a/compiler/testData/loadJava/compiledJava/ArrayTypeVariance.fir.txt b/compiler/testData/loadJava/compiledJava/ArrayTypeVariance.fir.txt new file mode 100644 index 00000000000..3f06f2fa02b --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/ArrayTypeVariance.fir.txt @@ -0,0 +1,4 @@ +public final class ArrayTypeVariance : R|java/lang/Object| { + public final operator function toArray(p0: R|kotlin/Array>|): R|kotlin/Array>| + +} diff --git a/compiler/testData/loadJava/compiledJava/ClassDoesNotOverrideMethod.fir.txt b/compiler/testData/loadJava/compiledJava/ClassDoesNotOverrideMethod.fir.txt new file mode 100644 index 00000000000..1c7b9159206 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/ClassDoesNotOverrideMethod.fir.txt @@ -0,0 +1,2 @@ +public abstract class ClassDoesNotOverrideMethod : R|java/util/Date| { +} diff --git a/compiler/testData/loadJava/compiledJava/ClassWithConstVal.fir.txt b/compiler/testData/loadJava/compiledJava/ClassWithConstVal.fir.txt new file mode 100644 index 00000000000..790395d8722 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/ClassWithConstVal.fir.txt @@ -0,0 +1,2 @@ +public final class ClassWithConstVal : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/ClassWithTypeP.fir.txt b/compiler/testData/loadJava/compiledJava/ClassWithTypeP.fir.txt new file mode 100644 index 00000000000..3171021c35a --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/ClassWithTypeP.fir.txt @@ -0,0 +1,2 @@ +

public final class ClassWithTypeP : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/ClassWithTypePExtendsIterableP.fir.txt b/compiler/testData/loadJava/compiledJava/ClassWithTypePExtendsIterableP.fir.txt new file mode 100644 index 00000000000..e878149c17d --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/ClassWithTypePExtendsIterableP.fir.txt @@ -0,0 +1,2 @@ +

public abstract class ClassWithTypePExtendsIterableP : R|java/lang/Object|, R|java/lang/Iterable

| { +} diff --git a/compiler/testData/loadJava/compiledJava/ClassWithTypePP.fir.txt b/compiler/testData/loadJava/compiledJava/ClassWithTypePP.fir.txt new file mode 100644 index 00000000000..edd7a9f00e8 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/ClassWithTypePP.fir.txt @@ -0,0 +1,2 @@ + public final class ClassWithTypePP : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/ClassWithTypePRefNext.fir.txt b/compiler/testData/loadJava/compiledJava/ClassWithTypePRefNext.fir.txt new file mode 100644 index 00000000000..c526d069162 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/ClassWithTypePRefNext.fir.txt @@ -0,0 +1,2 @@ + public open class ClassWithTypePRefNext : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/ClassWithTypePRefSelf.fir.txt b/compiler/testData/loadJava/compiledJava/ClassWithTypePRefSelf.fir.txt new file mode 100644 index 00000000000..c8bd95e58a1 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/ClassWithTypePRefSelf.fir.txt @@ -0,0 +1,2 @@ +

public final class ClassWithTypePRefSelf : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/ClassWithTypePRefSelfAndClass.fir.txt b/compiler/testData/loadJava/compiledJava/ClassWithTypePRefSelfAndClass.fir.txt new file mode 100644 index 00000000000..59e80869126 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/ClassWithTypePRefSelfAndClass.fir.txt @@ -0,0 +1,2 @@ +

public final class ClassWithTypePRefSelfAndClass : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/FieldAsVar.fir.txt b/compiler/testData/loadJava/compiledJava/FieldAsVar.fir.txt new file mode 100644 index 00000000000..340f2cc2890 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/FieldAsVar.fir.txt @@ -0,0 +1,2 @@ +public final class FieldAsVar : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/FieldOfArrayType.fir.txt b/compiler/testData/loadJava/compiledJava/FieldOfArrayType.fir.txt new file mode 100644 index 00000000000..fc4089be651 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/FieldOfArrayType.fir.txt @@ -0,0 +1,2 @@ +public open class FieldOfArrayType : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/FinalFieldAsVal.fir.txt b/compiler/testData/loadJava/compiledJava/FinalFieldAsVal.fir.txt new file mode 100644 index 00000000000..374e4b0622b --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/FinalFieldAsVal.fir.txt @@ -0,0 +1,2 @@ +public final class FinalFieldAsVal : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/InheritMethodsDifferentReturnTypes.fir.txt b/compiler/testData/loadJava/compiledJava/InheritMethodsDifferentReturnTypes.fir.txt new file mode 100644 index 00000000000..5d6a5c4b6a5 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/InheritMethodsDifferentReturnTypes.fir.txt @@ -0,0 +1,2 @@ +public final class InheritMethodsDifferentReturnTypes : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/InheritMethodsDifferentReturnTypesGeneric.fir.txt b/compiler/testData/loadJava/compiledJava/InheritMethodsDifferentReturnTypesGeneric.fir.txt new file mode 100644 index 00000000000..d69a6a6bd43 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/InheritMethodsDifferentReturnTypesGeneric.fir.txt @@ -0,0 +1,2 @@ +public final class InheritMethodsDifferentReturnTypesGeneric : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/InnerClass.fir.txt b/compiler/testData/loadJava/compiledJava/InnerClass.fir.txt new file mode 100644 index 00000000000..7d2dfb582a1 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/InnerClass.fir.txt @@ -0,0 +1,2 @@ +public open class InnerClass : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/InnerClassReferencesOuterTP.fir.txt b/compiler/testData/loadJava/compiledJava/InnerClassReferencesOuterTP.fir.txt new file mode 100644 index 00000000000..78012eccfc5 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/InnerClassReferencesOuterTP.fir.txt @@ -0,0 +1,2 @@ +

public open class InnerClassReferencesOuterTP : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/InnerClassTypeMultipleGeneric.fir.txt b/compiler/testData/loadJava/compiledJava/InnerClassTypeMultipleGeneric.fir.txt new file mode 100644 index 00000000000..c25a07539a9 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/InnerClassTypeMultipleGeneric.fir.txt @@ -0,0 +1,4 @@ +public open class InnerClassTypeMultipleGeneric : R|java/lang/Object| { + public open operator function staticType(): R|ft, ft, ft>, test/InnerClassTypeMultipleGeneric.Outer.Inner, ft, ft>>| + +} diff --git a/compiler/testData/loadJava/compiledJava/InnerClassesInGeneric.fir.txt b/compiler/testData/loadJava/compiledJava/InnerClassesInGeneric.fir.txt new file mode 100644 index 00000000000..439d1b163c7 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/InnerClassesInGeneric.fir.txt @@ -0,0 +1,2 @@ + public open class InnerClassesInGeneric : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/InnerOfGeneric.fir.txt b/compiler/testData/loadJava/compiledJava/InnerOfGeneric.fir.txt new file mode 100644 index 00000000000..5719f21fc33 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/InnerOfGeneric.fir.txt @@ -0,0 +1,2 @@ +public open class InnerOfGeneric : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/IntrinsicCompanionObject.fir.txt b/compiler/testData/loadJava/compiledJava/IntrinsicCompanionObject.fir.txt new file mode 100644 index 00000000000..b6c77a6b461 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/IntrinsicCompanionObject.fir.txt @@ -0,0 +1,12 @@ +public abstract interface IntrinsicCompanionObject : R|java/lang/Object| { + public abstract operator function testInt(i: R|ft|!): R|kotlin/Unit| + + public abstract operator function testChar(c: R|ft|!): R|kotlin/Unit| + + public abstract operator function testString(s: R|ft|!): R|kotlin/Unit| + + public abstract operator function testBoolean(b: R|ft|!): R|kotlin/Unit| + + public abstract operator function testEnum(e: R|ft|!): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/MethodReferencesOuterClassTP.fir.txt b/compiler/testData/loadJava/compiledJava/MethodReferencesOuterClassTP.fir.txt new file mode 100644 index 00000000000..1b738afef6f --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/MethodReferencesOuterClassTP.fir.txt @@ -0,0 +1,2 @@ +

public final class MethodReferencesOuterClassTP : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/MethodTypePOneUpperBound.fir.txt b/compiler/testData/loadJava/compiledJava/MethodTypePOneUpperBound.fir.txt new file mode 100644 index 00000000000..87503c41478 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/MethodTypePOneUpperBound.fir.txt @@ -0,0 +1,4 @@ +public open class MethodTypePOneUpperBound : R|java/lang/Object| { + public open operator function bar(): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/MethodTypePTwoUpperBounds.fir.txt b/compiler/testData/loadJava/compiledJava/MethodTypePTwoUpperBounds.fir.txt new file mode 100644 index 00000000000..cd9910853ba --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/MethodTypePTwoUpperBounds.fir.txt @@ -0,0 +1,4 @@ +public open class MethodTypePTwoUpperBounds : R|java/lang/Object| { + public open operator function foo(): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/MethodWithTypeP.fir.txt b/compiler/testData/loadJava/compiledJava/MethodWithTypeP.fir.txt new file mode 100644 index 00000000000..afd3b43199a --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/MethodWithTypeP.fir.txt @@ -0,0 +1,4 @@ +public final class MethodWithTypeP : R|java/lang/Object| { + public final operator function f(): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/MethodWithTypePP.fir.txt b/compiler/testData/loadJava/compiledJava/MethodWithTypePP.fir.txt new file mode 100644 index 00000000000..c16b163c520 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/MethodWithTypePP.fir.txt @@ -0,0 +1,4 @@ +public final class MethodWithTypePP : R|java/lang/Object| { + public final operator function f(): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/MethodWithTypePRefClassP.fir.txt b/compiler/testData/loadJava/compiledJava/MethodWithTypePRefClassP.fir.txt new file mode 100644 index 00000000000..76dabbab430 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/MethodWithTypePRefClassP.fir.txt @@ -0,0 +1,4 @@ +

public open class MethodWithTypePRefClassP : R|java/lang/Object| { + public final operator function f(): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/MethosWithPRefTP.fir.txt b/compiler/testData/loadJava/compiledJava/MethosWithPRefTP.fir.txt new file mode 100644 index 00000000000..617d5f92a6f --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/MethosWithPRefTP.fir.txt @@ -0,0 +1,4 @@ +public final class MethosWithPRefTP : R|java/lang/Object| { + public final operator function f(p: R|ft|!): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/MyException.fir.txt b/compiler/testData/loadJava/compiledJava/MyException.fir.txt new file mode 100644 index 00000000000..1965f9bfacf --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/MyException.fir.txt @@ -0,0 +1,2 @@ +public open class MyException : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/NestedClass.fir.txt b/compiler/testData/loadJava/compiledJava/NestedClass.fir.txt new file mode 100644 index 00000000000..020c6332aac --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/NestedClass.fir.txt @@ -0,0 +1,2 @@ +public open class NestedClass : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/OverrideMethod.fir.txt b/compiler/testData/loadJava/compiledJava/OverrideMethod.fir.txt new file mode 100644 index 00000000000..44b4d9a9628 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/OverrideMethod.fir.txt @@ -0,0 +1,2 @@ +public open class OverrideMethod : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/PackageLocalVisibility.fir.txt b/compiler/testData/loadJava/compiledJava/PackageLocalVisibility.fir.txt new file mode 100644 index 00000000000..f2b22f93100 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/PackageLocalVisibility.fir.txt @@ -0,0 +1,4 @@ +public open class Frame : R|java/lang/Object| { +} +public open class JFrame : R|awt/Frame| { +} diff --git a/compiler/testData/loadJava/compiledJava/PrivateMembers.fir.txt b/compiler/testData/loadJava/compiledJava/PrivateMembers.fir.txt new file mode 100644 index 00000000000..5e28efc0963 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/PrivateMembers.fir.txt @@ -0,0 +1,4 @@ +public open class PrivateMembers : R|java/lang/Object| { + private open operator function method(): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/PrivateMembersInHierarchy.fir.txt b/compiler/testData/loadJava/compiledJava/PrivateMembersInHierarchy.fir.txt new file mode 100644 index 00000000000..8fee6313542 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/PrivateMembersInHierarchy.fir.txt @@ -0,0 +1,2 @@ +public open class PrivateMembersInHierarchy : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/RawOverrides.fir.txt b/compiler/testData/loadJava/compiledJava/RawOverrides.fir.txt new file mode 100644 index 00000000000..559b3273ab6 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/RawOverrides.fir.txt @@ -0,0 +1,2 @@ +public open class RawOverrides : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/RawTypeWithUpperBound.fir.txt b/compiler/testData/loadJava/compiledJava/RawTypeWithUpperBound.fir.txt new file mode 100644 index 00000000000..5dca77fcd4c --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/RawTypeWithUpperBound.fir.txt @@ -0,0 +1,2 @@ +public abstract interface RawTypeWithUpperBound : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/RawUpperBound.fir.txt b/compiler/testData/loadJava/compiledJava/RawUpperBound.fir.txt new file mode 100644 index 00000000000..bc64885cc4d --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/RawUpperBound.fir.txt @@ -0,0 +1,2 @@ + public abstract interface RawUpperBound : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/RecursiveRawUpperBound.fir.txt b/compiler/testData/loadJava/compiledJava/RecursiveRawUpperBound.fir.txt new file mode 100644 index 00000000000..fdb86c57fbb --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/RecursiveRawUpperBound.fir.txt @@ -0,0 +1,2 @@ + public abstract interface RecursiveRawUpperBound : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/RecursiveWildcardUpperBound.fir.txt b/compiler/testData/loadJava/compiledJava/RecursiveWildcardUpperBound.fir.txt new file mode 100644 index 00000000000..f922e9ca3dc --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/RecursiveWildcardUpperBound.fir.txt @@ -0,0 +1,2 @@ + public abstract interface RecursiveWildcardUpperBound : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/RemoveRedundantProjectionKind.fir.txt b/compiler/testData/loadJava/compiledJava/RemoveRedundantProjectionKind.fir.txt new file mode 100644 index 00000000000..31f8152dea3 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/RemoveRedundantProjectionKind.fir.txt @@ -0,0 +1,6 @@ +public abstract interface RemoveRedundantProjectionKind : R|java/lang/Object| { + public abstract operator function f(collection: R|ft, java/util/Collection?>|!): R|kotlin/Unit| + + public abstract operator function f(comparator: R|ft, java/lang/Comparable?>|!): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/Simple.fir.txt b/compiler/testData/loadJava/compiledJava/Simple.fir.txt new file mode 100644 index 00000000000..7393ecfcc1a --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/Simple.fir.txt @@ -0,0 +1,2 @@ +public final class Simple : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/SubclassFromNested.java b/compiler/testData/loadJava/compiledJava/SubclassFromNested.java index 1716951b831..8c2505d0811 100644 --- a/compiler/testData/loadJava/compiledJava/SubclassFromNested.java +++ b/compiler/testData/loadJava/compiledJava/SubclassFromNested.java @@ -1,3 +1,4 @@ +// SKIP_IN_FIR_TEST package test; public class SubclassFromNested implements B.C { diff --git a/compiler/testData/loadJava/compiledJava/TopLevel$Class.fir.txt b/compiler/testData/loadJava/compiledJava/TopLevel$Class.fir.txt new file mode 100644 index 00000000000..0f83ab8892d --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/TopLevel$Class.fir.txt @@ -0,0 +1,4 @@ +public open class TopLevel$Class : R|java/lang/Object| { + public open operator function foo(other: R|ft|!): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/TwoFields.fir.txt b/compiler/testData/loadJava/compiledJava/TwoFields.fir.txt new file mode 100644 index 00000000000..44e37b770ba --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/TwoFields.fir.txt @@ -0,0 +1,2 @@ +public final class TwoFields : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/UnboundWildcard.fir.txt b/compiler/testData/loadJava/compiledJava/UnboundWildcard.fir.txt new file mode 100644 index 00000000000..b0e56b2d2ea --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/UnboundWildcard.fir.txt @@ -0,0 +1,6 @@ +public final class UnboundWildcard : R|java/lang/Object| { + public final operator function foo(): R|ft, test/UnboundWildcard.MyClass?>|! + + public final operator function collection(): R|ft, java/util/Collection?>|! + +} diff --git a/compiler/testData/loadJava/compiledJava/WildcardBounds.fir.txt b/compiler/testData/loadJava/compiledJava/WildcardBounds.fir.txt new file mode 100644 index 00000000000..48a06b31bdc --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/WildcardBounds.fir.txt @@ -0,0 +1,4 @@ +public open class WildcardBounds : R|java/lang/Object| { + public/*package*/ open operator function foo(x: R|ft, test/WildcardBounds.A?>|!, y: R|ft, test/WildcardBounds.A?>|!): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedAnnotation.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedAnnotation.fir.txt new file mode 100644 index 00000000000..be2bc785f1b --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedAnnotation.fir.txt @@ -0,0 +1,2 @@ +@R|test/AnnotatedAnnotation|() public abstract annotation class AnnotatedAnnotation : R|java/lang/annotation/Annotation| { +} diff --git a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedConstructor.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedConstructor.fir.txt new file mode 100644 index 00000000000..54b9cc6596d --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedConstructor.fir.txt @@ -0,0 +1,2 @@ +public open class AnnotatedConstructor : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedEnumEntry.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedEnumEntry.fir.txt new file mode 100644 index 00000000000..db75ab0704a --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedEnumEntry.fir.txt @@ -0,0 +1,2 @@ +public final enum class AnnotatedEnumEntry : R|java/lang/Enum| { +} diff --git a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedField.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedField.fir.txt new file mode 100644 index 00000000000..f3212591408 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedField.fir.txt @@ -0,0 +1,2 @@ +public open class AnnotatedField : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedMethod.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedMethod.fir.txt new file mode 100644 index 00000000000..81908ce12ae --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedMethod.fir.txt @@ -0,0 +1,4 @@ +public open class AnnotatedMethod : R|java/lang/Object| { + @R|test/AnnotatedMethod.Anno|(Int(42)) public open operator function f(): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedParameterInEnumClassConstructor.java b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedParameterInEnumClassConstructor.java index 8000979317f..4698dff574a 100644 --- a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedParameterInEnumClassConstructor.java +++ b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedParameterInEnumClassConstructor.java @@ -1,3 +1,4 @@ +// SKIP_IN_FIR_TEST package test; class AnnotatedParameterInInnerClassConstructor { diff --git a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedParameterInInnerClassConstructor.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedParameterInInnerClassConstructor.fir.txt new file mode 100644 index 00000000000..959fddeb39f --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedParameterInInnerClassConstructor.fir.txt @@ -0,0 +1,2 @@ +public/*package*/ open class AnnotatedParameterInInnerClassConstructor : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedTypeInEnumClassConstructor.java b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedTypeInEnumClassConstructor.java index 37282196f69..ac67b009250 100644 --- a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedTypeInEnumClassConstructor.java +++ b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedTypeInEnumClassConstructor.java @@ -1,3 +1,4 @@ +// SKIP_IN_FIR_TEST // SKIP_IN_RUNTIME_TEST package test; diff --git a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedTypeInEnumClassConstructor2.java b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedTypeInEnumClassConstructor2.java index 5baef256603..d70b4babfcb 100644 --- a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedTypeInEnumClassConstructor2.java +++ b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedTypeInEnumClassConstructor2.java @@ -1,3 +1,4 @@ +// SKIP_IN_FIR_TEST // SKIP_IN_RUNTIME_TEST package test; diff --git a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedTypeInFun.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedTypeInFun.fir.txt new file mode 100644 index 00000000000..fc9d8fed0a9 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedTypeInFun.fir.txt @@ -0,0 +1,4 @@ +public/*package*/ open class AnnotatedTypeInFun : R|java/lang/Object| { + public/*package*/ open operator function foo(@R|test/AnnotatedTypeInFun.Anno|(String(a)) a: @R|test/AnnotatedTypeInFun.Anno|(String(a)) R|ft|!, @R|test/AnnotatedTypeInFun.Anno|(String(b)) b: @R|test/AnnotatedTypeInFun.Anno|(String(b)) R|ft|!): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedTypeInInnerClassConstructor.java b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedTypeInInnerClassConstructor.java index 8c1069e218e..a26065f9952 100644 --- a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedTypeInInnerClassConstructor.java +++ b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedTypeInInnerClassConstructor.java @@ -1,3 +1,4 @@ +// SKIP_IN_FIR_TEST // SKIP_IN_RUNTIME_TEST package test; diff --git a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedTypeInInnerClassConstructor2.java b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedTypeInInnerClassConstructor2.java index 0bedb109524..b7efb8f89c9 100644 --- a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedTypeInInnerClassConstructor2.java +++ b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedTypeInInnerClassConstructor2.java @@ -1,3 +1,4 @@ +// SKIP_IN_FIR_TEST // SKIP_IN_RUNTIME_TEST package test; diff --git a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedValueParameter.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedValueParameter.fir.txt new file mode 100644 index 00000000000..45861b8e182 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedValueParameter.fir.txt @@ -0,0 +1,4 @@ +public open class AnnotatedValueParameter : R|java/lang/Object| { + public open operator function f(@R|test/AnnotatedValueParameter.Anno|(String(non-empty)) parameter: R|ft>, java/util/List>>|): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/annotations/AnnotationInParam.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/AnnotationInParam.fir.txt new file mode 100644 index 00000000000..3d61d7fd358 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/AnnotationInParam.fir.txt @@ -0,0 +1,2 @@ +public abstract interface AnnotationInParam : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/annotations/AnnotationRetentions.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/AnnotationRetentions.fir.txt new file mode 100644 index 00000000000..7cf7022274c --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/AnnotationRetentions.fir.txt @@ -0,0 +1,2 @@ +public open class AnnotationRetentions : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/annotations/AnnotationTargets.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/AnnotationTargets.fir.txt new file mode 100644 index 00000000000..3fbee81feff --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/AnnotationTargets.fir.txt @@ -0,0 +1,2 @@ +public open class AnnotationTargets : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/annotations/ArithmeticExpressionInParam.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/ArithmeticExpressionInParam.fir.txt new file mode 100644 index 00000000000..699826cb262 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/ArithmeticExpressionInParam.fir.txt @@ -0,0 +1,2 @@ +public open class ArithmeticExpressionInParam : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/annotations/ArrayOfEnumInParam.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/ArrayOfEnumInParam.fir.txt new file mode 100644 index 00000000000..4d157436d34 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/ArrayOfEnumInParam.fir.txt @@ -0,0 +1,2 @@ +public abstract interface ArrayOfEnumInParam : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/annotations/ArrayOfStringInParam.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/ArrayOfStringInParam.fir.txt new file mode 100644 index 00000000000..2fc2f8f0f9f --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/ArrayOfStringInParam.fir.txt @@ -0,0 +1,2 @@ +public abstract interface ArrayOfStringInParam : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/annotations/ClassObjectArrayInParam.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/ClassObjectArrayInParam.fir.txt new file mode 100644 index 00000000000..e7c9c4fdac7 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/ClassObjectArrayInParam.fir.txt @@ -0,0 +1,2 @@ +public open class ClassObjectArrayInParam : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParam.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParam.fir.txt new file mode 100644 index 00000000000..ba6e3badac8 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParam.fir.txt @@ -0,0 +1,2 @@ +public open class ClassObjectInParam : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParamRaw.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParamRaw.fir.txt new file mode 100644 index 00000000000..cc63baa8a79 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParamRaw.fir.txt @@ -0,0 +1,2 @@ +public open class ClassObjectInParamRaw : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParamVariance.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParamVariance.fir.txt new file mode 100644 index 00000000000..cbf19eb5e53 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParamVariance.fir.txt @@ -0,0 +1,2 @@ +public open class ClassObjectInParamVariance : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/annotations/CustomAnnotation.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/CustomAnnotation.fir.txt new file mode 100644 index 00000000000..10d56902fa1 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/CustomAnnotation.fir.txt @@ -0,0 +1,2 @@ +public abstract interface CustomAnnotation : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/annotations/CustomAnnotationWithDefaultParameter.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/CustomAnnotationWithDefaultParameter.fir.txt new file mode 100644 index 00000000000..6c55b01e9a5 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/CustomAnnotationWithDefaultParameter.fir.txt @@ -0,0 +1,2 @@ +public abstract interface CustomAnnotationWithDefaultParameter : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/annotations/EmptyArrayInParam.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/EmptyArrayInParam.fir.txt new file mode 100644 index 00000000000..eb72449e468 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/EmptyArrayInParam.fir.txt @@ -0,0 +1,2 @@ +public abstract interface EmptyArrayInParam : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/annotations/EnumArgumentWithCustomToString.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/EnumArgumentWithCustomToString.fir.txt new file mode 100644 index 00000000000..1d9c7c23c38 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/EnumArgumentWithCustomToString.fir.txt @@ -0,0 +1,4 @@ +public open class EnumArgumentWithCustomToString : R|java/lang/Object| { + @R|test/EnumArgumentWithCustomToString.EnumAnno|(#()) @R|test/EnumArgumentWithCustomToString.EnumArrayAnno|((#(), #())) public/*package*/ open operator function annotated(): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/annotations/EnumConstructorParameter.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/EnumConstructorParameter.fir.txt new file mode 100644 index 00000000000..eeac732ff7d --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/EnumConstructorParameter.fir.txt @@ -0,0 +1,2 @@ +public final enum class EnumConstructorParameter : R|java/lang/Enum| { +} diff --git a/compiler/testData/loadJava/compiledJava/annotations/EnumInParam.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/EnumInParam.fir.txt new file mode 100644 index 00000000000..4cef4eabd1d --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/EnumInParam.fir.txt @@ -0,0 +1,2 @@ +public abstract interface EnumInParam : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/annotations/JavaDocDeprecated.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/JavaDocDeprecated.fir.txt new file mode 100644 index 00000000000..95678eae1d4 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/JavaDocDeprecated.fir.txt @@ -0,0 +1,4 @@ +public open class JavaDocDeprecated : R|java/lang/Object| { + public open operator function getFoo(text: R|ft|!): R|ft|! + +} diff --git a/compiler/testData/loadJava/compiledJava/annotations/NestedEnumArgument.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/NestedEnumArgument.fir.txt new file mode 100644 index 00000000000..ec04dd46178 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/NestedEnumArgument.fir.txt @@ -0,0 +1,4 @@ +public open class NestedEnumArgument : R|java/lang/Object| { + @R|test/NestedEnumArgument.Anno|(#()) public/*package*/ open operator function foo(): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/annotations/PrimitiveValueInParam.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/PrimitiveValueInParam.fir.txt new file mode 100644 index 00000000000..2b7bfbb693a --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/PrimitiveValueInParam.fir.txt @@ -0,0 +1,2 @@ +public abstract interface PrimitiveValueInParam : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/annotations/RecursiveAnnotation.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/RecursiveAnnotation.fir.txt new file mode 100644 index 00000000000..e243707d1b6 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/RecursiveAnnotation.fir.txt @@ -0,0 +1,2 @@ +public abstract interface RecursiveAnnotation : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/annotations/RecursiveAnnotation2.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/RecursiveAnnotation2.fir.txt new file mode 100644 index 00000000000..ae1400161bd --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/RecursiveAnnotation2.fir.txt @@ -0,0 +1,2 @@ +public abstract interface RecursiveAnnotation2 : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/annotations/SimpleAnnotation.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/SimpleAnnotation.fir.txt new file mode 100644 index 00000000000..9e2b3f31af6 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/SimpleAnnotation.fir.txt @@ -0,0 +1,2 @@ +public abstract annotation class SimpleAnnotation : R|java/lang/annotation/Annotation| { +} diff --git a/compiler/testData/loadJava/compiledJava/annotations/StringConcatenationInParam.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/StringConcatenationInParam.fir.txt new file mode 100644 index 00000000000..9d595fbfe9f --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/StringConcatenationInParam.fir.txt @@ -0,0 +1,2 @@ +public abstract interface StringConcatenationInParam : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/annotations/StringConstantInParam.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/StringConstantInParam.fir.txt new file mode 100644 index 00000000000..0a0791dc419 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/StringConstantInParam.fir.txt @@ -0,0 +1,2 @@ +public abstract interface StringConstantInParam : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/annotations/StringInParam.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/StringInParam.fir.txt new file mode 100644 index 00000000000..ba64462bb2c --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/StringInParam.fir.txt @@ -0,0 +1,2 @@ +public abstract interface StringInParam : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/constructor/ConstructorGenericDeep.fir.txt b/compiler/testData/loadJava/compiledJava/constructor/ConstructorGenericDeep.fir.txt new file mode 100644 index 00000000000..fe839a84173 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/constructor/ConstructorGenericDeep.fir.txt @@ -0,0 +1,2 @@ +public open class ConstructorGenericDeep : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/constructor/ConstructorGenericSimple.fir.txt b/compiler/testData/loadJava/compiledJava/constructor/ConstructorGenericSimple.fir.txt new file mode 100644 index 00000000000..1ad58206389 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/constructor/ConstructorGenericSimple.fir.txt @@ -0,0 +1,2 @@ +public open class ConstructorGenericSimple : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/constructor/ConstructorGenericUpperBound.fir.txt b/compiler/testData/loadJava/compiledJava/constructor/ConstructorGenericUpperBound.fir.txt new file mode 100644 index 00000000000..e567ce9a37d --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/constructor/ConstructorGenericUpperBound.fir.txt @@ -0,0 +1,2 @@ +public open class ConstructorGenericUpperBound : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/enum/EnumMembers.fir.txt b/compiler/testData/loadJava/compiledJava/enum/EnumMembers.fir.txt new file mode 100644 index 00000000000..8f4c25299f9 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/enum/EnumMembers.fir.txt @@ -0,0 +1,4 @@ +public final enum class EnumMembers : R|java/lang/Enum| { + public open operator function first(): R|kotlin/Boolean| + +} diff --git a/compiler/testData/loadJava/compiledJava/enum/EnumWithSpecializedEntry.fir.txt b/compiler/testData/loadJava/compiledJava/enum/EnumWithSpecializedEntry.fir.txt new file mode 100644 index 00000000000..93b3d3a3b85 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/enum/EnumWithSpecializedEntry.fir.txt @@ -0,0 +1,2 @@ +public open enum class EnumWithSpecializedEntry : R|java/lang/Enum| { +} diff --git a/compiler/testData/loadJava/compiledJava/enum/JavaEnum.fir.txt b/compiler/testData/loadJava/compiledJava/enum/JavaEnum.fir.txt new file mode 100644 index 00000000000..e13e27f4dac --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/enum/JavaEnum.fir.txt @@ -0,0 +1,2 @@ +public final enum class JavaEnum : R|java/lang/Enum| { +} diff --git a/compiler/testData/loadJava/compiledJava/javaBean/DifferentGetterAndSetter.fir.txt b/compiler/testData/loadJava/compiledJava/javaBean/DifferentGetterAndSetter.fir.txt new file mode 100644 index 00000000000..4dcf24605bf --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/javaBean/DifferentGetterAndSetter.fir.txt @@ -0,0 +1,6 @@ +public open class DifferentGetterAndSetter : R|java/lang/Object| { + public open operator function setSomething(color: R|ft|!): R|kotlin/Unit| + + public open operator function getSomething(): R|kotlin/Int| + +} diff --git a/compiler/testData/loadJava/compiledJava/javaBean/JavaBeanAbstractGetter.fir.txt b/compiler/testData/loadJava/compiledJava/javaBean/JavaBeanAbstractGetter.fir.txt new file mode 100644 index 00000000000..5b4ac41570b --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/javaBean/JavaBeanAbstractGetter.fir.txt @@ -0,0 +1,6 @@ +public abstract interface JavaBeanAbstractGetter : R|java/lang/Object| { + public abstract operator function getRed(): R|kotlin/Int| + + public abstract operator function getBlue(): R|kotlin/Int| + +} diff --git a/compiler/testData/loadJava/compiledJava/javaBean/JavaBeanVal.fir.txt b/compiler/testData/loadJava/compiledJava/javaBean/JavaBeanVal.fir.txt new file mode 100644 index 00000000000..55dbbeb9e5b --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/javaBean/JavaBeanVal.fir.txt @@ -0,0 +1,4 @@ +public open class JavaBeanVal : R|java/lang/Object| { + public open operator function getColor(): R|ft|! + +} diff --git a/compiler/testData/loadJava/compiledJava/javaBean/JavaBeanVar.fir.txt b/compiler/testData/loadJava/compiledJava/javaBean/JavaBeanVar.fir.txt new file mode 100644 index 00000000000..b058578d98b --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/javaBean/JavaBeanVar.fir.txt @@ -0,0 +1,6 @@ +public open class JavaBeanVar : R|java/lang/Object| { + public open operator function getColor(): R|ft|! + + public open operator function setColor(string: R|ft|!): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/javaBean/JavaBeanVarOfGenericType.fir.txt b/compiler/testData/loadJava/compiledJava/javaBean/JavaBeanVarOfGenericType.fir.txt new file mode 100644 index 00000000000..c047c160f22 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/javaBean/JavaBeanVarOfGenericType.fir.txt @@ -0,0 +1,6 @@ +

public open class JavaBeanVarOfGenericType : R|java/lang/Object| { + public open operator function getCharacters(): R|ft>, java/util/ArrayList>>| + + public open operator function setCharacters(characters: R|ft>, java/util/ArrayList>>|): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/javaBean/TwoSetters.fir.txt b/compiler/testData/loadJava/compiledJava/javaBean/TwoSetters.fir.txt new file mode 100644 index 00000000000..239a873b5b7 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/javaBean/TwoSetters.fir.txt @@ -0,0 +1,6 @@ +public open class TwoSetters : R|java/lang/Object| { + public open operator function setSize(size: R|ft|!): R|kotlin/Unit| + + public open operator function setSize(size: R|kotlin/Int|): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/AllBoundsInWhen.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/AllBoundsInWhen.fir.txt new file mode 100644 index 00000000000..e8ba59d7c91 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/AllBoundsInWhen.fir.txt @@ -0,0 +1,4 @@ +public open class AllBoundsInWhen : R|java/lang/Object| { + public open operator function foo(): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/ArrayType.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/ArrayType.fir.txt new file mode 100644 index 00000000000..e18fc904d74 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/ArrayType.fir.txt @@ -0,0 +1,4 @@ +public open class ArrayType : R|java/lang/Object| { + public open operator function foo(): R|kotlin/Array>| + +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/ConstructorWithNewTypeParams.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/ConstructorWithNewTypeParams.fir.txt new file mode 100644 index 00000000000..bc8256081fa --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/ConstructorWithNewTypeParams.fir.txt @@ -0,0 +1,2 @@ + public open class ConstructorWithNewTypeParams : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/ConstructorWithParentTypeParams.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/ConstructorWithParentTypeParams.fir.txt new file mode 100644 index 00000000000..6698c7fcb27 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/ConstructorWithParentTypeParams.fir.txt @@ -0,0 +1,2 @@ + public open class ConstructorWithParentTypeParams : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/ConstructorWithSeveralParams.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/ConstructorWithSeveralParams.fir.txt new file mode 100644 index 00000000000..06039d270c3 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/ConstructorWithSeveralParams.fir.txt @@ -0,0 +1,2 @@ +public open class ConstructorWithSeveralParams : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/ConstructorWithoutParams.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/ConstructorWithoutParams.fir.txt new file mode 100644 index 00000000000..15f80d062ff --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/ConstructorWithoutParams.fir.txt @@ -0,0 +1,2 @@ +public open class ConstructorWithoutParams : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/CustomProjectionKind.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/CustomProjectionKind.fir.txt new file mode 100644 index 00000000000..c94163e2c27 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/CustomProjectionKind.fir.txt @@ -0,0 +1,4 @@ +public open class CustomProjectionKind : R|java/lang/Object| { + public open operator function foo(): R|ft>, java/util/List>>| + +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithFunctionTypes.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithFunctionTypes.fir.txt new file mode 100644 index 00000000000..06bbb7dea11 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithFunctionTypes.fir.txt @@ -0,0 +1,4 @@ +public open class MethodWithFunctionTypes : R|java/lang/Object| { + public open operator function foo(f: R|ft, ft>, kotlin/jvm/functions/Function1, ft>>|): R|ft>, kotlin/jvm/functions/Function0>>| + +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithGenerics.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithGenerics.fir.txt new file mode 100644 index 00000000000..ee9b7ffa89c --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithGenerics.fir.txt @@ -0,0 +1,4 @@ +public open class MethodWithGenerics : R|java/lang/Object| { + public open operator function foo(a: R|ft|!, b: R|ft, ft>, java/util/Map.Entry, ft>>>, java/util/List, ft>, java/util/Map.Entry, ft>>>>|): R|ft|! + +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithMappedClasses.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithMappedClasses.fir.txt new file mode 100644 index 00000000000..925513ba1ab --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithMappedClasses.fir.txt @@ -0,0 +1,6 @@ +public open class MethodWithMappedClasses : R|java/lang/Object| { + public open operator function copy(dest: R|ft, java/util/List?>|!, src: R|ft>, java/util/List>>|): R|kotlin/Unit| + + public open operator function copyMap(dest: R|ft, *>, java/util/Map, *>>|, src: R|ft, ft>, java/util/Map, ft>>|): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithTypeParameters.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithTypeParameters.fir.txt new file mode 100644 index 00000000000..1832433168e --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithTypeParameters.fir.txt @@ -0,0 +1,4 @@ +public open class MethodWithTypeParameters : R|java/lang/Object| { + public open operator function foo(a: R|ft|!, b: R|ft, java/util/List?>|!, list: R|ft, java/util/List?>|!): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithVararg.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithVararg.fir.txt new file mode 100644 index 00000000000..25b0be367b8 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithVararg.fir.txt @@ -0,0 +1,4 @@ +public open class MethodWithVararg : R|java/lang/Object| { + public open operator function foo(vararg s: R|kotlin/Array>|): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/PropertyArrayTypes.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/PropertyArrayTypes.fir.txt new file mode 100644 index 00000000000..3e5f854b354 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/PropertyArrayTypes.fir.txt @@ -0,0 +1,2 @@ + public open class PropertyArrayTypes : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/PropertyComplexTypes.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/PropertyComplexTypes.fir.txt new file mode 100644 index 00000000000..03921b74cdc --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/PropertyComplexTypes.fir.txt @@ -0,0 +1,2 @@ + public open class PropertyComplexTypes : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/PropertySimpleType.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/PropertySimpleType.fir.txt new file mode 100644 index 00000000000..41c6dc67b9c --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/PropertySimpleType.fir.txt @@ -0,0 +1,2 @@ +public open class PropertySimpleType : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/StarProjection.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/StarProjection.fir.txt new file mode 100644 index 00000000000..1ae3ba3be8e --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/StarProjection.fir.txt @@ -0,0 +1,4 @@ +public final class StarProjection : R|java/lang/Object| { + public final operator function foo(): R|ft, test/StarProjection.MyClass?>|! + +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/error/WrongProjectionKind.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/error/WrongProjectionKind.fir.txt new file mode 100644 index 00000000000..1949ada7afa --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/error/WrongProjectionKind.fir.txt @@ -0,0 +1,4 @@ +public open class WrongProjectionKind : R|java/lang/Object| { + public open operator function copy(from: R|kotlin/Array>|, to: R|kotlin/Array>|): R|ft>, java/util/List>>| + +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/error/WrongReturnTypeStructure.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/error/WrongReturnTypeStructure.fir.txt new file mode 100644 index 00000000000..2347e48dee4 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/error/WrongReturnTypeStructure.fir.txt @@ -0,0 +1,4 @@ +public open class WrongReturnTypeStructure : R|java/lang/Object| { + public open operator function foo(a: R|ft|!, b: R|ft, ft>, java/util/Map.Entry, ft>>>, java/util/List, ft>, java/util/Map.Entry, ft>>>>|): R|ft|! + +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/error/WrongTypeParameterBoundStructure1.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/error/WrongTypeParameterBoundStructure1.fir.txt new file mode 100644 index 00000000000..f2d3c10ff9a --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/error/WrongTypeParameterBoundStructure1.fir.txt @@ -0,0 +1,4 @@ +public open class WrongTypeParameterBoundStructure1 : R|java/lang/Object| { + public open operator function foo(a: R|ft|!, b: R|ft, java/util/List?>|!): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/error/WrongValueParameterStructure1.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/error/WrongValueParameterStructure1.fir.txt new file mode 100644 index 00000000000..6993b31c3fe --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/error/WrongValueParameterStructure1.fir.txt @@ -0,0 +1,4 @@ +public open class WrongValueParameterStructure1 : R|java/lang/Object| { + public open operator function foo(a: R|ft|!, b: R|ft, ft>, java/util/Map.Entry, ft>>>, java/util/List, ft>, java/util/Map.Entry, ft>>>>|): R|ft|! + +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/PropagateTypeArgumentNullable.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/PropagateTypeArgumentNullable.fir.txt new file mode 100644 index 00000000000..a31b2d2be4b --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/PropagateTypeArgumentNullable.fir.txt @@ -0,0 +1,2 @@ +public abstract interface PropagateTypeArgumentNullable : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/ChangeProjectionKind1.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/ChangeProjectionKind1.fir.txt new file mode 100644 index 00000000000..863fad079e7 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/ChangeProjectionKind1.fir.txt @@ -0,0 +1,2 @@ +public abstract interface ChangeProjectionKind1 : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.fir.txt new file mode 100644 index 00000000000..92b804ff6df --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.fir.txt @@ -0,0 +1,2 @@ +public abstract interface DeeplySubstitutedClassParameter : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.fir.txt new file mode 100644 index 00000000000..40d404c3360 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.fir.txt @@ -0,0 +1,2 @@ +public abstract interface DeeplySubstitutedClassParameter2 : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNotVararg.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNotVararg.fir.txt new file mode 100644 index 00000000000..183aebc0fa4 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNotVararg.fir.txt @@ -0,0 +1,2 @@ +public abstract interface InheritNotVararg : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNotVarargInteger.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNotVarargInteger.fir.txt new file mode 100644 index 00000000000..c4b2b5ce5a7 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNotVarargInteger.fir.txt @@ -0,0 +1,2 @@ +public abstract interface InheritNotVarargInteger : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.fir.txt new file mode 100644 index 00000000000..0d19bde0c5a --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.fir.txt @@ -0,0 +1,2 @@ +public abstract interface InheritNotVarargNotNull : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNotVarargPrimitive.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNotVarargPrimitive.fir.txt new file mode 100644 index 00000000000..c4b7bb841ac --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNotVarargPrimitive.fir.txt @@ -0,0 +1,2 @@ +public abstract interface InheritNotVarargPrimitive : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNullability.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNullability.fir.txt new file mode 100644 index 00000000000..bf967760004 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNullability.fir.txt @@ -0,0 +1,2 @@ +public abstract interface InheritNullability : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritVararg.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritVararg.fir.txt new file mode 100644 index 00000000000..e5bcface1df --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritVararg.fir.txt @@ -0,0 +1,2 @@ +public abstract interface InheritVararg : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritVarargInteger.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritVarargInteger.fir.txt new file mode 100644 index 00000000000..72bb95a573f --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritVarargInteger.fir.txt @@ -0,0 +1,2 @@ +public abstract interface InheritVarargInteger : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritVarargNotNull.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritVarargNotNull.fir.txt new file mode 100644 index 00000000000..b87c130715b --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritVarargNotNull.fir.txt @@ -0,0 +1,2 @@ +public abstract interface InheritVarargNotNull : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritVarargPrimitive.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritVarargPrimitive.fir.txt new file mode 100644 index 00000000000..5dae72ac855 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritVarargPrimitive.fir.txt @@ -0,0 +1,2 @@ +public abstract interface InheritVarargPrimitive : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/Kt3302.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/Kt3302.fir.txt new file mode 100644 index 00000000000..f4b116a6538 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/Kt3302.fir.txt @@ -0,0 +1,2 @@ +public abstract interface Kt3302 : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/MutableToReadOnly.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/MutableToReadOnly.fir.txt new file mode 100644 index 00000000000..7336cc9ff10 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/MutableToReadOnly.fir.txt @@ -0,0 +1,2 @@ +public abstract interface MutableToReadOnly : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/NotNullToNullable.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/NotNullToNullable.fir.txt new file mode 100644 index 00000000000..9d6d4157693 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/NotNullToNullable.fir.txt @@ -0,0 +1,2 @@ +public abstract interface NotNullToNullable : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/NullableToNotNull.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/NullableToNotNull.fir.txt new file mode 100644 index 00000000000..01b3bcbf9d6 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/NullableToNotNull.fir.txt @@ -0,0 +1,2 @@ +public abstract interface NullableToNotNull : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/NullableToNotNullKotlinSignature.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/NullableToNotNullKotlinSignature.fir.txt new file mode 100644 index 00000000000..37de3971f59 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/NullableToNotNullKotlinSignature.fir.txt @@ -0,0 +1,2 @@ +public abstract interface NullableToNotNullKotlinSignature : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/OverrideWithErasedParameter.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/OverrideWithErasedParameter.fir.txt new file mode 100644 index 00000000000..54471d8056f --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/OverrideWithErasedParameter.fir.txt @@ -0,0 +1,2 @@ +public abstract interface OverrideWithErasedParameter : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/ReadOnlyToMutable.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/ReadOnlyToMutable.fir.txt new file mode 100644 index 00000000000..90d4c39e10d --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/ReadOnlyToMutable.fir.txt @@ -0,0 +1,2 @@ +public abstract interface ReadOnlyToMutable : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.fir.txt new file mode 100644 index 00000000000..4887527014a --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.fir.txt @@ -0,0 +1,2 @@ +public abstract interface SubclassFromGenericAndNot : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/SubstitutedClassParameter.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/SubstitutedClassParameter.fir.txt new file mode 100644 index 00000000000..5dd2878e7fb --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/SubstitutedClassParameter.fir.txt @@ -0,0 +1,2 @@ +public abstract interface SubstitutedClassParameter : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/SubstitutedClassParameters.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/SubstitutedClassParameters.fir.txt new file mode 100644 index 00000000000..f65d186776e --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/SubstitutedClassParameters.fir.txt @@ -0,0 +1,2 @@ +public abstract interface SubstitutedClassParameters : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNotNullJavaSubtype.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNotNullJavaSubtype.fir.txt new file mode 100644 index 00000000000..90d123a2d43 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNotNullJavaSubtype.fir.txt @@ -0,0 +1,2 @@ +public abstract interface AddNotNullJavaSubtype : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNotNullSameJavaType.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNotNullSameJavaType.fir.txt new file mode 100644 index 00000000000..4bc28fe6072 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNotNullSameJavaType.fir.txt @@ -0,0 +1,2 @@ +public abstract interface AddNotNullSameJavaType : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.fir.txt new file mode 100644 index 00000000000..4a9cf11be9e --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.fir.txt @@ -0,0 +1,2 @@ +public abstract interface AddNullabilityJavaSubtype : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNullabilitySameGenericType1.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNullabilitySameGenericType1.fir.txt new file mode 100644 index 00000000000..43b094d15c3 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNullabilitySameGenericType1.fir.txt @@ -0,0 +1,2 @@ +public abstract interface AddNullabilitySameGenericType1 : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNullabilitySameGenericType2.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNullabilitySameGenericType2.fir.txt new file mode 100644 index 00000000000..1053e21023a --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNullabilitySameGenericType2.fir.txt @@ -0,0 +1,2 @@ +public abstract interface AddNullabilitySameGenericType2 : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNullabilitySameJavaType.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNullabilitySameJavaType.fir.txt new file mode 100644 index 00000000000..0755ec0f812 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNullabilitySameJavaType.fir.txt @@ -0,0 +1,2 @@ +public abstract interface AddNullabilitySameJavaType : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/CantMakeImmutableInSubclass.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/CantMakeImmutableInSubclass.fir.txt new file mode 100644 index 00000000000..88c891b34b9 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/CantMakeImmutableInSubclass.fir.txt @@ -0,0 +1,2 @@ +public abstract interface CantMakeImmutableInSubclass : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.fir.txt new file mode 100644 index 00000000000..92b804ff6df --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.fir.txt @@ -0,0 +1,2 @@ +public abstract interface DeeplySubstitutedClassParameter : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter2.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter2.fir.txt new file mode 100644 index 00000000000..40d404c3360 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter2.fir.txt @@ -0,0 +1,2 @@ +public abstract interface DeeplySubstitutedClassParameter2 : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.fir.txt new file mode 100644 index 00000000000..ec9f5510ff7 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.fir.txt @@ -0,0 +1,2 @@ +public abstract interface HalfSubstitutedTypeParameters : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritNullabilityGenericSubclassSimple.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritNullabilityGenericSubclassSimple.fir.txt new file mode 100644 index 00000000000..3d5f388be52 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritNullabilityGenericSubclassSimple.fir.txt @@ -0,0 +1,2 @@ +public abstract interface InheritNullabilityGenericSubclassSimple : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.fir.txt new file mode 100644 index 00000000000..f4baa3bf441 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.fir.txt @@ -0,0 +1,2 @@ +public abstract interface InheritNullabilityJavaSubtype : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritNullabilitySameGenericType.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritNullabilitySameGenericType.fir.txt new file mode 100644 index 00000000000..b1a95360103 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritNullabilitySameGenericType.fir.txt @@ -0,0 +1,2 @@ +public abstract interface InheritNullabilitySameGenericType : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.fir.txt new file mode 100644 index 00000000000..50e2e8aecdb --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.fir.txt @@ -0,0 +1,2 @@ +public abstract interface InheritNullabilitySameJavaType : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritProjectionKind.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritProjectionKind.fir.txt new file mode 100644 index 00000000000..15464a6d1d0 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritProjectionKind.fir.txt @@ -0,0 +1,2 @@ +public abstract interface InheritProjectionKind : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritReadOnlinessOfArgument.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritReadOnlinessOfArgument.fir.txt new file mode 100644 index 00000000000..3d96271ad89 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritReadOnlinessOfArgument.fir.txt @@ -0,0 +1,2 @@ +public abstract interface InheritReadOnlinessOfArgument : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritReadOnlinessSameClass.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritReadOnlinessSameClass.fir.txt new file mode 100644 index 00000000000..f0fa5d2a852 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritReadOnlinessSameClass.fir.txt @@ -0,0 +1,2 @@ +public abstract interface InheritReadOnlinessSameClass : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritReadOnlinessSubclass.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritReadOnlinessSubclass.fir.txt new file mode 100644 index 00000000000..69dbecbd100 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritReadOnlinessSubclass.fir.txt @@ -0,0 +1,2 @@ +public abstract interface InheritReadOnlinessSubclass : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SameProjectionKind.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SameProjectionKind.fir.txt new file mode 100644 index 00000000000..026afd073c2 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SameProjectionKind.fir.txt @@ -0,0 +1,2 @@ +public abstract interface SameProjectionKind : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubclassFromGenericAndNot.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubclassFromGenericAndNot.fir.txt new file mode 100644 index 00000000000..4887527014a --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubclassFromGenericAndNot.fir.txt @@ -0,0 +1,2 @@ +public abstract interface SubclassFromGenericAndNot : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubclassOfCollection.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubclassOfCollection.fir.txt new file mode 100644 index 00000000000..5bfe1b5a75d --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubclassOfCollection.fir.txt @@ -0,0 +1,4 @@ + public abstract interface SubclassOfCollection : R|java/util/Collection| { + public abstract operator function iterator(): R|ft>, java/util/Iterator>>| + +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubclassOfMapEntry.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubclassOfMapEntry.fir.txt new file mode 100644 index 00000000000..029996b957a --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubclassOfMapEntry.fir.txt @@ -0,0 +1,4 @@ + public abstract interface SubclassOfMapEntry : R|java/util/Map.Entry| { + public abstract operator function setValue(value: R|ft|!): R|ft|! + +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubstitutedClassParameter.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubstitutedClassParameter.fir.txt new file mode 100644 index 00000000000..5dd2878e7fb --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubstitutedClassParameter.fir.txt @@ -0,0 +1,2 @@ +public abstract interface SubstitutedClassParameter : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubstitutedClassParameters.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubstitutedClassParameters.fir.txt new file mode 100644 index 00000000000..f65d186776e --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubstitutedClassParameters.fir.txt @@ -0,0 +1,2 @@ +public abstract interface SubstitutedClassParameters : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.fir.txt new file mode 100644 index 00000000000..56f8983ac01 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.fir.txt @@ -0,0 +1,2 @@ +public abstract interface TwoSuperclassesConflictingProjectionKinds : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferMutability.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferMutability.fir.txt new file mode 100644 index 00000000000..5810bc01ae0 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferMutability.fir.txt @@ -0,0 +1,2 @@ +public abstract interface TwoSuperclassesInvariantAndCovariantInferMutability : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferNullability.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferNullability.fir.txt new file mode 100644 index 00000000000..57d2a9ba66b --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferNullability.fir.txt @@ -0,0 +1,2 @@ +public abstract interface TwoSuperclassesInvariantAndCovariantInferNullability : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesMutableAndNot.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesMutableAndNot.fir.txt new file mode 100644 index 00000000000..d3b9c465423 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesMutableAndNot.fir.txt @@ -0,0 +1,2 @@ +public abstract interface TwoSuperclassesMutableAndNot : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesReturnJavaSubtype.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesReturnJavaSubtype.fir.txt new file mode 100644 index 00000000000..e9b9e060949 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesReturnJavaSubtype.fir.txt @@ -0,0 +1,2 @@ +public abstract interface TwoSuperclassesReturnJavaSubtype : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesReturnSameJavaType.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesReturnSameJavaType.fir.txt new file mode 100644 index 00000000000..263139a460a --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesReturnSameJavaType.fir.txt @@ -0,0 +1,2 @@ +public abstract interface TwoSuperclassesReturnSameJavaType : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesSupplementNotNull.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesSupplementNotNull.fir.txt new file mode 100644 index 00000000000..1cd91a8f8e4 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesSupplementNotNull.fir.txt @@ -0,0 +1,2 @@ +public abstract interface TwoSuperclassesSupplementNotNull : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfClass.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfClass.fir.txt new file mode 100644 index 00000000000..91f47572727 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfClass.fir.txt @@ -0,0 +1,2 @@ +public abstract interface TypeParamOfClass : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.fir.txt new file mode 100644 index 00000000000..cba571f39ef --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.fir.txt @@ -0,0 +1,2 @@ +public abstract interface TypeParamOfClassSubstituted : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfFun.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfFun.fir.txt new file mode 100644 index 00000000000..b4110687808 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfFun.fir.txt @@ -0,0 +1,2 @@ +public abstract interface TypeParamOfFun : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/InheritNullability.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/InheritNullability.fir.txt new file mode 100644 index 00000000000..bf967760004 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/InheritNullability.fir.txt @@ -0,0 +1,2 @@ +public abstract interface InheritNullability : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/TwoBounds.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/TwoBounds.fir.txt new file mode 100644 index 00000000000..798960c2745 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/TwoBounds.fir.txt @@ -0,0 +1,2 @@ +public abstract interface TwoBounds : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/TwoSuperclasses.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/TwoSuperclasses.fir.txt new file mode 100644 index 00000000000..7bd6f85f4e6 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/TwoSuperclasses.fir.txt @@ -0,0 +1,2 @@ +public abstract interface TwoSuperclasses : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/TwoTypeParameters.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/TwoTypeParameters.fir.txt new file mode 100644 index 00000000000..23726055514 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/TwoTypeParameters.fir.txt @@ -0,0 +1,2 @@ +public abstract interface TwoTypeParameters : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/UseParameterAsUpperBound.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/UseParameterAsUpperBound.fir.txt new file mode 100644 index 00000000000..0160222f605 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/UseParameterAsUpperBound.fir.txt @@ -0,0 +1,2 @@ +public abstract interface UseParameterAsUpperBound : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/UseParameterInUpperBound.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/UseParameterInUpperBound.fir.txt new file mode 100644 index 00000000000..4aa49cab185 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/UseParameterInUpperBound.fir.txt @@ -0,0 +1,2 @@ +public abstract interface UseParameterInUpperBound : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/UseParameterInUpperBoundWithKotlinSignature.fir.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/UseParameterInUpperBoundWithKotlinSignature.fir.txt new file mode 100644 index 00000000000..0fbe5161a82 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/UseParameterInUpperBoundWithKotlinSignature.fir.txt @@ -0,0 +1,2 @@ +public abstract interface UseParameterInUpperBoundWithKotlinSignature : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/library/LoadIterable.fir.txt b/compiler/testData/loadJava/compiledJava/library/LoadIterable.fir.txt new file mode 100644 index 00000000000..e309884fbae --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/library/LoadIterable.fir.txt @@ -0,0 +1,6 @@ + public abstract interface LoadIterable : R|java/lang/Object| { + public abstract operator function getIterable(): R|ft>, java/lang/Iterable>>| + + public abstract operator function setIterable(Iterable: R|ft>, java/lang/Iterable>>|): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/library/LoadIterator.fir.txt b/compiler/testData/loadJava/compiledJava/library/LoadIterator.fir.txt new file mode 100644 index 00000000000..22c7ca47025 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/library/LoadIterator.fir.txt @@ -0,0 +1,6 @@ + public abstract interface LoadIterator : R|java/lang/Object| { + public abstract operator function getIterator(): R|ft>, java/util/Iterator>>| + + public abstract operator function setIterator(iterator: R|ft>, java/util/Iterator>>|): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/library/Max.fir.txt b/compiler/testData/loadJava/compiledJava/library/Max.fir.txt new file mode 100644 index 00000000000..3b981ffd9bf --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/library/Max.fir.txt @@ -0,0 +1,4 @@ +public open class Max : R|java/lang/Object| { + public open operator function max(coll: R|ft, java/util/Collection?>|!): R|ft|! + +} diff --git a/compiler/testData/loadJava/compiledJava/modality/ModalityOfFakeOverrides.fir.txt b/compiler/testData/loadJava/compiledJava/modality/ModalityOfFakeOverrides.fir.txt new file mode 100644 index 00000000000..e89c29120f7 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/modality/ModalityOfFakeOverrides.fir.txt @@ -0,0 +1,6 @@ +public open class ModalityOfFakeOverrides : R|java/util/AbstractList| { + @R|java/lang/Override|() @R|org/jetbrains/annotations/NotNull|() public open operator function get(index: R|kotlin/Int|): R|ft| + + @R|java/lang/Override|() public open operator function size(): R|kotlin/Int| + +} diff --git a/compiler/testData/loadJava/compiledJava/mutability/LoadIterable.fir.txt b/compiler/testData/loadJava/compiledJava/mutability/LoadIterable.fir.txt new file mode 100644 index 00000000000..2bed4be30bf --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/mutability/LoadIterable.fir.txt @@ -0,0 +1,10 @@ + public abstract interface LoadIterable : R|java/lang/Object| { + @R|kotlin/annotations/jvm/Mutable|() public abstract operator function getIterable(): R|ft>, java/lang/Iterable>>| + + public abstract operator function setIterable(@R|kotlin/annotations/jvm/Mutable|() Iterable: R|ft>, java/lang/Iterable>>|): R|kotlin/Unit| + + @R|kotlin/annotations/jvm/ReadOnly|() public abstract operator function getReadOnlyIterable(): R|ft>, java/lang/Iterable>>| + + public abstract operator function setReadOnlyIterable(@R|kotlin/annotations/jvm/ReadOnly|() Iterable: R|ft>, java/lang/Iterable>>|): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/mutability/LoadIterableWithConflict.fir.txt b/compiler/testData/loadJava/compiledJava/mutability/LoadIterableWithConflict.fir.txt new file mode 100644 index 00000000000..c56a5e39ae1 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/mutability/LoadIterableWithConflict.fir.txt @@ -0,0 +1,6 @@ + public abstract interface LoadIterableWithConflict : R|java/lang/Object| { + @R|kotlin/annotations/jvm/ReadOnly|() @R|kotlin/annotations/jvm/Mutable|() public abstract operator function getIterable(): R|ft>, java/lang/Iterable>>| + + public abstract operator function setIterable(@R|kotlin/annotations/jvm/ReadOnly|() @R|kotlin/annotations/jvm/Mutable|() Iterable: R|ft>, java/lang/Iterable>>|): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/mutability/LoadIterableWithNullability.fir.txt b/compiler/testData/loadJava/compiledJava/mutability/LoadIterableWithNullability.fir.txt new file mode 100644 index 00000000000..b493f88a74b --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/mutability/LoadIterableWithNullability.fir.txt @@ -0,0 +1,10 @@ + public abstract interface LoadIterableWithNullability : R|java/lang/Object| { + @R|org/jetbrains/annotations/NotNull|() @R|kotlin/annotations/jvm/Mutable|() public abstract operator function getIterable(): R|ft>, java/lang/Iterable>>| + + public abstract operator function setIterable(@R|kotlin/annotations/jvm/Mutable|() @R|org/jetbrains/annotations/NotNull|() Iterable: R|ft>, java/lang/Iterable>>|): R|kotlin/Unit| + + @R|org/jetbrains/annotations/NotNull|() @R|kotlin/annotations/jvm/ReadOnly|() public abstract operator function getReadOnlyIterable(): R|ft>, java/lang/Iterable>>| + + public abstract operator function setReadOnlyIterable(@R|kotlin/annotations/jvm/ReadOnly|() @R|org/jetbrains/annotations/NotNull|() Iterable: R|ft>, java/lang/Iterable>>|): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/mutability/LoadIterableWithPropagation.fir.txt b/compiler/testData/loadJava/compiledJava/mutability/LoadIterableWithPropagation.fir.txt new file mode 100644 index 00000000000..37f597deb63 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/mutability/LoadIterableWithPropagation.fir.txt @@ -0,0 +1,2 @@ +public abstract interface LoadIterableWithPropagation : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/mutability/ReadOnlyExtendsWildcard.fir.txt b/compiler/testData/loadJava/compiledJava/mutability/ReadOnlyExtendsWildcard.fir.txt new file mode 100644 index 00000000000..cfde63a22c6 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/mutability/ReadOnlyExtendsWildcard.fir.txt @@ -0,0 +1,6 @@ +public abstract interface ReadOnlyExtendsWildcard : R|java/lang/Object| { + public abstract operator function bar(): R|kotlin/Unit| + + public abstract operator function foo(@R|kotlin/annotations/jvm/ReadOnly|() x: R|ft, java/util/List?>|!, @R|org/jetbrains/annotations/NotNull|() y: R|ft, java/lang/Comparable<*>>|): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/notNull/NotNullField.fir.txt b/compiler/testData/loadJava/compiledJava/notNull/NotNullField.fir.txt new file mode 100644 index 00000000000..7e0c607d1b8 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/notNull/NotNullField.fir.txt @@ -0,0 +1,2 @@ +public open class NotNullField : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/notNull/NotNullIntArray.fir.txt b/compiler/testData/loadJava/compiledJava/notNull/NotNullIntArray.fir.txt new file mode 100644 index 00000000000..3ddf763ef6c --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/notNull/NotNullIntArray.fir.txt @@ -0,0 +1,4 @@ +public open class NotNullIntArray : R|java/lang/Object| { + @R|org/jetbrains/annotations/NotNull|() public open operator function hi(): R|kotlin/IntArray| + +} diff --git a/compiler/testData/loadJava/compiledJava/notNull/NotNullMethod.fir.txt b/compiler/testData/loadJava/compiledJava/notNull/NotNullMethod.fir.txt new file mode 100644 index 00000000000..9afe8d17667 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/notNull/NotNullMethod.fir.txt @@ -0,0 +1,4 @@ +public open class NotNullMethod : R|java/lang/Object| { + @R|org/jetbrains/annotations/NotNull|() public open operator function hi(): R|ft| + +} diff --git a/compiler/testData/loadJava/compiledJava/notNull/NotNullObjectArray.fir.txt b/compiler/testData/loadJava/compiledJava/notNull/NotNullObjectArray.fir.txt new file mode 100644 index 00000000000..9e4ba72cf48 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/notNull/NotNullObjectArray.fir.txt @@ -0,0 +1,4 @@ +public open class NotNullObjectArray : R|java/lang/Object| { + @R|org/jetbrains/annotations/NotNull|() public open operator function hi(): R|kotlin/Array>| + +} diff --git a/compiler/testData/loadJava/compiledJava/notNull/NotNullParameter.fir.txt b/compiler/testData/loadJava/compiledJava/notNull/NotNullParameter.fir.txt new file mode 100644 index 00000000000..05e25a3b658 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/notNull/NotNullParameter.fir.txt @@ -0,0 +1,4 @@ +public open class NotNullParameter : R|java/lang/Object| { + public open operator function hi(@R|org/jetbrains/annotations/NotNull|() param: R|ft|): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/protectedPackage/ProtectedPackageConstructor.fir.txt b/compiler/testData/loadJava/compiledJava/protectedPackage/ProtectedPackageConstructor.fir.txt new file mode 100644 index 00000000000..dd7f4652003 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/protectedPackage/ProtectedPackageConstructor.fir.txt @@ -0,0 +1,2 @@ +public open class ProtectedPackageConstructor : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/protectedPackage/ProtectedPackageFun.fir.txt b/compiler/testData/loadJava/compiledJava/protectedPackage/ProtectedPackageFun.fir.txt new file mode 100644 index 00000000000..2276eab56f2 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/protectedPackage/ProtectedPackageFun.fir.txt @@ -0,0 +1,4 @@ +public open class ProtectedPackageFun : R|java/lang/Object| { + protected/*protected and package*/ open operator function foo(): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/protectedPackage/ProtectedPackageProperty.fir.txt b/compiler/testData/loadJava/compiledJava/protectedPackage/ProtectedPackageProperty.fir.txt new file mode 100644 index 00000000000..af95bb07e77 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/protectedPackage/ProtectedPackageProperty.fir.txt @@ -0,0 +1,2 @@ +public open class ProtectedPackageProperty : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/protectedStatic/ConstructorInProtectedStaticNestedClass.fir.txt b/compiler/testData/loadJava/compiledJava/protectedStatic/ConstructorInProtectedStaticNestedClass.fir.txt new file mode 100644 index 00000000000..b788affc4fa --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/protectedStatic/ConstructorInProtectedStaticNestedClass.fir.txt @@ -0,0 +1,2 @@ +public open class ConstructorInProtectedStaticNestedClass : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/rendering/Rendering.fir.txt b/compiler/testData/loadJava/compiledJava/rendering/Rendering.fir.txt new file mode 100644 index 00000000000..4c74193a329 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/rendering/Rendering.fir.txt @@ -0,0 +1,2 @@ +public open class Rendering : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/sam/Comparator.fir.txt b/compiler/testData/loadJava/compiledJava/sam/Comparator.fir.txt new file mode 100644 index 00000000000..764ed67d2f2 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/Comparator.fir.txt @@ -0,0 +1,6 @@ + public abstract interface Comparator : R|java/lang/Object| { + public abstract operator function compare(o1: R|ft|!, o2: R|ft|!): R|kotlin/Int| + + public abstract operator function equals(obj: R|ft|!): R|kotlin/Boolean| + +} diff --git a/compiler/testData/loadJava/compiledJava/sam/DifferentParametersCount.fir.txt b/compiler/testData/loadJava/compiledJava/sam/DifferentParametersCount.fir.txt new file mode 100644 index 00000000000..86f6ed1737c --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/DifferentParametersCount.fir.txt @@ -0,0 +1,2 @@ +public final class DifferentParametersCount : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/sam/FakeStaticOverrides.fir.txt b/compiler/testData/loadJava/compiledJava/sam/FakeStaticOverrides.fir.txt new file mode 100644 index 00000000000..a7ac2c2b225 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/FakeStaticOverrides.fir.txt @@ -0,0 +1,2 @@ +public final class FakeStaticOverrides : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/sam/FilenameFilter.fir.txt b/compiler/testData/loadJava/compiledJava/sam/FilenameFilter.fir.txt new file mode 100644 index 00000000000..6a2f3875446 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/FilenameFilter.fir.txt @@ -0,0 +1,4 @@ +public abstract interface FilenameFilter : R|java/lang/Object| { + public abstract operator function accept(dir: R|ft|!, name: R|ft|!): R|kotlin/Boolean| + +} diff --git a/compiler/testData/loadJava/compiledJava/sam/GenericInterfaceParameterWithSelfBound.fir.txt b/compiler/testData/loadJava/compiledJava/sam/GenericInterfaceParameterWithSelfBound.fir.txt new file mode 100644 index 00000000000..d99fdc43d01 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/GenericInterfaceParameterWithSelfBound.fir.txt @@ -0,0 +1,4 @@ + public abstract interface GenericInterfaceParameterWithSelfBound : R|java/lang/Object| { + public abstract operator function method(t: R|ft|!): R|ft|! + +} diff --git a/compiler/testData/loadJava/compiledJava/sam/GenericInterfaceParametersWithBounds.fir.txt b/compiler/testData/loadJava/compiledJava/sam/GenericInterfaceParametersWithBounds.fir.txt new file mode 100644 index 00000000000..ab5bb565dff --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/GenericInterfaceParametersWithBounds.fir.txt @@ -0,0 +1,4 @@ + public abstract interface GenericInterfaceParametersWithBounds : R|java/lang/Object| { + public abstract operator function method(a: R|kotlin/Array>|, b: R|ft|!): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/sam/GenericMethodParameters.fir.txt b/compiler/testData/loadJava/compiledJava/sam/GenericMethodParameters.fir.txt new file mode 100644 index 00000000000..9d662430283 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/GenericMethodParameters.fir.txt @@ -0,0 +1,4 @@ +public abstract interface GenericMethodParameters : R|java/lang/Object| { + public abstract operator function method(a: R|kotlin/Array>|, b: R|ft|!): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/sam/InterfaceWithObjectMethod.fir.txt b/compiler/testData/loadJava/compiledJava/sam/InterfaceWithObjectMethod.fir.txt new file mode 100644 index 00000000000..13facc60ec5 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/InterfaceWithObjectMethod.fir.txt @@ -0,0 +1,4 @@ +public abstract interface InterfaceWithObjectMethod : R|java/lang/Object| { + public abstract operator function toString(): R|ft|! + +} diff --git a/compiler/testData/loadJava/compiledJava/sam/Nested.fir.txt b/compiler/testData/loadJava/compiledJava/sam/Nested.fir.txt new file mode 100644 index 00000000000..c249549d893 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/Nested.fir.txt @@ -0,0 +1,2 @@ +public abstract interface Nested : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/sam/Runnable.fir.txt b/compiler/testData/loadJava/compiledJava/sam/Runnable.fir.txt new file mode 100644 index 00000000000..c7851f11e7b --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/Runnable.fir.txt @@ -0,0 +1,4 @@ +public abstract interface Runnable : R|java/lang/Object| { + public abstract operator function run(): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/sam/SamSubinterfaceOfTwo.fir.txt b/compiler/testData/loadJava/compiledJava/sam/SamSubinterfaceOfTwo.fir.txt new file mode 100644 index 00000000000..4767d2a3f42 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/SamSubinterfaceOfTwo.fir.txt @@ -0,0 +1,2 @@ +public abstract interface SamSubinterfaceOfTwo : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/sam/SamSubinterfaceOverridding.fir.txt b/compiler/testData/loadJava/compiledJava/sam/SamSubinterfaceOverridding.fir.txt new file mode 100644 index 00000000000..157bb5c4ce2 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/SamSubinterfaceOverridding.fir.txt @@ -0,0 +1,4 @@ +public abstract interface SamSubinterfaceOverridding : R|java/lang/Runnable| { + public abstract operator function run(): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/sam/StaticOverrides.fir.txt b/compiler/testData/loadJava/compiledJava/sam/StaticOverrides.fir.txt new file mode 100644 index 00000000000..1cae5964d19 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/StaticOverrides.fir.txt @@ -0,0 +1,2 @@ +public final class StaticOverrides : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/sam/SubstitutedSamInterface.fir.txt b/compiler/testData/loadJava/compiledJava/sam/SubstitutedSamInterface.fir.txt new file mode 100644 index 00000000000..930e091952f --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/SubstitutedSamInterface.fir.txt @@ -0,0 +1,2 @@ +public abstract interface SubstitutedSamInterface : R|java/util/Comparator| { +} diff --git a/compiler/testData/loadJava/compiledJava/sam/SubstitutedSamInterfaceSubclassOfBuiltin.fir.txt b/compiler/testData/loadJava/compiledJava/sam/SubstitutedSamInterfaceSubclassOfBuiltin.fir.txt new file mode 100644 index 00000000000..fc3d6fe97b1 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/SubstitutedSamInterfaceSubclassOfBuiltin.fir.txt @@ -0,0 +1,2 @@ +public abstract interface SubstitutedSamInterfaceSubclassOfBuiltin : R|java/lang/Comparable| { +} diff --git a/compiler/testData/loadJava/compiledJava/sam/VarargParameter.fir.txt b/compiler/testData/loadJava/compiledJava/sam/VarargParameter.fir.txt new file mode 100644 index 00000000000..8f97358274b --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/VarargParameter.fir.txt @@ -0,0 +1,4 @@ +public abstract interface VarargParameter : R|java/lang/Object| { + public abstract operator function f(vararg strings: R|kotlin/Array>|): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/sam/adapters/AmbiguousAdapters.fir.txt b/compiler/testData/loadJava/compiledJava/sam/adapters/AmbiguousAdapters.fir.txt new file mode 100644 index 00000000000..c8e1b11fe8a --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/adapters/AmbiguousAdapters.fir.txt @@ -0,0 +1,6 @@ +public open class AmbiguousAdapters : R|java/lang/Object| { + public open operator function foo(r: R|ft|!): R|kotlin/Unit| + + public open operator function foo(c: R|ft|!): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/sam/adapters/Basic.fir.txt b/compiler/testData/loadJava/compiledJava/sam/adapters/Basic.fir.txt new file mode 100644 index 00000000000..b0a75992fcf --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/adapters/Basic.fir.txt @@ -0,0 +1,4 @@ +public open class Basic : R|java/lang/Object| { + public open operator function foo(r: R|ft|!): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/sam/adapters/Constructor.fir.txt b/compiler/testData/loadJava/compiledJava/sam/adapters/Constructor.fir.txt new file mode 100644 index 00000000000..cf214ee5e6d --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/adapters/Constructor.fir.txt @@ -0,0 +1,2 @@ +public open class Constructor : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/sam/adapters/ConstructorWithAnnotations.fir.txt b/compiler/testData/loadJava/compiledJava/sam/adapters/ConstructorWithAnnotations.fir.txt new file mode 100644 index 00000000000..957ff4e5829 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/adapters/ConstructorWithAnnotations.fir.txt @@ -0,0 +1,2 @@ +public open class ConstructorWithAnnotations : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/sam/adapters/DeepSamLoop.fir.txt b/compiler/testData/loadJava/compiledJava/sam/adapters/DeepSamLoop.fir.txt new file mode 100644 index 00000000000..1244d3abee2 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/adapters/DeepSamLoop.fir.txt @@ -0,0 +1,2 @@ +public abstract interface DeepSamLoop : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/sam/adapters/NoSamForClassTypeParameter.java b/compiler/testData/loadJava/compiledJava/sam/adapters/NoSamForClassTypeParameter.java index 9ca4c1a9bfa..c1d739589c3 100644 --- a/compiler/testData/loadJava/compiledJava/sam/adapters/NoSamForClassTypeParameter.java +++ b/compiler/testData/loadJava/compiledJava/sam/adapters/NoSamForClassTypeParameter.java @@ -1,3 +1,4 @@ +// SKIP_IN_FIR_TEST package test; class NoSamForTypeParameter { diff --git a/compiler/testData/loadJava/compiledJava/sam/adapters/NoSamForMethodTypeParameter.java b/compiler/testData/loadJava/compiledJava/sam/adapters/NoSamForMethodTypeParameter.java index 0b938967e81..000290a5808 100644 --- a/compiler/testData/loadJava/compiledJava/sam/adapters/NoSamForMethodTypeParameter.java +++ b/compiler/testData/loadJava/compiledJava/sam/adapters/NoSamForMethodTypeParameter.java @@ -1,3 +1,4 @@ +// SKIP_IN_FIR_TEST package test; class NoSamForTypeParameter { diff --git a/compiler/testData/loadJava/compiledJava/sam/adapters/NonTrivialFunctionType.fir.txt b/compiler/testData/loadJava/compiledJava/sam/adapters/NonTrivialFunctionType.fir.txt new file mode 100644 index 00000000000..1de1eb9cac8 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/adapters/NonTrivialFunctionType.fir.txt @@ -0,0 +1,10 @@ +public open class NonTrivialFunctionType : R|java/lang/Object| { + public open operator function foo(filenameFilter: R|ft|!): R|kotlin/Unit| + + public open operator function foo(comparator: R|ft>, java/util/Comparator>>|): R|kotlin/Unit| + + public open operator function wildcardUnbound(comparator: R|ft, java/util/Comparator?>|!): R|kotlin/Unit| + + public open operator function wildcardBound(comparator: R|ft, java/util/Comparator?>|!): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/sam/adapters/PrivateSamAdapter.fir.txt b/compiler/testData/loadJava/compiledJava/sam/adapters/PrivateSamAdapter.fir.txt new file mode 100644 index 00000000000..41bdba8e17c --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/adapters/PrivateSamAdapter.fir.txt @@ -0,0 +1,4 @@ +public open class PrivateSamAdapter : R|java/lang/Object| { + private open operator function samAdapter(r: R|ft|!): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/sam/adapters/SelfAsParameter.fir.txt b/compiler/testData/loadJava/compiledJava/sam/adapters/SelfAsParameter.fir.txt new file mode 100644 index 00000000000..60bdb91e153 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/adapters/SelfAsParameter.fir.txt @@ -0,0 +1,4 @@ +public abstract interface SelfAsParameter : R|java/lang/Object| { + public abstract operator function foo(p: R|ft|!): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/sam/adapters/SeveralSamParameters.fir.txt b/compiler/testData/loadJava/compiledJava/sam/adapters/SeveralSamParameters.fir.txt new file mode 100644 index 00000000000..22e1cbc704b --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/adapters/SeveralSamParameters.fir.txt @@ -0,0 +1,2 @@ +public open class SeveralSamParameters : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/sam/adapters/TypeParameterOfClass.fir.txt b/compiler/testData/loadJava/compiledJava/sam/adapters/TypeParameterOfClass.fir.txt new file mode 100644 index 00000000000..3d3f1d6f9e6 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/adapters/TypeParameterOfClass.fir.txt @@ -0,0 +1,4 @@ + public open class TypeParameterOfClass : R|java/lang/Object| { + public open operator function foo(comparator: R|ft>, java/util/Comparator>>|): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/sam/adapters/TypeParameterOfMethod.fir.txt b/compiler/testData/loadJava/compiledJava/sam/adapters/TypeParameterOfMethod.fir.txt new file mode 100644 index 00000000000..3aab61e5335 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/adapters/TypeParameterOfMethod.fir.txt @@ -0,0 +1,2 @@ +public open class TypeParameterOfMethod : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/sam/adapters/TypeParameterOfOuterClass.fir.txt b/compiler/testData/loadJava/compiledJava/sam/adapters/TypeParameterOfOuterClass.fir.txt new file mode 100644 index 00000000000..286eea9a948 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/adapters/TypeParameterOfOuterClass.fir.txt @@ -0,0 +1,2 @@ + public open class TypeParameterOfOuterClass : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/AdapterDoesntOverrideDeclaration.fir.txt b/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/AdapterDoesntOverrideDeclaration.fir.txt new file mode 100644 index 00000000000..78c4f5a26ce --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/AdapterDoesntOverrideDeclaration.fir.txt @@ -0,0 +1,2 @@ +public abstract interface AdapterDoesntOverrideDeclaration : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedAdapterAndDeclaration.fir.txt b/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedAdapterAndDeclaration.fir.txt new file mode 100644 index 00000000000..2600b6f049f --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedAdapterAndDeclaration.fir.txt @@ -0,0 +1,2 @@ +public abstract interface InheritedAdapterAndDeclaration : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedAmbiguousAdapters.fir.txt b/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedAmbiguousAdapters.fir.txt new file mode 100644 index 00000000000..002a525cf8c --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedAmbiguousAdapters.fir.txt @@ -0,0 +1,2 @@ +public abstract interface InheritedAmbiguousAdapters : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedAndOverriddenAmbiguousAdapters.fir.txt b/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedAndOverriddenAmbiguousAdapters.fir.txt new file mode 100644 index 00000000000..a0bab5fb57f --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedAndOverriddenAmbiguousAdapters.fir.txt @@ -0,0 +1,2 @@ +public abstract interface InheritedAndOverriddenAmbiguousAdapters : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedOverridden.fir.txt b/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedOverridden.fir.txt new file mode 100644 index 00000000000..ec883355e66 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedOverridden.fir.txt @@ -0,0 +1,2 @@ +public abstract interface InheritedOverridden : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedOverriddenAdapter.fir.txt b/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedOverriddenAdapter.fir.txt new file mode 100644 index 00000000000..0915987d8fc --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedOverriddenAdapter.fir.txt @@ -0,0 +1,2 @@ +public abstract interface InheritedOverriddenAdapter : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedSameAdapters.fir.txt b/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedSameAdapters.fir.txt new file mode 100644 index 00000000000..863f47c53da --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedSameAdapters.fir.txt @@ -0,0 +1,2 @@ +public abstract interface InheritedSameAdapters : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedSameAdaptersWithSubstitution.fir.txt b/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedSameAdaptersWithSubstitution.fir.txt new file mode 100644 index 00000000000..4cc3fcb9b90 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedSameAdaptersWithSubstitution.fir.txt @@ -0,0 +1,2 @@ +public abstract interface InheritedSameAdaptersWithSubstitution : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedSimple.fir.txt b/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedSimple.fir.txt new file mode 100644 index 00000000000..6e01f27bcf8 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedSimple.fir.txt @@ -0,0 +1,2 @@ +public abstract interface InheritedSimple : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/OverriddenAmbiguousAdapters.fir.txt b/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/OverriddenAmbiguousAdapters.fir.txt new file mode 100644 index 00000000000..a54145c6bc1 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/OverriddenAmbiguousAdapters.fir.txt @@ -0,0 +1,2 @@ +public abstract interface OverriddenAmbiguousAdapters : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/signatureAnnotations/StableName.fir.txt b/compiler/testData/loadJava/compiledJava/signatureAnnotations/StableName.fir.txt new file mode 100644 index 00000000000..29070999fd2 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/signatureAnnotations/StableName.fir.txt @@ -0,0 +1,4 @@ +public open class StableName : R|java/lang/Object| { + public open operator function connect(@R|kotlin/annotations/jvm/internal/ParameterName|(String(host)) host: R|ft|!): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/signaturePropagation/ArraysInSubtypes.fir.txt b/compiler/testData/loadJava/compiledJava/signaturePropagation/ArraysInSubtypes.fir.txt new file mode 100644 index 00000000000..340774f129f --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/signaturePropagation/ArraysInSubtypes.fir.txt @@ -0,0 +1,2 @@ +public abstract interface ArraysInSubtypes : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/signaturePropagation/MethodTypeParameterErased.fir.txt b/compiler/testData/loadJava/compiledJava/signaturePropagation/MethodTypeParameterErased.fir.txt new file mode 100644 index 00000000000..6805be9b4f9 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/signaturePropagation/MethodTypeParameterErased.fir.txt @@ -0,0 +1,2 @@ +public abstract interface MethodTypeParameterErased : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/signaturePropagation/RawSuperType.fir.txt b/compiler/testData/loadJava/compiledJava/signaturePropagation/RawSuperType.fir.txt new file mode 100644 index 00000000000..2cb98d2bb6f --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/signaturePropagation/RawSuperType.fir.txt @@ -0,0 +1,2 @@ +public open class RawSuperType : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/signaturePropagation/RawSuperTypeWithBound.fir.txt b/compiler/testData/loadJava/compiledJava/signaturePropagation/RawSuperTypeWithBound.fir.txt new file mode 100644 index 00000000000..bc416c462a8 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/signaturePropagation/RawSuperTypeWithBound.fir.txt @@ -0,0 +1,2 @@ +public open class RawSuperTypeWithBound : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/signaturePropagation/RawSuperTypeWithRecursiveBound.fir.txt b/compiler/testData/loadJava/compiledJava/signaturePropagation/RawSuperTypeWithRecursiveBound.fir.txt new file mode 100644 index 00000000000..d48c29369e2 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/signaturePropagation/RawSuperTypeWithRecursiveBound.fir.txt @@ -0,0 +1,2 @@ +public open class RawSuperTypeWithRecursiveBound : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/signaturePropagation/RawSuperTypeWithRecursiveBoundMultipleParameters.fir.txt b/compiler/testData/loadJava/compiledJava/signaturePropagation/RawSuperTypeWithRecursiveBoundMultipleParameters.fir.txt new file mode 100644 index 00000000000..75cd4f1a0f0 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/signaturePropagation/RawSuperTypeWithRecursiveBoundMultipleParameters.fir.txt @@ -0,0 +1,2 @@ +public open class RawSuperTypeWithRecursiveBoundMultipleParameters : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/signaturePropagation/ReturnInnerSubclassOfSupersInner.fir.txt b/compiler/testData/loadJava/compiledJava/signaturePropagation/ReturnInnerSubclassOfSupersInner.fir.txt new file mode 100644 index 00000000000..362ee7458b3 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/signaturePropagation/ReturnInnerSubclassOfSupersInner.fir.txt @@ -0,0 +1,2 @@ +public abstract interface ReturnInnerSubclassOfSupersInner : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/signaturePropagation/SubclassWithRawType.fir.txt b/compiler/testData/loadJava/compiledJava/signaturePropagation/SubclassWithRawType.fir.txt new file mode 100644 index 00000000000..ef81bbc9333 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/signaturePropagation/SubclassWithRawType.fir.txt @@ -0,0 +1,2 @@ +public abstract interface SubclassWithRawType : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/signaturePropagation/TwoSuperclassesInconsistentGenericTypes.fir.txt b/compiler/testData/loadJava/compiledJava/signaturePropagation/TwoSuperclassesInconsistentGenericTypes.fir.txt new file mode 100644 index 00000000000..a09b2bd816f --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/signaturePropagation/TwoSuperclassesInconsistentGenericTypes.fir.txt @@ -0,0 +1,6 @@ +public abstract interface TwoSuperclassesInconsistentGenericTypes : R|java/lang/Object| { + public abstract operator function foo(): R|ft>, java/util/List>>| + + public abstract operator function dummy(): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/static/DeeplyInnerClass.fir.txt b/compiler/testData/loadJava/compiledJava/static/DeeplyInnerClass.fir.txt new file mode 100644 index 00000000000..b61376fa13c --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/static/DeeplyInnerClass.fir.txt @@ -0,0 +1,2 @@ +public open class DeeplyInnerClass : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/static/DeeplyNestedStatic.fir.txt b/compiler/testData/loadJava/compiledJava/static/DeeplyNestedStatic.fir.txt new file mode 100644 index 00000000000..604f16af4db --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/static/DeeplyNestedStatic.fir.txt @@ -0,0 +1,2 @@ +public open class DeeplyNestedStatic : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/static/Enum.fir.txt b/compiler/testData/loadJava/compiledJava/static/Enum.fir.txt new file mode 100644 index 00000000000..7a5869031b2 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/static/Enum.fir.txt @@ -0,0 +1,2 @@ +public final enum class Enum : R|java/lang/Enum| { +} diff --git a/compiler/testData/loadJava/compiledJava/static/InnerClass.fir.txt b/compiler/testData/loadJava/compiledJava/static/InnerClass.fir.txt new file mode 100644 index 00000000000..7d2dfb582a1 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/static/InnerClass.fir.txt @@ -0,0 +1,2 @@ +public open class InnerClass : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/static/Simple.fir.txt b/compiler/testData/loadJava/compiledJava/static/Simple.fir.txt new file mode 100644 index 00000000000..8eba47f0b44 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/static/Simple.fir.txt @@ -0,0 +1,4 @@ +public open class Simple : R|java/lang/Object| { + public open operator function foo(): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/static/StaticFinal.fir.txt b/compiler/testData/loadJava/compiledJava/static/StaticFinal.fir.txt new file mode 100644 index 00000000000..2f511b0f65d --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/static/StaticFinal.fir.txt @@ -0,0 +1,2 @@ +public open class StaticFinal : R|java/lang/Object| { +} diff --git a/compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentClass.java b/compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentClass.java index d103214e59d..2e4645541f0 100644 --- a/compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentClass.java +++ b/compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentClass.java @@ -1,3 +1,4 @@ +// SKIP_IN_FIR_TEST package test; class Parent { diff --git a/compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentClassVisibility.java b/compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentClassVisibility.java index 3196e6a0aeb..ac00bb50080 100644 --- a/compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentClassVisibility.java +++ b/compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentClassVisibility.java @@ -1,3 +1,4 @@ +// SKIP_IN_FIR_TEST package test; class Parent { diff --git a/compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentInterface.java b/compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentInterface.java index d0b1396f89e..305cf2b7786 100644 --- a/compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentInterface.java +++ b/compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentInterface.java @@ -1,3 +1,4 @@ +// SKIP_IN_FIR_TEST package test; interface Parent1 { diff --git a/compiler/testData/loadJava/compiledJava/static/StaticMembersInEnum.fir.txt b/compiler/testData/loadJava/compiledJava/static/StaticMembersInEnum.fir.txt new file mode 100644 index 00000000000..b9e37a3f520 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/static/StaticMembersInEnum.fir.txt @@ -0,0 +1,2 @@ +public final enum class StaticMembersInEnum : R|java/lang/Enum| { +} diff --git a/compiler/testData/loadJava/compiledJava/static/StaticMembersInEnumFromParents.java b/compiler/testData/loadJava/compiledJava/static/StaticMembersInEnumFromParents.java index da03b3c7214..5d35e8ea1f8 100644 --- a/compiler/testData/loadJava/compiledJava/static/StaticMembersInEnumFromParents.java +++ b/compiler/testData/loadJava/compiledJava/static/StaticMembersInEnumFromParents.java @@ -1,3 +1,4 @@ +// SKIP_IN_FIR_TEST package test; interface Parent1 { diff --git a/compiler/testData/loadJava/compiledJava/vararg/VarargInt.fir.txt b/compiler/testData/loadJava/compiledJava/vararg/VarargInt.fir.txt new file mode 100644 index 00000000000..902a4830538 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/vararg/VarargInt.fir.txt @@ -0,0 +1,4 @@ +public open class VarargInt : R|java/lang/Object| { + public open operator function vararg(vararg p: R|kotlin/IntArray|): R|kotlin/Unit| + +} diff --git a/compiler/testData/loadJava/compiledJava/vararg/VarargString.fir.txt b/compiler/testData/loadJava/compiledJava/vararg/VarargString.fir.txt new file mode 100644 index 00000000000..4a23fab171e --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/vararg/VarargString.fir.txt @@ -0,0 +1,4 @@ +public open class VarargString : R|java/lang/Object| { + public open operator function vararg(vararg strings: R|kotlin/Array>|): R|kotlin/Unit| + +} diff --git a/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt b/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt index 3a8d8985578..30cc8289b58 100644 --- a/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt +++ b/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt @@ -20,6 +20,7 @@ import org.jetbrains.kotlin.codegen.ir.* import org.jetbrains.kotlin.fir.AbstractFirResolveTestCase import org.jetbrains.kotlin.fir.AbstractFirResolveTestCaseWithStdlib import org.jetbrains.kotlin.fir.builder.AbstractRawFirBuilderTestCase +import org.jetbrains.kotlin.fir.java.AbstractFirTypeEnhancementTest import org.jetbrains.kotlin.generators.tests.generator.testGroup import org.jetbrains.kotlin.generators.util.KT_OR_KTS_WITHOUT_DOTS_IN_NAME import org.jetbrains.kotlin.generators.util.KT_WITHOUT_DOTS_IN_NAME @@ -396,4 +397,10 @@ fun main(args: Array) { model("resolve/stdlib", pattern = KT_WITHOUT_DOTS_IN_NAME) } } + + testGroup("compiler/fir/resolve/tests", "compiler/testData") { + testClass { + model("loadJava/compiledJava", extension = "java") + } + } }